@curvefi/api 2.28.3 → 2.30.0

package/lib/factory/factory.js

@@ -63,12 +63,14 @@ exports.getFactoryPoolData = void 0;
 var ethers_1 = require("ethers");
 var ethcall_1 = require("ethcall");
 var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
-var deposit_json_1 = __importDefault(require("../constants/abis/factoryPools/deposit.json"));
 var gauge_factory_json_1 = __importDefault(require("../constants/abis/gauge_factory.json"));
 var gauge_child_json_1 = __importDefault(require("../constants/abis/gauge_child.json"));
 var common_1 = require("./common");
 var constants_1 = require("./constants");
 var BLACK_LIST = {
+    1: [
+        "0x066b6e1e93fa7dcd3f0eb7f8bac7d5a747ce0bf9",
+    ],
     137: [
         "0x666dc3b4babfd063faf965bd020024af0dc51b64",
         "0xe4199bc5c5c1f63dba47b56b6db7144c51cf0bf8",
@@ -106,8 +108,9 @@ function getRecentlyCreatedPoolId(swapAddress) {
         });
     });
 }
-function getFactoryIdsAndSwapAddresses() {
+function getFactoryIdsAndSwapAddresses(fromIdx) {
     var _a;
+    if (fromIdx === void 0) { fromIdx = 0; }
     return __awaiter(this, void 0, void 0, function () {
         var factoryContract, factoryMulticallContract, poolCount, _b, _c, _e, calls, i, factories, swapAddresses, blacklist;
         return __generator(this, function (_f) {
@@ -121,12 +124,14 @@ function getFactoryIdsAndSwapAddresses() {
                 case 1:
                     poolCount = _b.apply(void 0, [_e.apply(_c, [_f.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 = (_f.sent()).map(function (addr, i) { return ({ id: "factory-v2-".concat(i), address: addr.toLowerCase() }); });
+                    factories = (_f.sent()).map(function (addr, i) { return ({ id: "factory-v2-".concat(fromIdx + i), address: addr.toLowerCase() }); });
                     swapAddresses = Object.values(this.constants.POOLS_DATA).map(function (pool) { return pool.swap_address.toLowerCase(); });
                     blacklist = (_a = BLACK_LIST[this.chainId]) !== null && _a !== void 0 ? _a : [];
                     factories = factories.filter(function (f) { return !swapAddresses.includes(f.address) && !blacklist.includes(f.address); });
@@ -135,21 +140,51 @@ function getFactoryIdsAndSwapAddresses() {
         });
     });
 }
-function getFactoryImplementations(factorySwapAddresses) {
+function _handleReferenceAssets(referenceAssets) {
+    return referenceAssets.map(function (t) {
+        return {
+            0: "USD",
+            1: "ETH",
+            2: "BTC",
+        }[ethers_1.ethers.utils.formatUnits(t, 0)] || "OTHER";
+    });
+}
+function _handleCoinAddresses(coinAddresses) {
+    var _this = this;
+    return coinAddresses.map(function (addresses) { return addresses
+        .filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; })
+        .map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.address : addr.toLowerCase(); }); });
+}
+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, tempSwapContract, res, implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
+                case 0:
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.factory].multicallContract;
                     calls = [];
                     for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
                         addr = factorySwapAddresses_1[_i];
+                        tempSwapContract = new ethcall_1.Contract(addr, ERC20_json_1.default);
                         calls.push(factoryMulticallContract.get_implementation_address(addr));
+                        calls.push(factoryMulticallContract.get_gauge(addr));
+                        calls.push(factoryMulticallContract.get_pool_asset_type(addr));
+                        calls.push(tempSwapContract.symbol());
+                        calls.push(tempSwapContract.name());
+                        calls.push(factoryMulticallContract.is_meta(addr));
+                        calls.push(factoryMulticallContract.get_coins(addr));
                     }
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, (_a.sent()).map(function (a) { return a.toLowerCase(); })];
+                case 1:
+                    res = _a.sent();
+                    implememntationAddresses = res.filter(function (a, i) { return i % 7 == 0; }).map(function (a) { return a.toLowerCase(); });
+                    gaugeAddresses = res.filter(function (a, i) { return i % 7 == 1; }).map(function (a) { return a.toLowerCase(); });
+                    referenceAssets = _handleReferenceAssets(res.filter(function (a, i) { return i % 7 == 2; }));
+                    symbols = res.filter(function (a, i) { return i % 7 == 3; });
+                    names = res.filter(function (a, i) { return i % 7 == 4; });
+                    isMeta = res.filter(function (a, i) { return i % 7 == 5; });
+                    coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 7 == 6; }));
+                    return [2 /*return*/, [implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses]];
             }
         });
     });
