@curvefi/api 2.61.15 → 2.63.0

package/README.md

@@ -1607,7 +1607,9 @@ import curve from "@curvefi/api";
     // factory-v2-221
     const pool = curve.getPool(poolId);
 
-    await pool.depositAndStake([10, 10, 10]); // Initial amounts for stable pool must be equal
+    const amounts = await pool.getSeedAmounts(10);
+    // [ '10.0', '10.0', '10.0' ]
+    await pool.depositAndStake(amounts);
     const balances = await pool.stats.underlyingBalances();
     // [ '10.0', '10.0', '10.0' ]
 })()
@@ -1748,17 +1750,19 @@ import curve from "@curvefi/api";
     const pool = curve.getPool(poolId);
 
     // Deposit & Stake Wrapped
-    
-    await pool.depositAndStakeWrapped([10, 10]); // Initial wrapped amounts for stable metapool must be equal
+
+    const amounts = await pool.getSeedAmounts(10);
+    // [ '10', '9.666800376685890985' ]
+    await pool.depositAndStakeWrapped(amounts);
     const balances = await pool.stats.wrappedBalances();
-    // [ '10.0', '10.0' ]
+    // [ '10', '9.666800376685890985' ]
 
     // Or deposit & Stake Underlying
 
-    // const amounts = pool.metaUnderlyingSeedAmounts(30);
-    // [ '30', '10.000000000000000000', '10.000000', '10.000000' ]
+    // const amounts = pool.getSeedAmounts(10, true);  // useUnderlying = true
+    // [ '10', '3.690404151768511181', '3.713621', '2.595975' ]
     // await pool.depositAndStake(amounts);
