@curvefi/api 2.29.0 → 2.30.0

package/lib/factory/factory-crypto.js

@@ -61,7 +61,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCryptoFactoryPoolData = void 0;
 var ethers_1 = require("ethers");
-var ethcall_1 = require("ethcall");
 var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
 var factory_crypto_pool_2_json_1 = __importDefault(require("../constants/abis/factory-crypto/factory-crypto-pool-2.json"));
 var gauge_factory_json_1 = __importDefault(require("../constants/abis/gauge_factory.json"));
@@ -99,7 +98,8 @@ function getRecentlyCreatedCryptoPoolId(swapAddress) {
         });
     });
 }
-function getCryptoFactoryIdsAndSwapAddresses() {
+function getCryptoFactoryIdsAndSwapAddresses(fromIdx) {
+    if (fromIdx === void 0) { fromIdx = 0; }
     return __awaiter(this, void 0, void 0, function () {
         var factoryContract, factoryMulticallContract, poolCount, _a, _b, _c, calls, i, factories, swapAddresses;
         return __generator(this, function (_e) {
@@ -113,12 +113,14 @@ function getCryptoFactoryIdsAndSwapAddresses() {
                 case 1:
                     poolCount = _a.apply(void 0, [_c.apply(_b, [_e.sent(), 0])]);
                     calls = [];
-                    for (i = 0; i < poolCount; i++) {
+                    for (i = fromIdx; i < poolCount; i++) {
                         calls.push(factoryMulticallContract.pool_list(i));
                     }
+                    if (calls.length === 0)
+                        return [2 /*return*/, [[], []]];
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
                 case 2:
-                    factories = (_e.sent()).map(function (addr, i) { return ({ id: "factory-crypto-".concat(i), address: addr.toLowerCase() }); });
+                    factories = (_e.sent()).map(function (addr, i) { return ({ id: "factory-crypto-".concat(fromIdx + i), address: addr.toLowerCase() }); });
                     swapAddresses = Object.values(this.constants.POOLS_DATA).map(function (pool) { return pool.swap_address.toLowerCase(); });
                     factories = factories.filter(function (f) { return !swapAddresses.includes(f.address); });
                     return [2 /*return*/, [factories.map(function (f) { return f.id; }), factories.map(function (f) { return f.address; })]];
@@ -126,114 +128,51 @@ function getCryptoFactoryIdsAndSwapAddresses() {
         });
     });
 }
-function setCryptoFactorySwapContracts(factorySwapAddresses) {
+function _handleCoinAddresses(coinAddresses) {
     var _this = this;
-    factorySwapAddresses.forEach(function (addr) {
-        _this.contracts[addr] = {
-            contract: new ethers_1.Contract(addr, factory_crypto_pool_2_json_1.default, _this.signer || _this.provider),
-            multicallContract: new ethcall_1.Contract(addr, factory_crypto_pool_2_json_1.default),
-        };
-    });
+    return coinAddresses.map(function (addresses) { return addresses.map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase(); }); });
 }
-function getCryptoFactoryTokenAddresses(factorySwapAddresses) {
+function getPoolsData(factorySwapAddresses) {
     return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr;
+        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, tokenAddresses, gaugeAddresses, coinAddresses;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.crypto_factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
+                case 0:
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
                     calls = [];
                     for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
                         addr = factorySwapAddresses_1[_i];
                         calls.push(factoryMulticallContract.get_token(addr));
+                        calls.push(factoryMulticallContract.get_gauge(addr));
+                        calls.push(factoryMulticallContract.get_coins(addr));
                     }
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, (_a.sent()).map(function (addr) { return addr.toLowerCase(); })];
+                case 1:
+                    res = _a.sent();
+                    tokenAddresses = res.filter(function (a, i) { return i % 3 == 0; }).map(function (a) { return a.toLowerCase(); });
+                    gaugeAddresses = res.filter(function (a, i) { return i % 3 == 1; }).map(function (a) { return a.toLowerCase(); });
+                    coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 3 == 2; }));
+                    return [2 /*return*/, [tokenAddresses, gaugeAddresses, coinAddresses]];
             }
         });
     });
 }