@@ -157,110 +192,13 @@ function getFactoryImplementations(factorySwapAddresses) {
 function setFactorySwapContracts(factorySwapAddresses, factorySwapABIs) {
     var _this = this;
     factorySwapAddresses.forEach(function (addr, i) {
-        _this.contracts[addr] = {
-            contract: new ethers_1.Contract(addr, factorySwapABIs[i], _this.signer || _this.provider),
-            multicallContract: new ethcall_1.Contract(addr, factorySwapABIs[i]),
-        };
-    });
-}
-function getFactoryGaugeAddresses(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.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(); })];
-            }
-        });
+        _this.setContract(addr, factorySwapABIs[i]);
     });
 }
 function setFactoryGaugeContracts(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 getFactorySymbolsAndNames(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var calls, _i, factorySwapAddresses_3, addr, res, symbols, names, i;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_3 = factorySwapAddresses; _i < factorySwapAddresses_3.length; _i++) {
-                        addr = factorySwapAddresses_3[_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 < factorySwapAddresses.length; i++) {
-                        symbols.push(res[2 * i]);
-                        names.push(res[(2 * i) + 1]);
-                    }
-                    return [2 /*return*/, [symbols, names]];
-            }
-        });
-    });
-}
-function getFactoryReferenceAssets(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_4, addr;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_4 = factorySwapAddresses; _i < factorySwapAddresses_4.length; _i++) {
-                        addr = factorySwapAddresses_4[_i];
-                        calls.push(factoryMulticallContract.get_pool_asset_type(addr));
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, (_a.sent()).map(function (t) {
-                        return {
-                            0: "USD",
-                            1: "ETH",
-                            2: "BTC",
-                        }[ethers_1.ethers.utils.formatUnits(t, 0)] || "OTHER";
-                    })];
-            }
-        });
-    });
-}
-function getFactoryCoinAddresses(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_5, addr;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_5 = factorySwapAddresses; _i < factorySwapAddresses_5.length; _i++) {
-                        addr = factorySwapAddresses_5[_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
-                        .filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; })
-                        .map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.address : addr.toLowerCase(); }); })];
-            }
-        });
+        _this.setContract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default);
     });
 }
 function setFactoryCoinsContracts(coinAddresses) {
@@ -269,10 +207,7 @@ function setFactoryCoinsContracts(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 getExistingCoinAddressNameDict() {
@@ -296,152 +231,102 @@ function getExistingCoinAddressNameDict() {
     dict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
     return dict;
 }
-function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
+function getCoinsData(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, newCoinAddresses_1, addr, res, symbols, decimals;
+        return __generator(this, function (_b) {
+            switch (_b.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 {
                             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];
-                    });
-                    return [2 /*return*/, coinAddrNamesDict];
-            }
-        });
-    });
-}
-function getCoinAddressDecimalsDict(coinAddresses, existingCoinAddressDecimalsDict) {
-    return __awaiter(this, void 0, void 0, function () {
-        var flattenedCoinAddresses, newCoinAddresses, coinAddrNamesDict, _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))).filter(function (addr) { return addr !== _this.constants.NATIVE_TOKEN.address; });
-                    newCoinAddresses = [];
-                    coinAddrNamesDict = {};
-                    for (_i = 0, flattenedCoinAddresses_3 = flattenedCoinAddresses; _i < flattenedCoinAddresses_3.length; _i++) {
-                        addr = flattenedCoinAddresses_3[_i];
-                        if (addr in existingCoinAddressDecimalsDict) {
-                            coinAddrNamesDict[addr] = existingCoinAddressDecimalsDict[addr];
-                        }
-                        else {
-                            newCoinAddresses.push(addr);
-                        }
+                    calls = [];
+                    for (_a = 0, newCoinAddresses_1 = newCoinAddresses; _a < newCoinAddresses_1.length; _a++) {
+                        addr = newCoinAddresses_1[_a];
+                        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 = _b.sent();
+                    symbols = res.filter(function (a, i) { return i % 2 == 0; });
+                    decimals = res.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) {
-                        coinAddrNamesDict[addr] = decimals[i];
+                        coinAddrNamesDict[addr] = symbols[i];
+                        coinAddrDecimalsDict[addr] = decimals[i];
                     });