-    // [ '30.0', '9.272021785560442569', '8.927595', '11.800485' ]
+    // [ '10', '3.690404151768511181', '3.713621', '2.595975' ]
 })()
 ```
 
@@ -1891,7 +1895,7 @@ import curve from "@curvefi/api";
     // factory-crypto-155
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.02' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();
@@ -1943,7 +1947,7 @@ import curve from "@curvefi/api";
     // factory-twocrypto-155
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.02' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();
@@ -2030,7 +2034,7 @@ import curve from "@curvefi/api";
     // factory-tricrypto-2
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.017647058823529412', '0.00111111' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();

package/lib/constants/aliases.js

@@ -228,23 +228,23 @@ export var ALIASES_CELO = lowerCaseValues({
     "factory_admin": "",
 });
 export var ALIASES_ZKSYNC = lowerCaseValues({
-    "crv": "0x0a7432cF27F1aE3825c313F3C81e7D3efD7639aB",
+    "crv": "0x5945932099f124194452a4c62d34bB37f16183B2",
     "gauge_factory": "0x0000000000000000000000000000000000000000",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
-    "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
-    "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
-    "address_provider": "0x0000000022d53366457f9d5e68ec105046fc4383",
+    "fee_distributor": "0x0000000000000000000000000000000000000000",
+    "gauge_controller": "0x0000000000000000000000000000000000000000",
+    "address_provider": "0x0000000000000000000000000000000000000000",
     "router": "0x7C915390e109CA66934f1eB285854375D1B127FA",
-    "deposit_and_stake": "0x0000000000000000000000000000000000000000",
+    "deposit_and_stake": "0x253548e98C769aD2850da8DB3E4c2b2cE46E3839",
     "stable_calc": "0x0000000000000000000000000000000000000000",
     "crypto_calc": '0x0000000000000000000000000000000000000000',
-    "factory": '0xAF5261eD780fd5b80CF6E206b6BF90CbB97F511B',
-    "crvusd_factory": '0x4F8846Ae9380B90d2E71D5e3D042dff3E7ebb40d',
-    "eywa_factory": '0x37F22A0B028f2152e6CAcef210e0C4d3b875f367',
-    "crypto_factory": '0xF18056Bbd320E96A48e3Fbf8bC061322531aac99',
-    "twocrypto_factory": '0x0000000000000000000000000000000000000000',
-    "tricrypto_factory": '0x0c0e5f2fF0ff18a3be9b835635039256dC4B4963',
-    "stable_ng_factory": '0x0000000000000000000000000000000000000000',
+    "factory": '0x0000000000000000000000000000000000000000',
+    "crvusd_factory": '0x0000000000000000000000000000000000000000',
+    "eywa_factory": '0x0000000000000000000000000000000000000000',
+    "crypto_factory": '0x0000000000000000000000000000000000000000',
+    "twocrypto_factory": '0xf3a546AF64aFd6BB8292746BA66DB33aFAE72114',
+    "tricrypto_factory": '0x5d4174C40f1246dABe49693845442927d5929f0D',
+    "stable_ng_factory": '0xFcAb5d04e8e031334D5e8D2C166B08daB0BE6CaE',
     "factory_admin": "0x0000000000000000000000000000000000000000",
 });
 export var ALIASES_BASE = lowerCaseValues({

package/lib/constants/tricryptoDeployImplementations.js

@@ -40,8 +40,8 @@ export var tricryptoDeployImplementations = {
         implementationIdx: 1,
     },
     324: {
-        amm_native_transfers_disabled: '0x0000000000000000000000000000000000000000'.toLowerCase(),
-        amm_native_transfers_enabled: '0x0000000000000000000000000000000000000000'.toLowerCase(),
+        amm_native_transfers_disabled: '0x1BD7d40CF9bBb63537746C89992f421bC35C6716'.toLowerCase(),
+        amm_native_transfers_enabled: '0x18d01726FeDaBd91579A9368DFB2F8A24f905280'.toLowerCase(),
         implementationIdx: 0,
     },
     1284: {

package/lib/curve.js

@@ -432,7 +432,7 @@ var Curve = /** @class */ (function () {
                 return __generator(this, function (_h) {
                     switch (_h.label) {
                         case 0:
-                            if ([196, 252, 5000, 1313161554].includes(this.chainId))
+                            if ([196, 252, 324, 5000, 1313161554].includes(this.chainId))
                                 return [2 /*return*/];
                             if (!useApi) return [3 /*break*/, 2];
                             _a = this.constants;
@@ -578,7 +578,7 @@ var Curve = /** @class */ (function () {
                 return __generator(this, function (_h) {
                     switch (_h.label) {
                         case 0:
-                            if ([324, 1284].includes(this.chainId))
+                            if ([1284].includes(this.chainId))
                                 return [2 /*return*/];
                             if (!useApi) return [3 /*break*/, 2];
                             _a = this.constants;
@@ -617,7 +617,7 @@ var Curve = /** @class */ (function () {
                 return __generator(this, function (_k) {
                     switch (_k.label) {
                         case 0:
-                            if ([324, 1284].includes(this.chainId))
+                            if ([1284].includes(this.chainId))
                                 return [2 /*return*/];
                             if (!useApi) return [3 /*break*/, 2];
                             _a = this.constants;
@@ -754,7 +754,7 @@ var Curve = /** @class */ (function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if ([324, 1284].includes(this.chainId))
+                        if ([1284].includes(this.chainId))
                             return [2 /*return*/, []];
                         currentPoolIds = Object.keys(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA);
                         lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
@@ -773,7 +773,7 @@ var Curve = /** @class */ (function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if ([324, 1284].includes(this.chainId))
+                        if ([1284].includes(this.chainId))
                             return [2 /*return*/, []];
                         currentPoolIds = Object.keys(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
                         lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
@@ -843,7 +843,7 @@ var Curve = /** @class */ (function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if ([324, 1284].includes(this.chainId))
+                        if ([1284].includes(this.chainId))
                             return [2 /*return*/, ''];
                         _a = lowerCasePoolDataAddresses;
                         return [4 /*yield*/, getTwocryptoFactoryPoolData.call(this, 0, poolAddress)];
@@ -860,7 +860,7 @@ var Curve = /** @class */ (function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if ([324, 1284].includes(this.chainId))
+                        if ([1284].includes(this.chainId))
                             return [2 /*return*/, ''];
                         _a = lowerCasePoolDataAddresses;
                         return [4 /*yield*/, getTricryptoFactoryPoolData.call(this, 0, poolAddress)];
@@ -1141,7 +1141,7 @@ var Curve = /** @class */ (function () {
                         this.setContract(this.constants.ALIASES.crypto_calc, cryptoCalcZapABI);
                         this.setContract(this.constants.ALIASES.stable_calc, StableCalcZapABI);
                         this.setContract(this.constants.ALIASES.factory, factoryABI);
-                        if (!(this.chainId !== 1313161554 && this.chainId !== 252 && this.chainId !== 196 && this.chainId !== 5000)) return [3 /*break*/, 19];
+                        if (!(this.chainId !== 1313161554 && this.chainId !== 252 && this.chainId !== 324 && this.chainId !== 196 && this.chainId !== 5000)) return [3 /*break*/, 19];
                         factoryContract = this.contracts[this.constants.ALIASES.factory].contract;
                         _o = this.constants.ALIASES;
                         return [4 /*yield*/, factoryContract.admin(this.constantOptions)];

package/lib/factory/constants.js

@@ -291,18 +291,8 @@ export var implementationABIDictCelo = lowerCaseKeys({
     "0xa7b9d886A9a374A1C86DC52d2BA585c5CDFdac26": MetaStableSwapNGABI,
 });
 export var implementationABIDictZkSync = lowerCaseKeys({
-    "0x7c2a205C52361410233540008f7095dEF5915843": Plain2BasicABI,
-    "0xEF04fC6b95b1658AfdFd527aF9b947cd7BD46bde": Plain2BalancesABI,
-    "0x4887ef1a68f30364a25a8b0bAA13EeeA7eeBE574": Plain2ETHABI,
-    "0x044f8F31078c0CB898f25fff3286cE905C18434e": Plain2OptimizedABI,
-    "0x2e6De7148Afc6e4B1ee766D070DDeff0C84831a5": Plain3BasicABI,
-    "0x5D18b28C052Bb0C1573d90Ea055b13048026d83F": Plain3BalancesABI,
-    "0x9707Bbf96eBB136B67788aa7E46d771Ec18895f4": Plain3ETHABI,
-    "0xb274f2cdCff70A0bac146e9Ca5a8a28f59a3f812": Plain3OptimizedABI,
-    "0x30eb3F0EF60993584e8dD231dF7539db31800555": Plain4BasicABI,
-    "0x3D21E268d6A526948e978ad1595052c949927e54": Plain4BalancesABI,
-    "0xD46aed59fBd5eB6c134b1AFb364240bb62dA0451": Plain4ETHABI,
-    "0xE80AeF1a4782eA7b7f9Ad9F0c2ed9343861934e3": Plain4OptimizedABI,
+    "0x04D0095a1A4Ae881a078ae61F36945E85464e6d7": PlainStableSwapNGABI,
+    "0xC5d5402481aefec461Ab86b1051AC26dF05BeE3B": MetaStableSwapNGABI,
 });
 export var implementationABIDictBase = lowerCaseKeys({
     "0xD166EEdf272B860E991d331B71041799379185D5": Plain2BasicABI,

package/lib/pools/PoolTemplate.d.ts

@@ -112,8 +112,7 @@ export declare class PoolTemplate {
     private _calcLpTokenAmount;
     private calcLpTokenAmount;
     private calcLpTokenAmountWrapped;
-    metaUnderlyingSeedAmounts(amount1: number | string): string[];
-    cryptoSeedAmounts(amount1: number | string): Promise<string[]>;
+    getSeedAmounts(amount1: number | string, useUnderlying?: boolean): Promise<string[]>;
     depositBalancedAmounts(): Promise<string[]>;
     depositExpected(amounts: (number | string)[]): Promise<string>;
     private _balancedAmountsWithSameValue;
@@ -260,7 +259,7 @@ export declare class PoolTemplate {
     private _getCoinIdx;
     private _getRates;
     private _balances;
-    private _stored_rates;
+    private _storedRatesBN;
     private _underlyingPrices;
     private _wrappedPrices;
     private getGaugeStatus;

package/lib/pools/PoolTemplate.js

@@ -412,7 +412,7 @@ var PoolTemplate = /** @class */ (function () {
             if (isDeposit === void 0) { isDeposit = true; }
             if (useUnderlying === void 0) { useUnderlying = true; }
             return __awaiter(_this, void 0, void 0, function () {
-                var e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, contract, basePool, e_3, lpContract, _lpTotalSupply, decimals_2, amounts_1, seedAmounts_2, _amounts18Decimals;
+                var e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, contract, basePool, e_3, lpContract, _lpTotalSupply, decimals_2, amounts, seedAmounts_2, _amounts18Decimals;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
@@ -434,7 +434,7 @@ var PoolTemplate = /** @class */ (function () {
                                 throw Error("Initial deposit for crypto meta pools must be in wrapped coins");
                             decimals_1 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
                             amounts = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_1[i]); });
-                            return [4 /*yield*/, this.cryptoSeedAmounts(amounts[0])];
+                            return [4 /*yield*/, this.getSeedAmounts(amounts[0])];
                         case 5:
                             seedAmounts_1 = _c.sent();
                             amounts.forEach(function (a, i) {
@@ -443,7 +443,7 @@ var PoolTemplate = /** @class */ (function () {
                             });
                             return [2 /*return*/, parseUnits(Math.pow(amounts.map(Number).reduce(function (a, b) { return a * b; }), 1 / amounts.length))];
                         case 6:
-                            _c.trys.push([6, 13, , 15]);
+                            _c.trys.push([6, 13, , 16]);
                             contract = curve.contracts[curve.constants.ALIASES.stable_calc].contract;
                             if (!(curve.constants.ALIASES.stable_calc === curve.constants.ZERO_ADDRESS || this.id.startsWith("factory-stable-ng"))) return [3 /*break*/, 8];
                             return [4 /*yield*/, this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying)];
@@ -455,7 +455,7 @@ var PoolTemplate = /** @class */ (function () {
                         case 9: return [2 /*return*/, _c.sent()];
                         case 10: return [4 /*yield*/, contract.calc_token_amount(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, isDeposit, useUnderlying && this.isLending)];
                         case 11: return [2 /*return*/, _c.sent()];
-                        case 12: return [3 /*break*/, 15];
+                        case 12: return [3 /*break*/, 16];
                         case 13:
                             e_3 = _c.sent();
                             if (!isDeposit)
@@ -467,25 +467,17 @@ var PoolTemplate = /** @class */ (function () {
                             if (_lpTotalSupply > curve.parseUnits("0"))
                                 throw e_3; // Already seeded
                             decimals_2 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                            amounts_1 = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_2[i]); });
-                            if (this.isMeta && useUnderlying) {
-                                seedAmounts_2 = this.metaUnderlyingSeedAmounts(amounts_1[0]);
-                                amounts_1.forEach(function (a, i) {
-                                    if (!BN(a).eq(BN(seedAmounts_2[i])))
-                                        throw Error("Amounts must be = ".concat(seedAmounts_2));
-                                });
-                            }
-                            else {
-                                if (_amounts[0] <= curve.parseUnits("0"))
-                                    throw Error("Initial deposit amounts must be > 0");
-                                amounts_1.forEach(function (a) {
-                                    if (a !== amounts_1[0])
-                                        throw Error("Initial deposit amounts must be equal");
-                                });
-                            }
-                            _amounts18Decimals = amounts_1.map(function (a) { return parseUnits(a); });
+                            amounts = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_2[i]); });
+                            return [4 /*yield*/, this.getSeedAmounts(amounts[0])];
+                        case 15:
+                            seedAmounts_2 = _c.sent();
+                            amounts.forEach(function (a, i) {
+                                if (!BN(a).eq(BN(seedAmounts_2[i])))
+                                    throw Error("Amounts must be = ".concat(seedAmounts_2));
+                            });
+                            _amounts18Decimals = amounts.map(function (a) { return parseUnits(a); });
                             return [2 /*return*/, _amounts18Decimals.reduce(function (_a, _b) { return _a + _b; })];
-                        case 15: return [2 /*return*/];
+                        case 16: return [2 /*return*/];
                     }
                 });
             });
@@ -1110,11 +1102,27 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
-        this._stored_rates = function () { return __awaiter(_this, void 0, void 0, function () {
+        this._storedRatesBN = function (useUnderlying) { return __awaiter(_this, void 0, void 0, function () {
+            var _vp, isUseStoredRates, _stored_rates;
+            var _this = this;
             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()];
+                    case 0:
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        if (useUnderlying)
+                            return [2 /*return*/, this.underlyingCoins.map(function () { return BN(1); })];
+                        return [4 /*yield*/, curve.contracts[curve.getPoolsData()[this.basePool].swap_address].contract.get_virtual_price()];
+                    case 1:
+                        _vp = _c.sent();
+                        return [2 /*return*/, [BN(1), toBN(_vp)]];
+                    case 2:
+                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        if (!isUseStoredRates) return [3 /*break*/, 4];
+                        return [4 /*yield*/, curve.contracts[this.address].contract.stored_rates()];
+                    case 3:
+                        _stored_rates = _c.sent();
+                        return [2 /*return*/, _stored_rates.map(function (_r, i) { return toBN(_r, 36 - _this.wrappedDecimals[i]); })];
+                    case 4: return [2 /*return*/, this.wrappedCoins.map(function () { return BN(1); })];
                 }
             });
         }); };
@@ -1374,32 +1382,18 @@ var PoolTemplate = /** @class */ (function () {
         });
     };
     // ---------------- DEPOSIT ----------------
-    PoolTemplate.prototype.metaUnderlyingSeedAmounts = function (amount1) {
-        if (this.isCrypto)
-            throw Error("Use cryptoSeedAmounts method for ".concat(this.name, " pool"));
-        if (!this.isMeta)
-            throw Error("metaUnderlyingSeedAmounts method exists only for meta stable pools");
-        var amount1BN = BN(amount1);
-        if (amount1BN.lte(0))
-            throw Error("Initial deposit amounts must be > 0");
-        var amounts = [_cutZeros(amount1BN.toFixed(this.underlyingDecimals[0]))];
-        for (var i = 1; i < this.underlyingDecimals.length; i++) {
-            amounts.push(amount1BN.div(this.underlyingDecimals.length - 1).toFixed(this.underlyingDecimals[i]));
-        }
-        return amounts;
-    };
-    PoolTemplate.prototype.cryptoSeedAmounts = function (amount1) {
+    PoolTemplate.prototype.getSeedAmounts = function (amount1, useUnderlying) {
+        if (useUnderlying === void 0) { useUnderlying = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var decimals, amount1BN, priceScaleBN, _c, priceScaleBN;
+            var amount1BN, decimals, priceScaleBN, _c, priceScaleBN, amounts, basePool, basePoolBalancesBN, totalBN, i, storedRatesBN, i;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        if (!this.isCrypto)
-                            throw Error("cryptoSeedAmounts method doesn't exist for stable pools");
-                        decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
                         amount1BN = BN(amount1);
                         if (amount1BN.lte(0))
                             throw Error("Initial deposit amounts must be > 0");
+                        if (!this.isCrypto) return [3 /*break*/, 5];
+                        decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
                         if (!(decimals.length === 2)) return [3 /*break*/, 2];
                         _c = toBN;
                         return [4 /*yield*/, curve.contracts[this.address].contract.price_scale(curve.constantOptions)];
@@ -1419,7 +1413,26 @@ var PoolTemplate = /** @class */ (function () {
                                 _cutZeros(amount1BN.div(priceScaleBN[0]).toFixed(decimals[1])),
                                 _cutZeros(amount1BN.div(priceScaleBN[1]).toFixed(decimals[2])),
                             ]];
-                    case 4: throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 3");
+                    case 4: throw Error("getSeedAmounts method doesn't exist for crypto pools with N coins > 3");
+                    case 5:
+                        amounts = [_cutZeros(amount1BN.toFixed(this.wrappedDecimals[0]))];
+                        if (!(this.isMeta && useUnderlying)) return [3 /*break*/, 7];
+                        basePool = new PoolTemplate(this.basePool);
+                        return [4 /*yield*/, basePool.stats.underlyingBalances()];
+                    case 6:
+                        basePoolBalancesBN = (_d.sent()).map(BN);
+                        totalBN = basePoolBalancesBN.reduce(function (a, b) { return a.plus(b); });
+                        for (i = 1; i < this.underlyingDecimals.length; i++) {
+                            amounts.push(amount1BN.times(basePoolBalancesBN[i - 1]).div(totalBN).toFixed(this.underlyingDecimals[i]));
+                        }
+                        return [2 /*return*/, amounts.map(_cutZeros)];
+                    case 7: return [4 /*yield*/, this._storedRatesBN(false)];
+                    case 8:
+                        storedRatesBN = _d.sent();
+                        for (i = 1; i < this.wrappedDecimals.length; i++) {
+                            amounts.push(amount1BN.times(storedRatesBN[0]).div(storedRatesBN[i]).toFixed(this.wrappedDecimals[i]));
+                        }
+                        return [2 /*return*/, amounts.map(_cutZeros)];
                 }
             });
         });
@@ -1470,46 +1483,34 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.depositBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, prices, isUseStoredRates, result, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
-            var _this = this;
+            var amountsBN, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
                         amountsBN = amounts.map(BN);
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _e.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_e.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        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;
+                        pricesBN = _e.sent();
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, this.stats.underlyingBalances()];
                     case 5:
-                        pricesBN = prices.map(BN);
-                        return [4 /*yield*/, this.stats.underlyingBalances()];
-                    case 6:
                         balancesBN = (_e.sent()).map(BN);
                         balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
                         _c = BN;
                         return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 7:
+                    case 6:
                         expectedBN = _c.apply(void 0, [_e.sent()]);
                         _d = BN;
                         return [4 /*yield*/, this.depositExpected(balancedAmounts)];
-                    case 8:
+                    case 7:
                         balancedExpectedBN = _d.apply(void 0, [_e.sent()]);
-                        return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
+                        return [2 /*return*/, expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100).toString()];
                 }
             });
         });
@@ -2468,40 +2469,30 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.withdrawImbalanceBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var prices, isUseStoredRates, result, value, lpTokenAmount, balancedAmounts, balancedValue;
-            var _this = this;
+            var pricesBN, valueBN, lpTokenAmount, balancedAmounts, balancedValueBN;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _c.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_c.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        result = _c.sent();
-                        result.forEach(function (item, index) {
-                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
-                        });
-                        return [3 /*break*/, 5];
+                        pricesBN = _c.sent();
+                        _c.label = 4;
                     case 4:
-                        prices = this.underlyingCoins.map(function () { return 1; });
-                        _c.label = 5;
-                    case 5:
-                        value = amounts.map(checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        valueBN = amounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
                         return [4 /*yield*/, this.withdrawImbalanceExpected(amounts)];
-                    case 6:
+                    case 5:
                         lpTokenAmount = _c.sent();
                         return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 7:
+                    case 6:
                         balancedAmounts = _c.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
+                        balancedValueBN = balancedAmounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
+                        return [2 /*return*/, valueBN.minus(balancedValueBN).div(balancedValueBN).times(100).toString()];
                 }
             });
         });
@@ -2666,42 +2657,32 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.withdrawOneCoinBonus = function (lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function () {
-            var prices, isUseStoredRates, result, coinPrice, amount, _c, value, balancedAmounts, balancedValue;
-            var _this = this;
+            var pricesBN, coinPriceBN, amountBN, _c, valueBN, balancedAmounts, balancedValueBN;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_d.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        result = _d.sent();
-                        result.forEach(function (item, index) {
-                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
-                        });
-                        return [3 /*break*/, 5];
+                        pricesBN = _d.sent();
+                        _d.label = 4;
                     case 4:
-                        prices = this.underlyingCoins.map(function () { return 1; });
-                        _d.label = 5;
-                    case 5:
-                        coinPrice = prices[this._getCoinIdx(coin)];
-                        _c = Number;
+                        coinPriceBN = pricesBN[this._getCoinIdx(coin)];
+                        _c = BN;
                         return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
-                    case 6:
-                        amount = _c.apply(void 0, [_d.sent()]);
-                        value = amount * coinPrice;
+                    case 5:
+                        amountBN = _c.apply(void 0, [_d.sent()]);
+                        valueBN = amountBN.times(coinPriceBN);
                         return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 7:
+                    case 6:
                         balancedAmounts = _d.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
+                        balancedValueBN = balancedAmounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
+                        return [2 /*return*/, valueBN.minus(balancedValueBN).div(balancedValueBN).times(100).toString()];
                 }
             });
         });

package/lib/utils.js

@@ -69,7 +69,7 @@ export var ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 export var MAX_ALLOWANCE = BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639935"); // 2**256 - 1
 // Formatting numbers
 export var _cutZeros = function (strn) {
-    return strn.replace(/0+$/gi, '').replace(/\.$/gi, '');
+    return strn.replace(/(\.\d*[1-9])0+$/gi, '$1').replace(/\.0+$/gi, '');
 };
 export var checkNumber = function (n) {
     if (Number(n) !== Number(n))
@@ -774,21 +774,25 @@ export var getGasPriceFromL2 = function () { return __awaiter(void 0, void 0, vo
                 return [4 /*yield*/, getGasPrice()]; // gwei
             case 3: return [2 /*return*/, _a.sent()]; // gwei
             case 4:
-                if (!(curve.chainId === 5000)) return [3 /*break*/, 6];
+                if (!(curve.chainId === 324)) return [3 /*break*/, 6];
                 return [4 /*yield*/, getGasPrice()]; // gwei
             case 5: return [2 /*return*/, _a.sent()]; // gwei
             case 6:
-                if (!L2Networks.includes(curve.chainId)) return [3 /*break*/, 8];
+                if (!(curve.chainId === 5000)) return [3 /*break*/, 8];
+                return [4 /*yield*/, getGasPrice()]; // gwei
+            case 7: return [2 /*return*/, _a.sent()]; // gwei
+            case 8:
+                if (!L2Networks.includes(curve.chainId)) return [3 /*break*/, 10];
                 return [4 /*yield*/, curve.contracts[curve.constants.ALIASES.gas_oracle_blob].contract.gasPrice({ "gasPrice": "0x2000000" })];
-            case 7:
+            case 9:
                 gasPrice = _a.sent();
                 return [2 /*return*/, Number(gasPrice)];
-            case 8: throw Error("This method exists only for L2 networks");
+            case 10: throw Error("This method exists only for L2 networks");
         }
     });
 }); };
 export var getGasInfoForL2 = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var baseFee, gasPrice, baseFee;
+    var baseFee, gasPrice, gasPrice, baseFee;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -809,15 +813,23 @@ export var getGasInfoForL2 = function () { return __awaiter(void 0, void 0, void
                         gasPrice: gasPrice,
                     }];
             case 4:
-                if (!(curve.chainId === 5000)) return [3 /*break*/, 6];
-                return [4 /*yield*/, getBaseFeeByLastBlock()];
+                if (!(curve.chainId === 324)) return [3 /*break*/, 6];
+                return [4 /*yield*/, getGasPrice()];
             case 5:
+                gasPrice = _a.sent();
+                return [2 /*return*/, {
+                        gasPrice: gasPrice,
+                    }];
+            case 6:
+                if (!(curve.chainId === 5000)) return [3 /*break*/, 8];
+                return [4 /*yield*/, getBaseFeeByLastBlock()];
+            case 7:
                 baseFee = _a.sent();
                 return [2 /*return*/, {
                         maxFeePerGas: Number(((baseFee * 1.1) + 0.01).toFixed(2)),
                         maxPriorityFeePerGas: 0.01,
                     }];
-            case 6: throw Error("This method exists only for L2 networks");
+            case 8: throw Error("This method exists only for L2 networks");
         }
     });
 }); };

package/package.json

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