@curvefi/api 2.30.1 → 2.31.1

package/lib/factory/factory-crypto.js

@@ -1,361 +1,208 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+import { curve } from "../curve.js";
+import ERC20ABI from "../constants/abis/ERC20.json" assert { type: 'json' };
+import cryptoFactorySwapABI from "../constants/abis/factory-crypto/factory-crypto-pool-2.json" assert { type: 'json' };
+import factoryGaugeABI from "../constants/abis/gauge_factory.json" assert { type: 'json' };
+import gaugeChildABI from "../constants/abis/gauge_child.json" assert { type: 'json' };
+import { setFactoryZapContracts } from "./common.js";
+import { CRYPTO_FACTORY_CONSTANTS } from "./constants-crypto.js";
+const deepFlatten = (arr) => [].concat(...arr.map((v) => (Array.isArray(v) ? deepFlatten(v) : v)));
+async function getRecentlyCreatedCryptoPoolId(swapAddress) {
+    const factoryContract = this.contracts[this.constants.ALIASES.crypto_factory].contract;
+    const poolCount = Number(curve.formatUnits(await factoryContract.pool_count(this.constantOptions), 0));
+    for (let i = 1; i <= poolCount; i++) {
+        const address = await factoryContract.pool_list(poolCount - i);
+        if (address.toLowerCase() === swapAddress.toLowerCase())
+            return `factory-crypto-${poolCount - i}`;
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCryptoFactoryPoolData = void 0;
-var ethers_1 = require("ethers");
-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"));
-var gauge_child_json_1 = __importDefault(require("../constants/abis/gauge_child.json"));
-var common_1 = require("./common");
-var constants_crypto_1 = require("./constants-crypto");
-var deepFlatten = function (arr) { return [].concat.apply([], arr.map(function (v) { return (Array.isArray(v) ? deepFlatten(v) : v); })); };
-function getRecentlyCreatedCryptoPoolId(swapAddress) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryContract, poolCount, _a, _b, _c, i, address;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    factoryContract = this.contracts[this.constants.ALIASES.crypto_factory].contract;
-                    _a = Number;
-                    _c = (_b = ethers_1.ethers.utils).formatUnits;
-                    return [4 /*yield*/, factoryContract.pool_count(this.constantOptions)];
-                case 1:
-                    poolCount = _a.apply(void 0, [_c.apply(_b, [_e.sent(), 0])]);
-                    i = 1;
-                    _e.label = 2;
-                case 2:
-                    if (!(i <= poolCount)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, factoryContract.pool_list(poolCount - i)];
-                case 3:
-                    address = _e.sent();
-                    if (address.toLowerCase() === swapAddress.toLowerCase())
-                        return [2 /*return*/, "factory-crypto-".concat(poolCount - i)];
-                    _e.label = 4;
-                case 4:
-                    i++;
-                    return [3 /*break*/, 2];
-                case 5: throw Error("Unknown pool");
-            }
-        });
-    });
+    throw Error("Unknown pool");
 }
-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) {
-            switch (_e.label) {
-                case 0:
-                    factoryContract = this.contracts[this.constants.ALIASES.crypto_factory].contract;
-                    factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
-                    _a = Number;
-                    _c = (_b = ethers_1.ethers.utils).formatUnits;
-                    return [4 /*yield*/, factoryContract.pool_count(this.constantOptions)];
-                case 1:
-                    poolCount = _a.apply(void 0, [_c.apply(_b, [_e.sent(), 0])]);
-                    calls = [];
-                    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(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; })]];
-            }
-        });
-    });
+async function getCryptoFactoryIdsAndSwapAddresses(fromIdx = 0) {
+    const factoryContract = this.contracts[this.constants.ALIASES.crypto_factory].contract;
+    const factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
+    const poolCount = Number(curve.formatUnits(await factoryContract.pool_count(this.constantOptions), 0));
+    const calls = [];
+    for (let i = fromIdx; i < poolCount; i++) {
+        calls.push(factoryMulticallContract.pool_list(i));
+    }
+    if (calls.length === 0)
+        return [[], []];
+    let factories = (await this.multicallProvider.all(calls)).map((addr, i) => ({ id: `factory-crypto-${fromIdx + i}`, address: addr.toLowerCase() }));
+    const swapAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address.toLowerCase());
+    factories = factories.filter((f) => !swapAddresses.includes(f.address));
+    return [factories.map((f) => f.id), factories.map((f) => f.address)];
 }
 function _handleCoinAddresses(coinAddresses) {
-    var _this = this;
-    return coinAddresses.map(function (addresses) { return addresses.map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase(); }); });
+    return coinAddresses.map((addresses) => addresses.map((addr) => this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase()));
 }
