@curvefi/api 2.57.1 → 2.57.3

package/lib/curve.js

@@ -54,8 +54,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { ethers, Contract, AbstractProvider } from "ethers";
-import { Provider as MulticallProvider, Contract as MulticallContract } from 'ethcall';
+import { ethers, AbstractProvider, } from "ethers";
+import { Provider as MulticallProvider } from 'ethcall';
 import { getFactoryPoolData } from "./factory/factory.js";
 import { getFactoryPoolsDataFromApi } from "./factory/factory-api.js";
 import { getCryptoFactoryPoolData } from "./factory/factory-crypto.js";
@@ -111,6 +111,7 @@ import { lowerCasePoolDataAddresses, extractDecimals, extractGauges } from "./co
 import { _getAllGauges, _getHiddenPools } from "./external-api.js";
 import { L2Networks } from "./constants/L2Networks.js";
 import { getTwocryptoFactoryPoolData } from "./factory/factory-twocrypto";
+import { initContract, initMulticallContract } from "./utils.js";
 var _killGauges = function (poolsData) { return __awaiter(void 0, void 0, void 0, function () {
     var gaugeData, isKilled, gaugeStatuses, poolId;
     return __generator(this, function (_a) {
@@ -1179,10 +1180,26 @@ var Curve = /** @class */ (function () {
         });
     };
     Curve.prototype.setContract = function (address, abi) {
-        this.contracts[address] = {
-            contract: new Contract(address, abi, this.signer || this.provider),
-            multicallContract: new MulticallContract(address, abi),
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        var curveInstance = this;
+        var proxyHandler = {
+            get: function (target, name) {
+                if (name === 'contract') {
+                    return initContract(target['address'], target['abi'], curveInstance.signer || curveInstance.provider);
+                }
+                else if (name === 'multicallContract') {
+                    return initMulticallContract(target['address'], target['abi']);
+                }
+                else {
+                    return target[name];
+                }
+            },
+        };
+        var coreContract = {
+            address: address,
+            abi: abi,
         };
+        this.contracts[address] = new Proxy(coreContract, proxyHandler);
     };
     Curve.prototype._filterHiddenPools = function (pools) {
         return __awaiter(this, void 0, void 0, function () {

package/lib/index.d.ts

@@ -38,7 +38,7 @@ declare const curve: {
         price: number;
     }[][]>;
     PoolTemplate: typeof PoolTemplate;
-    getBasePools: () => import("./interfaces.js").IBasePoolShortItem[];
+    getBasePools: () => Promise<import("./interfaces.js").IBasePoolShortItem[]>;
     getPool: (poolId: string) => PoolTemplate;
     getUsdRate: (coin: string) => Promise<number>;
     getGasPriceFromL1: () => Promise<number>;

package/lib/utils.d.ts

@@ -1,4 +1,5 @@
-import { Contract } from 'ethers';
+import { BrowserProvider, Contract, JsonRpcProvider, Signer } from 'ethers';
+import { Contract as MulticallContract } from "ethcall";
 import BigNumber from 'bignumber.js';
 import { IBasePoolShortItem, IChainId, IDict, INetworkName, IRewardFromApi, IVolumeAndAPYs, REFERENCE_ASSET } from './interfaces';
 export declare const ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -64,4 +65,6 @@ export declare const isMethodExist: (contract: Contract, methodName: string) =>
 export declare const getPoolName: (name: string) => string;
 export declare const isStableNgPool: (name: string) => boolean;
 export declare const assetTypeNameHandler: (assetTypeName: string) => REFERENCE_ASSET;
-export declare const getBasePools: () => IBasePoolShortItem[];
+export declare const getBasePools: () => Promise<IBasePoolShortItem[]>;
+export declare const initContract: (address: string, abi: any, provider: BrowserProvider | JsonRpcProvider | Signer) => Contract;
+export declare const initMulticallContract: (address: string, abi: any) => MulticallContract;

package/lib/utils.js

@@ -970,15 +970,65 @@ export var assetTypeNameHandler = function (assetTypeName) {
         return assetTypeName.toUpperCase();
     }
 };
-export var getBasePools = function () {
-    return Object.keys(curve.constants.BASE_POOLS).map(function (poolId) {
-        var pool = getPool(poolId);
-        return {
-            id: poolId,
-            name: pool.name,
-            pool: pool.address,
-            token: pool.lpToken,
-            coins: pool.underlyingCoinAddresses,
-        };
+export var getBasePools = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var factoryContract, factoryMulticallContract, basePoolCount, _a, _b, _c, calls, i, basePoolList, pools, basePoolIds;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                factoryContract = curve.contracts[curve.constants.ALIASES['stable_ng_factory']].contract;
+                factoryMulticallContract = curve.contracts[curve.constants.ALIASES['stable_ng_factory']].multicallContract;
+                _a = Number;
+                _c = (_b = curve).formatUnits;
+                return [4 /*yield*/, factoryContract.base_pool_count(curve.constantOptions)];
+            case 1:
+                basePoolCount = _a.apply(void 0, [_c.apply(_b, [_d.sent(), 0])]);
+                calls = [];
+                for (i = 0; i < basePoolCount; i++) {
+                    calls.push(factoryMulticallContract.base_pool_list(i));
+                }
+                return [4 /*yield*/, curve.multicallProvider.all(calls)];
+            case 2:
+                basePoolList = (_d.sent()).map(function (item) { return item.toLowerCase(); });
+                pools = __assign(__assign(__assign({}, curve.constants.STABLE_NG_FACTORY_POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.POOLS_DATA);
+                basePoolIds = Object.keys(pools).filter(function (item) { return basePoolList.includes(pools[item].swap_address); });
+                return [2 /*return*/, basePoolIds.map(function (poolId) {
+                        var pool = getPool(poolId);
+                        return {
+                            id: poolId,
+                            name: pool.name,
+                            pool: pool.address,
+                            token: pool.lpToken,
+                            coins: pool.underlyingCoinAddresses,
+                        };
+                    })];
+        }
     });
+}); };
+var memoizedContract = function () {
+    var cache = {};
+    return function (address, abi, provider) {
+        if (address in cache) {
+            return cache[address];
+        }
+        else {
+            var result = new Contract(address, abi, provider);
+            cache[address] = result;
+            return result;
+        }
+    };
+};
+var memoizedulticallContract = function () {
+    var cache = {};
+    return function (address, abi) {
+        if (address in cache) {
+            return cache[address];
+        }
+        else {
+            var result = new MulticallContract(address, abi);
+            cache[address] = result;
+            return result;
+        }
+    };
 };
+export var initContract = memoizedContract();
+export var initMulticallContract = memoizedulticallContract();

package/package.json

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