@curvefi/api 1.17.2 → 1.20.0

package/lib/curve.js

@@ -62,6 +62,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.curve = exports.ALIASES = exports.DECIMALS_LOWER_CASE = exports.DECIMALS = exports.COINS = exports.USD_COINS_LOWER_CASE = exports.USD_COINS = exports.EUR_COINS_LOWER_CASE = exports.EUR_COINS = exports.LINK_COINS_LOWER_CASE = exports.LINK_COINS = exports.ETH_COINS_LOWER_CASE = exports.ETH_COINS = exports.BTC_COINS_LOWER_CASE = exports.BTC_COINS = exports.GAUGES = exports.LP_TOKENS = exports.POOLS_DATA = void 0;
 var ethers_1 = require("ethers");
 var ethcall_1 = require("ethcall");
+var factory_1 = require("./factory");
+var factory_crypto_1 = require("./factory-crypto");
 var ERC20_json_1 = __importDefault(require("./constants/abis/json/ERC20.json"));
 var cERC20_json_1 = __importDefault(require("./constants/abis/json/cERC20.json"));
 var yERC20_json_1 = __importDefault(require("./constants/abis/json/yERC20.json"));
@@ -73,6 +75,8 @@ var router_json_1 = __importDefault(require("./constants/abis/json/router.json")
 var deposit_and_stake_json_1 = __importDefault(require("./constants/abis/json/deposit_and_stake.json"));
 var registry_exchange_json_1 = __importDefault(require("./constants/abis/json/registry_exchange.json"));
 var streamer_json_1 = __importDefault(require("./constants/abis/json/streamer.json"));
+var factory_json_1 = __importDefault(require("./constants/abis/json/factory.json"));
+var factory_crypto_json_1 = __importDefault(require("./constants/abis/json/factory-crypto.json"));
 var abis_ethereum_1 = require("./constants/abis/abis-ethereum");
 var abis_polygon_1 = require("./constants/abis/abis-polygon");
 var coins_ethereum_1 = require("./constants/coins-ethereum");
@@ -86,6 +90,8 @@ exports.ALIASES = {
     "address_provider": "0x0000000022d53366457f9d5e68ec105046fc4383",
     "router": "0xfA9a30350048B2BF66865ee20363067c66f67e58",
     "deposit_and_stake": "0x271fbE8aB7f1fB262f81C77Ea5303F03DA9d3d6A",
+    "factory": '0xb9fc157394af804a3578134a6585c0dc9cc990d4',
+    "crypto_factory": '0xF18056Bbd320E96A48e3Fbf8bC061322531aac99',
     "registry_exchange": "",
 };
 var Curve = /** @class */ (function () {
@@ -102,6 +108,7 @@ var Curve = /** @class */ (function () {
         this.feeData = {};
         this.constantOptions = { gasLimit: 12000000 };
         this.options = {};
+        this.constants = {};
     }
     Curve.prototype.init = function (providerType, providerSettings, options // gasPrice in Gwei
     ) {
@@ -409,11 +416,66 @@ var Curve = /** @class */ (function () {
                             contract: new ethers_1.Contract(exports.ALIASES.deposit_and_stake, deposit_and_stake_json_1.default, this.signer || this.provider),
                             multicallContract: new ethcall_1.Contract(exports.ALIASES.deposit_and_stake, deposit_and_stake_json_1.default),
                         };
+                        this.contracts[exports.ALIASES.factory] = {
+                            contract: new ethers_1.Contract(exports.ALIASES.factory, factory_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(exports.ALIASES.factory, factory_json_1.default),
+                        };
+                        this.contracts[exports.ALIASES.factory.toLowerCase()] = {
+                            contract: new ethers_1.Contract(exports.ALIASES.factory, factory_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(exports.ALIASES.factory, factory_json_1.default),
+                        };
+                        this.contracts[exports.ALIASES.crypto_factory] = {
+                            contract: new ethers_1.Contract(exports.ALIASES.crypto_factory, factory_crypto_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(exports.ALIASES.crypto_factory, factory_crypto_json_1.default),
+                        };
+                        this.contracts[exports.ALIASES.crypto_factory.toLowerCase()] = {
+                            contract: new ethers_1.Contract(exports.ALIASES.crypto_factory, factory_crypto_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(exports.ALIASES.crypto_factory, factory_crypto_json_1.default),
+                        };
+                        this.constants = {
+                            ALIASES: exports.ALIASES,
+                            POOLS_DATA: exports.POOLS_DATA,
+                            DECIMALS_LOWER_CASE: exports.DECIMALS_LOWER_CASE,
+                            LP_TOKENS: exports.LP_TOKENS,
+                            GAUGES: exports.GAUGES,
+                        };
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Curve.prototype.fetchFactoryPools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.constants;
+                        return [4 /*yield*/, factory_1.getFactoryPoolData.call(this)];
+                    case 1:
+                        _a.FACTORY_POOLS_DATA = _b.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
+    Curve.prototype.fetchCryptoFactoryPools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this.chainId === 1 || this.chainId === 1337)) return [3 /*break*/, 2];
+                        _a = this.constants;
+                        return [4 /*yield*/, factory_crypto_1.getCryptoFactoryPoolData.call(this)];
+                    case 1:
+                        _a.CRYPTO_FACTORY_POOLS_DATA = _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
     Curve.prototype.setCustomFeeData = function (customFeeData) {
         this.feeData = __assign(__assign({}, this.feeData), customFeeData);
     };

package/lib/factory-crypto.d.ts

@@ -0,0 +1,32 @@
+import { Contract, ethers } from "ethers";
+import { Contract as MulticallContract, Provider as MulticallProvider } from "ethcall";
+import { DictInterface, PoolDataInterface } from "./interfaces";
+interface CurveInterface {
+    provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
+    multicallProvider: MulticallProvider;
+    signer: ethers.Signer;
+    signerAddress: string;
+    chainId: number;
+    contracts: {
+        [index: string]: {
+            contract: Contract;
+            multicallContract: MulticallContract;
+        };
+    };
+    feeData: {
+        gasPrice?: number;
+        maxFeePerGas?: number;
+        maxPriorityFeePerGas?: number;
+    };
+    constantOptions: {
+        gasLimit: number;
+    };
+    options: {
+        gasPrice?: number | ethers.BigNumber;
+        maxFeePerGas?: number | ethers.BigNumber;
+        maxPriorityFeePerGas?: number | ethers.BigNumber;
+    };
+    constants: DictInterface<any>;
+}
+export declare function getCryptoFactoryPoolData(this: CurveInterface): Promise<DictInterface<PoolDataInterface>>;
+export {};

package/lib/factory-crypto.js

@@ -0,0 +1,377 @@
+"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 (_) 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 __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 ethcall_1 = require("ethcall");
+var ERC20_json_1 = __importDefault(require("./constants/abis/json/ERC20.json"));
+var factory_crypto_pool_2_json_1 = __importDefault(require("./constants/abis/json/factory-crypto/factory-crypto-pool-2.json"));
+var gauge_factory_json_1 = __importDefault(require("./constants/abis/json/gauge_factory.json"));
+var WETH_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+var deepFlatten = function (arr) { return [].concat.apply([], arr.map(function (v) { return (Array.isArray(v) ? deepFlatten(v) : v); })); };
+function getCryptoFactorySwapAddresses() {
+    return __awaiter(this, void 0, void 0, function () {
+        var factoryContract, factoryMulticallContract, poolCount, _a, _b, _c, calls, i, factorySwapAddresses, 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 = 0; i < poolCount; i++) {
+                        calls.push(factoryMulticallContract.pool_list(i));
+                    }
+                    return [4 /*yield*/, this.multicallProvider.all(calls)];
+                case 2:
+                    factorySwapAddresses = (_e.sent()).map(function (addr) { return addr.toLowerCase(); });
+                    swapAddresses = Object.values(__assign(__assign({}, this.constants.POOLS_DATA), this.constants.FACTORY_POOLS_DATA))
+                        .map(function (pool) { return pool.swap_address.toLowerCase(); });
+                    return [2 /*return*/, factorySwapAddresses.filter(function (addr) { return !swapAddresses.includes(addr); })];
+            }
+        });
+    });
+}
+function setCryptoFactorySwapContracts(factorySwapAddresses) {
+    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),
+        };
+    });
+}
+function getCryptoFactoryTokenAddresses(factorySwapAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, 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_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
+                        addr = factorySwapAddresses_1[_i];
+                        calls.push(factoryMulticallContract.get_token(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.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),
+        };
+    });
+}
+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 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, gauge_factory_json_1.default, _this.signer || _this.provider),
+            multicallContract: new ethcall_1.Contract(addr, gauge_factory_json_1.default),
+        };
+    });
+}
+function getCryptoFactoryPoolNames(factoryTokenAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        var calls, _i, factoryTokenAddresses_1, addr, names, existingNames, i, n;
+        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());
+                    }
+                    return [4 /*yield*/, this.multicallProvider.all(calls)];
+                case 1:
+                    names = (_a.sent()).map(function (name) { return name + "V2"; });
+                    existingNames = Object.keys(this.constants.POOLS_DATA);
+                    // rename duplications
+                    for (i = 0; i < names.length; i++) {
+                        if (names.indexOf(names[i]) !== i || existingNames.includes(names[i])) {
+                            n = 1;
+                            do {
+                                n++;
+                            } while (names.indexOf(names[i].slice(0, -4) + "-".concat(n) + "-fV2") !== -1 || existingNames.includes(names[i].slice(0, -4) + "-".concat(n) + "-fV2"));
+                            names[i] = names[i].slice(0, -4) + "-".concat(n) + "-fV2";
+                        }
+                    }
+                    return [2 /*return*/, names];
+            }
+        });
+    });
+}
+function getCryptoFactoryCoinAddresses(factorySwapAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        var factoryMulticallContract, calls, _i, factorySwapAddresses_3, 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_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 addr.toLowerCase(); }); })];
+            }
+        });
+    });
+}
+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];
+        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),
+        };
+    }
+}
+function getCryptoFactoryUnderlyingCoinAddresses(coinAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, coinAddresses.map(function (coins) { return coins.map(function (c) { return c === WETH_ADDRESS ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : c; }); })];
+        });
+    });
+}
+function getExistingCoinAddressNameDict() {
+    var dict = {};
+    var _loop_1 = function (poolData) {
+        poolData.coin_addresses.forEach(function (addr, i) {
+            if (!(addr.toLowerCase() in dict)) {
+                dict[addr.toLowerCase()] = poolData.coins[i];
+            }
+        });
+        poolData.underlying_coin_addresses.forEach(function (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);
+    }
+    if (this.chainId === 137)
+        dict["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"] = "MATIC";
+    return dict;
+}
+function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
+    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) {
+                case 0:
+                    flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
+                    newCoinAddresses = [];
+                    coinAddrNamesDict = {};
+                    for (_i = 0, flattenedCoinAddresses_2 = flattenedCoinAddresses; _i < flattenedCoinAddresses_2.length; _i++) {
+                        addr = flattenedCoinAddresses_2[_i];
+                        if (addr in existingCoinAddrNameDict) {
+                            coinAddrNamesDict[addr] = existingCoinAddrNameDict[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)));
+                    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 = 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)); });
+                    newCoinAddresses.forEach(function (addr, i) {
+                        coinAddrNamesDict[addr] = decimals[i];
+                        existingCoinAddressDecimalsDict[addr] = decimals[i]; // Add to DECIMALS_LOWER_CASE TODO move to another place
+                    });
+                    return [2 /*return*/, coinAddrNamesDict];
+            }
+        });
+    });
+}
+function getCryptoFactoryPoolData() {
+    return __awaiter(this, void 0, void 0, function () {
+        var swapAddresses, tokenAddresses, gaugeAddresses, poolNames, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, CRYPTO_FACTORY_POOLS_DATA, i;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, getCryptoFactorySwapAddresses.call(this)];
+                case 1:
+                    swapAddresses = _c.sent();
+                    setCryptoFactorySwapContracts.call(this, swapAddresses);
+                    return [4 /*yield*/, getCryptoFactoryTokenAddresses.call(this, swapAddresses)];
+                case 2:
+                    tokenAddresses = _c.sent();
+                    setCryptoFactoryTokenContracts.call(this, tokenAddresses);
+                    (_a = this.constants.LP_TOKENS).push.apply(_a, tokenAddresses); // TODO move to another place
+                    return [4 /*yield*/, getCryptoFactoryGaugeAddresses.call(this, swapAddresses)];
+                case 3:
+                    gaugeAddresses = _c.sent();
+                    setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
+                    (_b = this.constants.GAUGES).push.apply(_b, gaugeAddresses.filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; })); // TODO move to another place
+                    return [4 /*yield*/, getCryptoFactoryPoolNames.call(this, tokenAddresses)];
+                case 4:
+                    poolNames = _c.sent();
+                    return [4 /*yield*/, getCryptoFactoryCoinAddresses.call(this, swapAddresses)];
+                case 5:
+                    coinAddresses = _c.sent();
+                    setCryptoFactoryCoinsContracts.call(this, coinAddresses);
+                    return [4 /*yield*/, getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses)];
+                case 6:
+                    underlyingCoinAddresses = _c.sent();
+                    existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
+                    return [4 /*yield*/, getCoinAddressNameDict.call(this, coinAddresses, existingCoinAddressNameDict)];
+                case 7:
+                    coinAddressNameDict = _c.sent();
+                    coinAddressNameDict['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'] = 'ETH';
+                    return [4 /*yield*/, getCoinAddressDecimalsDict.call(this, coinAddresses, this.constants.DECIMALS_LOWER_CASE)];
+                case 8:
+                    coinAddressDecimalsDict = _c.sent();
+                    coinAddressDecimalsDict['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'] = 18;
+                    CRYPTO_FACTORY_POOLS_DATA = {};
+                    for (i = 0; i < poolNames.length; i++) {
+                        CRYPTO_FACTORY_POOLS_DATA[poolNames[i]] = {
+                            reference_asset: "CRYPTO",
+                            N_COINS: coinAddresses[i].length,
+                            is_crypto: true,
+                            underlying_decimals: underlyingCoinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                            decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                            use_lending: coinAddresses[i].map(function () { return false; }),
+                            is_plain: coinAddresses[i].map(function () { return true; }),
+                            underlying_coins: underlyingCoinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                            coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                            swap_address: swapAddresses[i],
+                            token_address: tokenAddresses[i],
+                            gauge_address: gaugeAddresses[i],
+                            underlying_coin_addresses: underlyingCoinAddresses[i],
+                            coin_addresses: coinAddresses[i],
+                            swap_abi: factory_crypto_pool_2_json_1.default[i],
+                            gauge_abi: gauge_factory_json_1.default,
+                            is_factory: true,
+                            is_crypto_factory: true,
+                        };
+                    }
+                    return [2 /*return*/, CRYPTO_FACTORY_POOLS_DATA];
+            }
+        });
+    });
+}
+exports.getCryptoFactoryPoolData = getCryptoFactoryPoolData;

package/lib/factory.d.ts

@@ -0,0 +1,32 @@
+import { Contract, ethers } from "ethers";
+import { Contract as MulticallContract, Provider as MulticallProvider } from "ethcall";
+import { DictInterface, PoolDataInterface } from "./interfaces";
+interface CurveInterface {
+    provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
+    multicallProvider: MulticallProvider;
+    signer: ethers.Signer;
+    signerAddress: string;
+    chainId: number;
+    contracts: {
+        [index: string]: {
+            contract: Contract;
+            multicallContract: MulticallContract;
+        };
+    };
+    feeData: {
+        gasPrice?: number;
+        maxFeePerGas?: number;
+        maxPriorityFeePerGas?: number;
+    };
+    constantOptions: {
+        gasLimit: number;
+    };
+    options: {
+        gasPrice?: number | ethers.BigNumber;
+        maxFeePerGas?: number | ethers.BigNumber;
+        maxPriorityFeePerGas?: number | ethers.BigNumber;
+    };
+    constants: DictInterface<any>;
+}
+export declare function getFactoryPoolData(this: CurveInterface): Promise<DictInterface<PoolDataInterface>>;
+export {};