-function setCryptoFactoryTokenContracts(factoryTokenAddresses) {
+function setCryptoFactorySwapContracts(factorySwapAddresses) {
     var _this = this;
-    factoryTokenAddresses.forEach(function (addr) {
-        _this.contracts[addr] = {
-            contract: new ethers_1.Contract(addr, ERC20_json_1.default, _this.signer || _this.provider),
-            multicallContract: new ethcall_1.Contract(addr, ERC20_json_1.default),
-        };
+    factorySwapAddresses.forEach(function (addr) {
+        _this.setContract(addr, factory_crypto_pool_2_json_1.default);
     });
 }
-function getCryptoFactoryGaugeAddresses(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_2, addr;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.crypto_factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_2 = factorySwapAddresses; _i < factorySwapAddresses_2.length; _i++) {
-                        addr = factorySwapAddresses_2[_i];
-                        calls.push(factoryMulticallContract.get_gauge(addr));
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, (_a.sent()).map(function (addr) { return addr.toLowerCase(); })];
-            }
-        });
+function setCryptoFactoryTokenContracts(factoryTokenAddresses) {
+    var _this = this;
+    factoryTokenAddresses.forEach(function (addr) {
+        _this.setContract(addr, ERC20_json_1.default);
     });
 }
 function setCryptoFactoryGaugeContracts(factoryGaugeAddresses) {
     var _this = this;
     factoryGaugeAddresses.filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; }).forEach(function (addr, i) {
-        _this.contracts[addr] = {
-            contract: new ethers_1.Contract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default, _this.signer || _this.provider),
-            multicallContract: new ethcall_1.Contract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default),
-        };
-    });
-}
-function getCryptoFactorySymbolsAndNames(factoryTokenAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var calls, _i, factoryTokenAddresses_1, addr, res, symbols, names, i;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    calls = [];
-                    for (_i = 0, factoryTokenAddresses_1 = factoryTokenAddresses; _i < factoryTokenAddresses_1.length; _i++) {
-                        addr = factoryTokenAddresses_1[_i];
-                        calls.push(this.contracts[addr].multicallContract.symbol(), this.contracts[addr].multicallContract.name());
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 1:
-                    res = _a.sent();
-                    symbols = [];
-                    names = [];
-                    for (i = 0; i < factoryTokenAddresses.length; i++) {
-                        symbols.push(res[2 * i]);
-                        names.push(res[(2 * i) + 1]);
-                    }
-                    return [2 /*return*/, [symbols, names]];
-            }
-        });
-    });
-}
-function getCryptoFactoryCoinAddresses(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_3, addr;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.crypto_factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_3 = factorySwapAddresses; _i < factorySwapAddresses_3.length; _i++) {
-                        addr = factorySwapAddresses_3[_i];
-                        calls.push(factoryMulticallContract.get_coins(addr));
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, (_a.sent()).map(function (addresses) { return addresses.map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase(); }); })];
-            }
-        });
+        _this.setContract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default);
     });
 }
 function setCryptoFactoryCoinsContracts(coinAddresses) {
@@ -242,19 +181,12 @@ function setCryptoFactoryCoinsContracts(coinAddresses) {
         var addr = flattenedCoinAddresses_1[_i];
         if (addr in this.contracts)
             continue;
-        this.contracts[addr] = {
-            contract: new ethers_1.Contract(addr, ERC20_json_1.default, this.signer || this.provider),
-            multicallContract: new ethcall_1.Contract(addr, ERC20_json_1.default),
-        };
+        this.setContract(addr, ERC20_json_1.default);
     }
 }
 function getCryptoFactoryUnderlyingCoinAddresses(coinAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _this = this;
-        return __generator(this, function (_a) {
-            return [2 /*return*/, coinAddresses.map(function (coins) { return coins.map(function (c) { return c === _this.constants.NATIVE_TOKEN.wrappedAddress ? _this.constants.NATIVE_TOKEN.address : c; }); })];
-        });
-    });
+    var _this = this;
+    return coinAddresses.map(function (coins) { return coins.map(function (c) { return c === _this.constants.NATIVE_TOKEN.wrappedAddress ? _this.constants.NATIVE_TOKEN.address : c; }); });
 }
 function getExistingCoinAddressNameDict() {
     var dict = {};
@@ -277,20 +209,21 @@ function getExistingCoinAddressNameDict() {
     dict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
     return dict;
 }
-function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
+function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, existingCoinAddrDecimalsDict) {
     return __awaiter(this, void 0, void 0, function () {
-        var flattenedCoinAddresses, newCoinAddresses, coinAddrNamesDict, _i, flattenedCoinAddresses_2, addr, calls, names;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var flattenedCoinAddresses, newCoinAddresses, coinAddrNamesDict, coinAddrDecimalsDict, _i, flattenedCoinAddresses_2, addr, calls, _a, tokenAddresses_1, addr, _b, newCoinAddresses_1, addr, res, res1, tokenSymbols, tokenNames, res2, symbols, decimals;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
                     newCoinAddresses = [];
                     coinAddrNamesDict = {};
+                    coinAddrDecimalsDict = {};
                     for (_i = 0, flattenedCoinAddresses_2 = flattenedCoinAddresses; _i < flattenedCoinAddresses_2.length; _i++) {
                         addr = flattenedCoinAddresses_2[_i];
                         if (addr in existingCoinAddrNameDict) {
                             coinAddrNamesDict[addr] = existingCoinAddrNameDict[addr];
+                            coinAddrDecimalsDict[addr] = existingCoinAddrDecimalsDict[addr];
                         }
                         else if (addr === "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2") {
                             coinAddrNamesDict[addr] = "MKR";
@@ -299,100 +232,69 @@ function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
                             newCoinAddresses.push(addr);
                         }
                     }
-                    calls = newCoinAddresses.map(function (addr) {
-                        return _this.contracts[addr].multicallContract.symbol();
-                    });
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 1:
-                    names = _a.sent();
-                    newCoinAddresses.forEach(function (addr, i) {
-                        coinAddrNamesDict[addr] = names[i];
-                    });
-                    coinAddrNamesDict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
-                    return [2 /*return*/, coinAddrNamesDict];
-            }
-        });
-    });
-}
-function getCoinAddressDecimalsDict(coinAddresses, existingCoinAddressDecimalsDict) {
-    return __awaiter(this, void 0, void 0, function () {
-        var flattenedCoinAddresses, newCoinAddresses, coinAddressDecimalsDict, _i, flattenedCoinAddresses_3, addr, calls, decimals;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
-                    newCoinAddresses = [];
-                    coinAddressDecimalsDict = {};
-                    for (_i = 0, flattenedCoinAddresses_3 = flattenedCoinAddresses; _i < flattenedCoinAddresses_3.length; _i++) {
-                        addr = flattenedCoinAddresses_3[_i];
-                        if (addr in existingCoinAddressDecimalsDict) {
-                            coinAddressDecimalsDict[addr] = existingCoinAddressDecimalsDict[addr];
-                        }
-                        else {
-                            newCoinAddresses.push(addr);
-                        }
+                    calls = [];
+                    for (_a = 0, tokenAddresses_1 = tokenAddresses; _a < tokenAddresses_1.length; _a++) {
+                        addr = tokenAddresses_1[_a];
+                        calls.push(this.contracts[addr].multicallContract.symbol());
+                        calls.push(this.contracts[addr].multicallContract.name());
+                    }
+                    for (_b = 0, newCoinAddresses_1 = newCoinAddresses; _b < newCoinAddresses_1.length; _b++) {
+                        addr = newCoinAddresses_1[_b];
+                        calls.push(this.contracts[addr].multicallContract.symbol());
+                        calls.push(this.contracts[addr].multicallContract.decimals());
                     }
-                    calls = newCoinAddresses.map(function (addr) {
-                        return _this.contracts[addr].multicallContract.decimals();
-                    });
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
                 case 1:
-                    decimals = (_a.sent()).map(function (_d) { return Number(ethers_1.ethers.utils.formatUnits(_d, 0)); });
+                    res = _c.sent();
+                    res1 = res.slice(0, tokenAddresses.length * 2);
+                    tokenSymbols = res1.filter(function (a, i) { return i % 2 == 0; });
+                    tokenNames = res1.filter(function (a, i) { return i % 2 == 1; });
+                    res2 = res.slice(tokenAddresses.length * 2);
+                    symbols = res2.filter(function (a, i) { return i % 2 == 0; });
+                    decimals = res2.filter(function (a, i) { return i % 2 == 1; }).map(function (_d) { return Number(ethers_1.ethers.utils.formatUnits(_d, 0)); });
                     newCoinAddresses.forEach(function (addr, i) {
-                        coinAddressDecimalsDict[addr] = decimals[i];
+                        coinAddrNamesDict[addr] = symbols[i];
+                        coinAddrDecimalsDict[addr] = decimals[i];
                     });
-                    coinAddressDecimalsDict[this.constants.NATIVE_TOKEN.address] = 18;
-                    return [2 /*return*/, coinAddressDecimalsDict];
+                    coinAddrNamesDict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
+                    return [2 /*return*/, [tokenSymbols, tokenNames, coinAddrNamesDict, coinAddrDecimalsDict]];
             }
         });
     });
 }