-function getPoolsData(factorySwapAddresses) {
-    return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, tokenAddresses, gaugeAddresses, coinAddresses;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                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 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]];
-            }
-        });
-    });
+async function getPoolsData(factorySwapAddresses) {
+    const factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
+    const calls = [];
+    for (const addr of factorySwapAddresses) {
+        calls.push(factoryMulticallContract.get_token(addr));
+        calls.push(factoryMulticallContract.get_gauge(addr));
+        calls.push(factoryMulticallContract.get_coins(addr));
+    }
+    const res = await this.multicallProvider.all(calls);
+    const tokenAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
+    const gaugeAddresses = res.filter((a, i) => i % 3 == 1).map((a) => a.toLowerCase());
+    const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 2));
+    return [tokenAddresses, gaugeAddresses, coinAddresses];
 }
 function setCryptoFactorySwapContracts(factorySwapAddresses) {
-    var _this = this;
-    factorySwapAddresses.forEach(function (addr) {
-        _this.setContract(addr, factory_crypto_pool_2_json_1.default);
+    factorySwapAddresses.forEach((addr) => {
+        this.setContract(addr, cryptoFactorySwapABI);
     });
 }
 function setCryptoFactoryTokenContracts(factoryTokenAddresses) {
-    var _this = this;
-    factoryTokenAddresses.forEach(function (addr) {
-        _this.setContract(addr, ERC20_json_1.default);
+    factoryTokenAddresses.forEach((addr) => {
+        this.setContract(addr, ERC20ABI);
     });
 }
 function setCryptoFactoryGaugeContracts(factoryGaugeAddresses) {
-    var _this = this;
-    factoryGaugeAddresses.filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; }).forEach(function (addr, i) {
-        _this.setContract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default);
+    factoryGaugeAddresses.filter((addr) => addr !== curve.constants.ZERO_ADDRESS).forEach((addr, i) => {
+        this.setContract(addr, this.chainId === 1 ? factoryGaugeABI : gaugeChildABI);
     });
 }
 function setCryptoFactoryCoinsContracts(coinAddresses) {
-    var flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
-    for (var _i = 0, flattenedCoinAddresses_1 = flattenedCoinAddresses; _i < flattenedCoinAddresses_1.length; _i++) {
-        var addr = flattenedCoinAddresses_1[_i];
+    const flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
+    for (const addr of flattenedCoinAddresses) {
         if (addr in this.contracts)
             continue;
-        this.setContract(addr, ERC20_json_1.default);
+        this.setContract(addr, ERC20ABI);
     }
 }
 function getCryptoFactoryUnderlyingCoinAddresses(coinAddresses) {
-    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; }); });
+    return coinAddresses.map((coins) => coins.map((c) => c === this.constants.NATIVE_TOKEN.wrappedAddress ? this.constants.NATIVE_TOKEN.address : c));
 }
 function getExistingCoinAddressNameDict() {
-    var dict = {};
-    var _loop_1 = function (poolData) {
-        poolData.wrapped_coin_addresses.forEach(function (addr, i) {
+    const dict = {};
+    for (const poolData of Object.values(this.constants.POOLS_DATA)) {
+        poolData.wrapped_coin_addresses.forEach((addr, i) => {
             if (!(addr.toLowerCase() in dict)) {
                 dict[addr.toLowerCase()] = poolData.wrapped_coins[i];
             }
         });
-        poolData.underlying_coin_addresses.forEach(function (addr, i) {
+        poolData.underlying_coin_addresses.forEach((addr, i) => {
             if (!(addr.toLowerCase() in dict)) {
                 dict[addr.toLowerCase()] = poolData.underlying_coins[i];
             }
         });
-    };
-    for (var _i = 0, _a = Object.values(this.constants.POOLS_DATA); _i < _a.length; _i++) {
-        var poolData = _a[_i];
-        _loop_1(poolData);
     }
     dict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
     return dict;
 }
-function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, existingCoinAddrDecimalsDict) {
-    return __awaiter(this, void 0, void 0, function () {
-        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";
-                        }
-                        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());
-                    }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
-                case 1:
-                    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) {
-                        coinAddrNamesDict[addr] = symbols[i];
-                        coinAddrDecimalsDict[addr] = decimals[i];
-                    });
-                    coinAddrNamesDict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
-                    return [2 /*return*/, [tokenSymbols, tokenNames, coinAddrNamesDict, coinAddrDecimalsDict]];
-            }
-        });
+async function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, existingCoinAddrDecimalsDict) {
+    const flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
+    const newCoinAddresses = [];
+    const coinAddrNamesDict = {};
+    const coinAddrDecimalsDict = {};
+    for (const addr of flattenedCoinAddresses) {
+        if (addr in existingCoinAddrNameDict) {
+            coinAddrNamesDict[addr] = existingCoinAddrNameDict[addr];
+            coinAddrDecimalsDict[addr] = existingCoinAddrDecimalsDict[addr];
+        }
+        else if (addr === "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2") {
+            coinAddrNamesDict[addr] = "MKR";
+        }
+        else {
+            newCoinAddresses.push(addr);
+        }
+    }
+    const calls = [];
+    for (const addr of tokenAddresses) {
+        calls.push(this.contracts[addr].multicallContract.symbol());
+        calls.push(this.contracts[addr].multicallContract.name());
+    }
+    for (const addr of newCoinAddresses) {
+        calls.push(this.contracts[addr].multicallContract.symbol());
+        calls.push(this.contracts[addr].multicallContract.decimals());
+    }
+    const res = await this.multicallProvider.all(calls);
+    const res1 = res.slice(0, tokenAddresses.length * 2);
+    const tokenSymbols = res1.filter((a, i) => i % 2 == 0);
+    const tokenNames = res1.filter((a, i) => i % 2 == 1);
+    const res2 = res.slice(tokenAddresses.length * 2);
+    const symbols = res2.filter((a, i) => i % 2 == 0);
+    const decimals = res2.filter((a, i) => i % 2 == 1).map((_d) => Number(curve.formatUnits(_d, 0)));
+    newCoinAddresses.forEach((addr, i) => {
+        coinAddrNamesDict[addr] = symbols[i];
+        coinAddrDecimalsDict[addr] = decimals[i];
     });
+    coinAddrNamesDict[this.constants.NATIVE_TOKEN.address] = this.constants.NATIVE_TOKEN.symbol;
+    return [tokenSymbols, tokenNames, coinAddrNamesDict, coinAddrDecimalsDict];
 }