-                    coinAddrNamesDict[this.constants.NATIVE_TOKEN.address] = 18;
-                    return [2 /*return*/, coinAddrNamesDict];
+                    return [2 /*return*/, [coinAddrNamesDict, coinAddrDecimalsDict]];
             }
         });
     });
 }
-function getFactoryIsMeta(factorySwapAddresses) {
+function getFactoryPoolData(fromIdx, swapAddress) {
+    if (fromIdx === void 0) { fromIdx = 0; }
     return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_6, addr;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.contracts[this.constants.ALIASES.factory].multicallContract];
-                case 1:
-                    factoryMulticallContract = _a.sent();
-                    calls = [];
-                    for (_i = 0, factorySwapAddresses_6 = factorySwapAddresses; _i < factorySwapAddresses_6.length; _i++) {
-                        addr = factorySwapAddresses_6[_i];
-                        calls.push(factoryMulticallContract.is_meta(addr));
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 2: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-function getFactoryPoolData(swapAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, rawPoolIds, rawSwapAddresses, _b, rawImplementations, poolIds, swapAddresses, implementations, implementationABIDict, i, swapABIs, gaugeAddresses, _c, poolSymbols, poolNames, referenceAssets, coinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, isMeta, implementationBasePoolIdDict, basePoolIds, FACTORY_POOLS_DATA, _loop_2, this_1, i;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var _a, rawPoolIds, rawSwapAddresses, _b, _c, rawImplementations, rawGauges, rawReferenceAssets, rawPoolSymbols, rawPoolNames, rawIsMeta, rawCoinAddresses, poolIds, swapAddresses, implementations, gaugeAddresses, referenceAssets, poolSymbols, poolNames, isMeta, coinAddresses, implementationABIDict, i, swapABIs, _e, coinAddressNameDict, coinAddressDecimalsDict, implementationBasePoolIdDict, basePoolIds, FACTORY_POOLS_DATA, _loop_2, this_1, i;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
                     if (!swapAddress) return [3 /*break*/, 2];
                     return [4 /*yield*/, getRecentlyCreatedPoolId.call(this, swapAddress)];
                 case 1:
-                    _b = [[_e.sent()], [swapAddress.toLowerCase()]];
+                    _b = [[_f.sent()], [swapAddress.toLowerCase()]];
                     return [3 /*break*/, 4];
-                case 2: return [4 /*yield*/, getFactoryIdsAndSwapAddresses.call(this)];
+                case 2: return [4 /*yield*/, getFactoryIdsAndSwapAddresses.call(this, fromIdx)];
                 case 3:
-                    _b = _e.sent();
-                    _e.label = 4;
+                    _b = _f.sent();
+                    _f.label = 4;
                 case 4:
                     _a = _b, rawPoolIds = _a[0], rawSwapAddresses = _a[1];
-                    return [4 /*yield*/, getFactoryImplementations.call(this, rawSwapAddresses)];
+                    if (rawPoolIds.length === 0)
+                        return [2 /*return*/, {}];
+                    return [4 /*yield*/, getPoolsData.call(this, rawSwapAddresses)];
                 case 5:
-                    rawImplementations = _e.sent();
+                    _c = _f.sent(), rawImplementations = _c[0], rawGauges = _c[1], rawReferenceAssets = _c[2], rawPoolSymbols = _c[3], rawPoolNames = _c[4], rawIsMeta = _c[5], rawCoinAddresses = _c[6];
                     poolIds = [];
                     swapAddresses = [];
                     implementations = [];
+                    gaugeAddresses = [];
+                    referenceAssets = [];
+                    poolSymbols = [];
+                    poolNames = [];
+                    isMeta = [];
+                    coinAddresses = [];
                     implementationABIDict = constants_1.FACTORY_CONSTANTS[this.chainId].implementationABIDict;
                     for (i = 0; i < rawPoolIds.length; i++) {
                         if (rawImplementations[i] in implementationABIDict) {
                             poolIds.push(rawPoolIds[i]);
                             swapAddresses.push(rawSwapAddresses[i]);
                             implementations.push(rawImplementations[i]);
+                            gaugeAddresses.push(rawGauges[i]);
+                            referenceAssets.push(rawReferenceAssets[i]);
+                            poolSymbols.push(rawPoolSymbols[i]);
+                            poolNames.push(rawPoolNames[i]);
+                            isMeta.push(rawIsMeta[i]);
+                            coinAddresses.push(rawCoinAddresses[i]);
                         }
                     }
                     swapABIs = implementations.map(function (addr) { return implementationABIDict[addr]; });
                     setFactorySwapContracts.call(this, swapAddresses, swapABIs);
-                    return [4 /*yield*/, getFactoryGaugeAddresses.call(this, swapAddresses)];
-                case 6:
-                    gaugeAddresses = _e.sent();
                     setFactoryGaugeContracts.call(this, gaugeAddresses);
-                    return [4 /*yield*/, getFactorySymbolsAndNames.call(this, swapAddresses)];
-                case 7:
-                    _c = _e.sent(), poolSymbols = _c[0], poolNames = _c[1];
-                    return [4 /*yield*/, getFactoryReferenceAssets.call(this, swapAddresses)];
-                case 8:
-                    referenceAssets = _e.sent();
-                    return [4 /*yield*/, getFactoryCoinAddresses.call(this, swapAddresses)];
-                case 9:
-                    coinAddresses = _e.sent();
                     setFactoryCoinsContracts.call(this, coinAddresses);
-                    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();
-                    return [4 /*yield*/, getFactoryIsMeta.call(this, swapAddresses)];
-                case 12:
-                    isMeta = _e.sent();
+                    common_1.setFactoryZapContracts.call(this, false);
+                    return [4 /*yield*/, getCoinsData.call(this, coinAddresses, getExistingCoinAddressNameDict.call(this), this.constants.DECIMALS)];
+                case 6:
+                    _e = _f.sent(), coinAddressNameDict = _e[0], coinAddressDecimalsDict = _e[1];
                     implementationBasePoolIdDict = constants_1.FACTORY_CONSTANTS[this.chainId].implementationBasePoolIdDict;
                     basePoolIds = implementations.map(function (addr) { return implementationBasePoolIdDict[addr]; });
-                    common_1.setFactoryZapContracts.call(this, false);
                     FACTORY_POOLS_DATA = {};
                     _loop_2 = function (i) {
                         if (!isMeta[i]) {
@@ -453,6 +338,7 @@ function getFactoryPoolData(swapAddress) {
                                 swap_address: swapAddresses[i],
                                 token_address: swapAddresses[i],
                                 gauge_address: gaugeAddresses[i],
+                                implementation_address: implementations[i],
                                 is_plain: true,
                                 is_factory: true,
                                 underlying_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
@@ -474,6 +360,7 @@ function getFactoryPoolData(swapAddress) {
                             // @ts-ignore
                             var basePoolIdDecimalsDict = Object.fromEntries(basePoolIds.map(function (poolId) { var _a; return [poolId, (_a = allPoolsData_1[poolId]) === null || _a === void 0 ? void 0 : _a.underlying_decimals]; }));
                             var basePoolIdZapDict = constants_1.FACTORY_CONSTANTS[this_1.chainId].basePoolIdZapDict;
+                            var basePoolZap = basePoolIdZapDict[basePoolIds[i]];
                             FACTORY_POOLS_DATA[poolIds[i]] = {
                                 name: poolNames[i].split(": ")[1].trim(),
                                 full_name: poolNames[i],
@@ -483,6 +370,7 @@ function getFactoryPoolData(swapAddress) {
                                 token_address: swapAddresses[i],
                                 gauge_address: gaugeAddresses[i],
                                 deposit_address: basePoolIdZapDict[basePoolIds[i]].address,
+                                implementation_address: implementations[i],
                                 is_meta: true,
                                 is_factory: true,
                                 base_pool: basePoolIds[i],
@@ -494,7 +382,7 @@ function getFactoryPoolData(swapAddress) {
                                 wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
                                 swap_abi: swapABIs[i],
                                 gauge_abi: this_1.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default,
-                                deposit_abi: deposit_json_1.default,
+                                deposit_abi: basePoolZap.ABI,
                             };
                         }
                     };

package/lib/index.d.ts

@@ -15,10 +15,6 @@ declare function init(providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy', p
     maxPriorityFeePerGas?: number;
     chainId?: number;
 }): Promise<void>;
-declare function fetchFactoryPools(useApi?: boolean): Promise<void>;
-declare function fetchCryptoFactoryPools(useApi?: boolean): Promise<void>;
-declare function fetchRecentlyDeployedFactoryPool(poolAddress: string): Promise<string>;
-declare function fetchRecentlyDeployedCryptoFactoryPool(poolAddress: string): Promise<string>;
 declare function setCustomFeeData(customFeeData: {
     gasPrice?: number;
     maxFeePerGas?: number;
@@ -29,11 +25,7 @@ declare const curve: {
     chainId: number;
     signerAddress: string;
     setCustomFeeData: typeof setCustomFeeData;
-    fetchFactoryPools: typeof fetchFactoryPools;
-    fetchCryptoFactoryPools: typeof fetchCryptoFactoryPools;
     getPoolList: () => string[];
-    getFactoryPoolList: () => string[];
-    getCryptoFactoryPoolList: () => string[];
     getUserPoolListByLiquidity: (address?: string) => Promise<string[]>;
     getUserPoolListByClaimable: (address?: string) => Promise<string[]>;
     getUserPoolList: (address?: string, useApi?: boolean) => Promise<string[]>;
@@ -47,44 +39,55 @@ declare const curve: {
     PoolTemplate: typeof PoolTemplate;
     getPool: (poolId: string) => PoolTemplate;
     getUsdRate: (coin: string) => Promise<number>;
-    getTVL: (chainId?: number) => Promise<number>;
+    getTVL: (network?: import("./interfaces").INetworkName | import("./interfaces").IChainId) => Promise<number>;
     getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<string[] | import("./interfaces").IDict<string[]>>;
     getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;
     hasAllowance: (coins: string[], amounts: (string | number)[], address: string, spender: string) => Promise<boolean>;
-    ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<string[]>;
+    ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string, isMax?: boolean) => Promise<string[]>;
     getCoinsData: (...coins: string[] | string[][]) => Promise<{
         name: string;
         symbol: string;
         decimals: number;
     }[]>;
+    getVolume: (network?: import("./interfaces").INetworkName | import("./interfaces").IChainId) => Promise<{
+        totalVolume: number;
+        cryptoVolume: number;
+        cryptoShare: number;
+    }>;
     factory: {
-        deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 2 | 1 | 3, implementationIdx: 0 | 2 | 1 | 3) => Promise<ethers.ContractTransaction>;
+        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchNewPools: () => Promise<string[]>;
+        getPoolList: () => string[];
+        deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<ethers.ContractTransaction>;
         deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number, fee: number, implementationIdx: 0 | 1) => Promise<ethers.ContractTransaction>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
         getDeployedPlainPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
         getDeployedMetaPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
-        fetchRecentlyDeployedPool: typeof fetchRecentlyDeployedFactoryPool;
+        fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
-            deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 2 | 1 | 3, implementationIdx: 0 | 2 | 1 | 3) => Promise<number>;
+            deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<number>;
             deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number, fee: number, implementationIdx: 0 | 1) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
         };
     };
     cryptoFactory: {
+        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchNewPools: () => Promise<string[]>;
+        getPoolList: () => string[];
         deployPool: (name: string, symbol: string, coins: string[], A: number, gamma: number, midFee: number, outFee: number, allowedExtraProfit: number, feeGamma: number, adjustmentStep: number, maHalfTime: number, initialPrice: number) => Promise<ethers.ContractTransaction>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
         getDeployed: (tx: ethers.ContractTransaction) => Promise<string>;
         getDeployedPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
-        fetchRecentlyDeployedPool: typeof fetchRecentlyDeployedCryptoFactoryPool;
+        fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
             deployPool: (name: string, symbol: string, coins: string[], A: number, gamma: number, midFee: number, outFee: number, allowedExtraProfit: number, feeGamma: number, adjustmentStep: number, maHalfTime: number, initialPrice: number) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
         };
     };
     estimateGas: {
-        ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<number>;
+        ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string, isMax?: boolean) => Promise<number>;
     };
     boosting: {
         getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;

package/lib/index.js

@@ -60,52 +60,6 @@ function init(providerType, providerSettings, options) {
         });
     });
 }