-function getCryptoFactoryPoolData(swapAddress) {
+function getCryptoFactoryPoolData(fromIdx, swapAddress) {
+    if (fromIdx === void 0) { fromIdx = 0; }
     return __awaiter(this, void 0, void 0, function () {
-        var _a, poolIds, swapAddresses, _b, tokenAddresses, gaugeAddresses, _c, poolSymbols, poolNames, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, CRYPTO_FACTORY_POOLS_DATA, i, lpTokenBasePoolIdDict, basePoolIdZapDict, basePoolId, allPoolsData, basePoolCoinNames, basePoolCoinAddresses, basePoolDecimals, basePoolZap;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var _a, poolIds, swapAddresses, _b, _c, tokenAddresses, gaugeAddresses, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, _e, poolSymbols, poolNames, coinAddressNameDict, coinAddressDecimalsDict, CRYPTO_FACTORY_POOLS_DATA, i, lpTokenBasePoolIdDict, basePoolIdZapDict, basePoolId, allPoolsData, basePoolCoinNames, basePoolCoinAddresses, basePoolDecimals, basePoolZap;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
                     if (!swapAddress) return [3 /*break*/, 2];
                     return [4 /*yield*/, getRecentlyCreatedCryptoPoolId.call(this, swapAddress)];
                 case 1:
-                    _b = [[_e.sent()], [swapAddress.toLowerCase()]];
+                    _b = [[_f.sent()], [swapAddress.toLowerCase()]];
                     return [3 /*break*/, 4];
-                case 2: return [4 /*yield*/, getCryptoFactoryIdsAndSwapAddresses.call(this)];
+                case 2: return [4 /*yield*/, getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx)];
                 case 3:
-                    _b = _e.sent();
-                    _e.label = 4;
+                    _b = _f.sent();
+                    _f.label = 4;
                 case 4:
                     _a = _b, poolIds = _a[0], swapAddresses = _a[1];
-                    // const [poolIds, swapAddresses] = await getCryptoFactoryIdsAndSwapAddresses.call(this);
-                    setCryptoFactorySwapContracts.call(this, swapAddresses);
-                    return [4 /*yield*/, getCryptoFactoryTokenAddresses.call(this, swapAddresses)];
+                    if (poolIds.length === 0)
+                        return [2 /*return*/, {}];
+                    return [4 /*yield*/, getPoolsData.call(this, swapAddresses)];
                 case 5:
-                    tokenAddresses = _e.sent();
+                    _c = _f.sent(), tokenAddresses = _c[0], gaugeAddresses = _c[1], coinAddresses = _c[2];
+                    setCryptoFactorySwapContracts.call(this, swapAddresses);
                     setCryptoFactoryTokenContracts.call(this, tokenAddresses);
-                    return [4 /*yield*/, getCryptoFactoryGaugeAddresses.call(this, swapAddresses)];
-                case 6:
-                    gaugeAddresses = _e.sent();
                     setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
-                    return [4 /*yield*/, getCryptoFactorySymbolsAndNames.call(this, tokenAddresses)];
-                case 7:
-                    _c = _e.sent(), poolSymbols = _c[0], poolNames = _c[1];
-                    return [4 /*yield*/, getCryptoFactoryCoinAddresses.call(this, swapAddresses)];
-                case 8:
-                    coinAddresses = _e.sent();
                     setCryptoFactoryCoinsContracts.call(this, coinAddresses);
-                    return [4 /*yield*/, getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses)];
-                case 9:
-                    underlyingCoinAddresses = _e.sent();
-                    existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
-                    return [4 /*yield*/, getCoinAddressNameDict.call(this, coinAddresses, existingCoinAddressNameDict)];
-                case 10:
-                    coinAddressNameDict = _e.sent();
-                    return [4 /*yield*/, getCoinAddressDecimalsDict.call(this, coinAddresses, this.constants.DECIMALS)];
-                case 11:
-                    coinAddressDecimalsDict = _e.sent();
                     common_1.setFactoryZapContracts.call(this, true);
+                    underlyingCoinAddresses = getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses);
+                    existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
+                    return [4 /*yield*/, getCoinsData.call(this, tokenAddresses, coinAddresses, existingCoinAddressNameDict, this.constants.DECIMALS)];
+                case 6:
+                    _e = _f.sent(), poolSymbols = _e[0], poolNames = _e[1], coinAddressNameDict = _e[2], coinAddressDecimalsDict = _e[3];
                     CRYPTO_FACTORY_POOLS_DATA = {};
                     for (i = 0; i < poolIds.length; i++) {
                         lpTokenBasePoolIdDict = constants_crypto_1.CRYPTO_FACTORY_CONSTANTS[this.chainId].lpTokenBasePoolIdDict;

package/lib/factory/factory.d.ts

@@ -1,2 +1,2 @@
 import { IDict, IPoolData, ICurve } from "../interfaces";
-export declare function getFactoryPoolData(this: ICurve, swapAddress?: string): Promise<IDict<IPoolData>>;
+export declare function getFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string): Promise<IDict<IPoolData>>;