-function getCryptoFactoryPoolData(fromIdx, swapAddress) {
-    if (fromIdx === void 0) { fromIdx = 0; }
-    return __awaiter(this, void 0, void 0, function () {
-        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 = [[_f.sent()], [swapAddress.toLowerCase()]];
-                    return [3 /*break*/, 4];
-                case 2: return [4 /*yield*/, getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx)];
-                case 3:
-                    _b = _f.sent();
-                    _f.label = 4;
-                case 4:
-                    _a = _b, poolIds = _a[0], swapAddresses = _a[1];
-                    if (poolIds.length === 0)
-                        return [2 /*return*/, {}];
-                    return [4 /*yield*/, getPoolsData.call(this, swapAddresses)];
-                case 5:
-                    _c = _f.sent(), tokenAddresses = _c[0], gaugeAddresses = _c[1], coinAddresses = _c[2];
-                    setCryptoFactorySwapContracts.call(this, swapAddresses);
-                    setCryptoFactoryTokenContracts.call(this, tokenAddresses);
-                    setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
-                    setCryptoFactoryCoinsContracts.call(this, coinAddresses);
-                    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;
-                        basePoolIdZapDict = constants_crypto_1.CRYPTO_FACTORY_CONSTANTS[this.chainId].basePoolIdZapDict;
-                        basePoolId = lpTokenBasePoolIdDict[coinAddresses[i][1].toLowerCase()];
-                        if (basePoolId) { // isMeta
-                            allPoolsData = __assign(__assign({}, this.constants.POOLS_DATA), CRYPTO_FACTORY_POOLS_DATA);
-                            basePoolCoinNames = __spreadArray([], allPoolsData[basePoolId].underlying_coins, true);
-                            basePoolCoinAddresses = __spreadArray([], allPoolsData[basePoolId].underlying_coin_addresses, true);
-                            basePoolDecimals = __spreadArray([], allPoolsData[basePoolId].underlying_decimals, true);
-                            basePoolZap = basePoolIdZapDict[basePoolId];
-                            CRYPTO_FACTORY_POOLS_DATA[poolIds[i]] = {
-                                name: poolNames[i].split(": ")[1].trim(),
-                                full_name: poolNames[i],
-                                symbol: poolSymbols[i],
-                                reference_asset: "CRYPTO",
-                                swap_address: swapAddresses[i],
-                                token_address: tokenAddresses[i],
-                                gauge_address: gaugeAddresses[i],
-                                deposit_address: basePoolZap.address,
-                                is_meta: true,
-                                is_crypto: true,
-                                is_factory: true,
-                                base_pool: basePoolId,
-                                underlying_coins: __spreadArray([coinAddressNameDict[underlyingCoinAddresses[i][0]]], basePoolCoinNames, true),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
-                                underlying_coin_addresses: __spreadArray([underlyingCoinAddresses[i][0]], basePoolCoinAddresses, true),
-                                wrapped_coin_addresses: coinAddresses[i],
-                                underlying_decimals: __spreadArray([coinAddressDecimalsDict[underlyingCoinAddresses[i][0]]], basePoolDecimals, true),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
-                                swap_abi: factory_crypto_pool_2_json_1.default,
-                                gauge_abi: this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default,
-                                deposit_abi: basePoolZap.ABI,
-                            };
-                        }
-                        else {
-                            CRYPTO_FACTORY_POOLS_DATA[poolIds[i]] = {
-                                name: poolNames[i].split(": ")[1].trim(),
-                                full_name: poolNames[i],
-                                symbol: poolSymbols[i],
-                                reference_asset: "CRYPTO",
-                                swap_address: swapAddresses[i],
-                                token_address: tokenAddresses[i],
-                                gauge_address: gaugeAddresses[i],
-                                is_crypto: true,
-                                is_plain: underlyingCoinAddresses[i].toString() === coinAddresses[i].toString(),
-                                is_factory: true,
-                                underlying_coins: underlyingCoinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
-                                underlying_coin_addresses: underlyingCoinAddresses[i],
-                                wrapped_coin_addresses: coinAddresses[i],
-                                underlying_decimals: underlyingCoinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
-                                swap_abi: factory_crypto_pool_2_json_1.default,
-                                gauge_abi: this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default,
-                            };
-                        }
-                    }
-                    return [2 /*return*/, CRYPTO_FACTORY_POOLS_DATA];
-            }
-        });
-    });
+export async function getCryptoFactoryPoolData(fromIdx = 0, swapAddress) {
+    const [poolIds, swapAddresses] = swapAddress ?
+        [[await getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
+        : await getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
+    if (poolIds.length === 0)
+        return {};
+    const [tokenAddresses, gaugeAddresses, coinAddresses] = await getPoolsData.call(this, swapAddresses);
+    setCryptoFactorySwapContracts.call(this, swapAddresses);
+    setCryptoFactoryTokenContracts.call(this, tokenAddresses);
+    setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
+    setCryptoFactoryCoinsContracts.call(this, coinAddresses);
+    setFactoryZapContracts.call(this, true);
+    const underlyingCoinAddresses = getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses);
+    const existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
+    const [poolSymbols, poolNames, coinAddressNameDict, coinAddressDecimalsDict] = await getCoinsData.call(this, tokenAddresses, coinAddresses, existingCoinAddressNameDict, this.constants.DECIMALS);
+    const CRYPTO_FACTORY_POOLS_DATA = {};
+    for (let i = 0; i < poolIds.length; i++) {
+        const lpTokenBasePoolIdDict = CRYPTO_FACTORY_CONSTANTS[this.chainId].lpTokenBasePoolIdDict;
+        const basePoolIdZapDict = CRYPTO_FACTORY_CONSTANTS[this.chainId].basePoolIdZapDict;
+        const basePoolId = lpTokenBasePoolIdDict[coinAddresses[i][1].toLowerCase()];
+        if (basePoolId) { // isMeta
+            const allPoolsData = { ...this.constants.POOLS_DATA, ...CRYPTO_FACTORY_POOLS_DATA };
+            const basePoolCoinNames = [...allPoolsData[basePoolId].underlying_coins];
+            const basePoolCoinAddresses = [...allPoolsData[basePoolId].underlying_coin_addresses];
+            const basePoolDecimals = [...allPoolsData[basePoolId].underlying_decimals];
+            const basePoolZap = basePoolIdZapDict[basePoolId];
+            CRYPTO_FACTORY_POOLS_DATA[poolIds[i]] = {
+                name: poolNames[i].split(": ")[1].trim(),
+                full_name: poolNames[i],
+                symbol: poolSymbols[i],
+                reference_asset: "CRYPTO",
+                swap_address: swapAddresses[i],
+                token_address: tokenAddresses[i],
+                gauge_address: gaugeAddresses[i],
+                deposit_address: basePoolZap.address,
+                is_meta: true,
+                is_crypto: true,
+                is_factory: true,
+                base_pool: basePoolId,
+                underlying_coins: [coinAddressNameDict[underlyingCoinAddresses[i][0]], ...basePoolCoinNames],
+                wrapped_coins: coinAddresses[i].map((addr) => coinAddressNameDict[addr]),
+                underlying_coin_addresses: [underlyingCoinAddresses[i][0], ...basePoolCoinAddresses],
+                wrapped_coin_addresses: coinAddresses[i],
+                underlying_decimals: [coinAddressDecimalsDict[underlyingCoinAddresses[i][0]], ...basePoolDecimals],
+                wrapped_decimals: coinAddresses[i].map((addr) => coinAddressDecimalsDict[addr]),
+                swap_abi: cryptoFactorySwapABI,
+                gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+                deposit_abi: basePoolZap.ABI,
+            };
+        }
+        else {
+            CRYPTO_FACTORY_POOLS_DATA[poolIds[i]] = {
+                name: poolNames[i].split(": ")[1].trim(),
+                full_name: poolNames[i],
+                symbol: poolSymbols[i],
+                reference_asset: "CRYPTO",
+                swap_address: swapAddresses[i],
+                token_address: tokenAddresses[i],
+                gauge_address: gaugeAddresses[i],
+                is_crypto: true,
+                is_plain: underlyingCoinAddresses[i].toString() === coinAddresses[i].toString(),
+                is_factory: true,
+                underlying_coins: underlyingCoinAddresses[i].map((addr) => coinAddressNameDict[addr]),
+                wrapped_coins: coinAddresses[i].map((addr) => coinAddressNameDict[addr]),
+                underlying_coin_addresses: underlyingCoinAddresses[i],
+                wrapped_coin_addresses: coinAddresses[i],
+                underlying_decimals: underlyingCoinAddresses[i].map((addr) => coinAddressDecimalsDict[addr]),
+                wrapped_decimals: coinAddresses[i].map((addr) => coinAddressDecimalsDict[addr]),
+                swap_abi: cryptoFactorySwapABI,
+                gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+            };
+        }
+    }
+    return CRYPTO_FACTORY_POOLS_DATA;
 }
-exports.getCryptoFactoryPoolData = getCryptoFactoryPoolData;