-function fetchFactoryPools(useApi) {
-    if (useApi === void 0) { useApi = true; }
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, curve_1.curve.fetchFactoryPools(useApi)];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-function fetchCryptoFactoryPools(useApi) {
-    if (useApi === void 0) { useApi = true; }
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, curve_1.curve.fetchCryptoFactoryPools(useApi)];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-function fetchRecentlyDeployedFactoryPool(poolAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, curve_1.curve.fetchRecentlyDeployedFactoryPool(poolAddress)];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-function fetchRecentlyDeployedCryptoFactoryPool(poolAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, curve_1.curve.fetchRecentlyDeployedCryptoFactoryPool(poolAddress)];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
 function setCustomFeeData(customFeeData) {
     curve_1.curve.setCustomFeeData(customFeeData);
 }
@@ -114,11 +68,7 @@ var curve = {
     chainId: 0,
     signerAddress: '',
     setCustomFeeData: setCustomFeeData,
-    fetchFactoryPools: fetchFactoryPools,
-    fetchCryptoFactoryPools: fetchCryptoFactoryPools,
-    getPoolList: utils_1.getPoolList,
-    getFactoryPoolList: utils_1.getFactoryPoolList,
-    getCryptoFactoryPoolList: utils_1.getCryptoFactoryPoolList,
+    getPoolList: curve_1.curve.getPoolList,
     getUserPoolListByLiquidity: utils_1.getUserPoolListByLiquidity,
     getUserPoolListByClaimable: utils_1.getUserPoolListByClaimable,
     getUserPoolList: utils_1.getUserPoolList,
@@ -133,7 +83,11 @@ var curve = {
     hasAllowance: utils_2.hasAllowance,
     ensureAllowance: utils_2.ensureAllowance,
     getCoinsData: utils_2.getCoinsData,
+    getVolume: utils_2.getVolume,
     factory: {
+        fetchPools: curve_1.curve.fetchFactoryPools,
+        fetchNewPools: curve_1.curve.fetchNewFactoryPools,
+        getPoolList: curve_1.curve.getFactoryPoolList,
         deployPlainPool: deploy_1.deployStablePlainPool,
         deployMetaPool: deploy_1.deployStableMetaPool,
         deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
@@ -142,7 +96,7 @@ var curve = {
         getDeployedPlainPoolAddress: deploy_1.getDeployedStablePlainPoolAddress,
         getDeployedMetaPoolAddress: deploy_1.getDeployedStableMetaPoolAddress,
         getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
-        fetchRecentlyDeployedPool: fetchRecentlyDeployedFactoryPool,
+        fetchRecentlyDeployedPool: curve_1.curve.fetchRecentlyDeployedFactoryPool,
         estimateGas: {
             deployPlainPool: deploy_1.deployStablePlainPoolEstimateGas,
             deployMetaPool: deploy_1.deployStableMetaPoolEstimateGas,
@@ -152,6 +106,9 @@ var curve = {
         },
     },
     cryptoFactory: {
+        fetchPools: curve_1.curve.fetchCryptoFactoryPools,
+        fetchNewPools: curve_1.curve.fetchNewCryptoFactoryPools,
+        getPoolList: curve_1.curve.getCryptoFactoryPoolList,
         deployPool: deploy_1.deployCryptoPool,
         deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
             return [2 /*return*/, (0, deploy_1.deployGauge)(poolAddress, true)];
@@ -159,7 +116,7 @@ var curve = {
         getDeployed: deploy_1.getDeployedStablePlainPoolAddress,
         getDeployedPoolAddress: deploy_1.getDeployedCryptoPoolAddress,
         getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
-        fetchRecentlyDeployedPool: fetchRecentlyDeployedCryptoFactoryPool,
+        fetchRecentlyDeployedPool: curve_1.curve.fetchRecentlyDeployedCryptoFactoryPool,
         estimateGas: {
             deployPool: deploy_1.deployCryptoPoolEstimateGas,
             deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {