@curvefi/api 2.16.2 → 2.17.0

package/lib/factory/deploy.js

@@ -0,0 +1,358 @@
+"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.getDeployedGaugeAddress = exports.deployGauge = exports.deployGaugeEstimateGas = exports.getDeployedCryptoPoolAddress = exports.deployCryptoPool = exports.deployCryptoPoolEstimateGas = exports.getDeployedStableMetaPoolAddress = exports.deployStableMetaPool = exports.deployStableMetaPoolEstimateGas = exports.getDeployedStablePlainPoolAddress = exports.deployStablePlainPool = exports.deployStablePlainPoolEstimateGas = void 0;
+var ethers_1 = require("ethers");
+var curve_1 = require("../curve");
+var utils_1 = require("../utils");
+var curve_lp_token_v5_json_1 = __importDefault(require("../constants/abis/curve_lp_token_v5.json"));
+// ------- STABLE PLAIN POOLS -------
+var _deployStablePlainPool = function (name, symbol, coins, A, fee, // %
+assetType, implementationIdx, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var _A, _fee, _coins, contract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (name.length > 32)
+                    throw Error("Max name length = 32");
+                if (symbol.length > 10)
+                    throw Error("Max symbol length = 10");
+                if (![2, 3, 4].includes(coins.length))
+                    throw Error("Invalid number of coins. Must be 2, 3 or 4");
+                if (fee < 0.04)
+                    throw Error("Fee must be >= 0.04%");
+                if (fee > 1)
+                    throw Error("Fee must be <= 1%");
+                if (![0, 1, 2, 3].includes(assetType))
+                    throw Error("Invalid assetType. Must be one of: 0 = USD, 1 = ETH, 2 = BTC, 3 = Other");
+                if (![0, 1, 2, 3].includes(implementationIdx))
+                    throw Error("Invalid implementationIdx. Must be one 0, 1, 2 or 3");
+                _A = (0, utils_1.parseUnits)(A, 0);
+                _fee = (0, utils_1.parseUnits)(fee, 8);
+                _coins = coins.concat(Array(4 - coins.length).fill(ethers_1.ethers.constants.AddressZero));
+                contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.factory].contract;
+                return [4 /*yield*/, contract.estimateGas.deploy_plain_pool(name, symbol, _coins, _A, _fee, assetType, implementationIdx, curve_1.curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, gas.toNumber()];
+                gasLimit = gas.mul(130).div(100);
+                return [4 /*yield*/, curve_1.curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_plain_pool(name, symbol, _coins, _A, _fee, assetType, implementationIdx, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var deployStablePlainPoolEstimateGas = function (name, symbol, coins, A, fee, // %
+assetType, implementationIdx) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStablePlainPool(name, symbol, coins, A, fee, assetType, implementationIdx, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployStablePlainPoolEstimateGas = deployStablePlainPoolEstimateGas;
+var deployStablePlainPool = function (name, symbol, coins, A, fee, // %
+assetType, implementationIdx) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStablePlainPool(name, symbol, coins, A, fee, assetType, implementationIdx, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployStablePlainPool = deployStablePlainPool;
+var getDeployedStablePlainPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                return [2 /*return*/, txInfo.logs[0].address.toLowerCase()];
+        }
+    });
+}); };
+exports.getDeployedStablePlainPoolAddress = getDeployedStablePlainPoolAddress;
+// ------- STABLE META POOLS -------
+var _deployStableMetaPool = function (basePool, name, symbol, coin, A, fee, // %
+implementationIdx, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var _A, _fee, contract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (name.length > 32)
+                    throw Error("Max name length = 32");
+                if (symbol.length > 10)
+                    throw Error("Max symbol length = 10");
+                if (fee < 0.04)
+                    throw Error("Fee must be >= 0.04%");
+                if (fee > 1)
+                    throw Error("Fee must be <= 1%");
+                if (![0, 1].includes(implementationIdx))
+                    throw Error("Invalid implementationIdx. Must be one 0 or 1");
+                _A = (0, utils_1.parseUnits)(A, 0);
+                _fee = (0, utils_1.parseUnits)(fee, 8);
+                contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.factory].contract;
+                return [4 /*yield*/, contract.estimateGas.deploy_metapool(basePool, name, symbol, coin, _A, _fee, implementationIdx, curve_1.curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, gas.toNumber()];
+                gasLimit = gas.mul(130).div(100);
+                return [4 /*yield*/, curve_1.curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_metapool(basePool, name, symbol, coin, _A, _fee, implementationIdx, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var deployStableMetaPoolEstimateGas = function (basePool, name, symbol, coin, A, fee, // %
+implementationIdx) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableMetaPool(basePool, name, symbol, coin, A, fee, implementationIdx, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployStableMetaPoolEstimateGas = deployStableMetaPoolEstimateGas;
+var deployStableMetaPool = function (basePool, name, symbol, coin, A, fee, // %
+implementationIdx) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableMetaPool(basePool, name, symbol, coin, A, fee, implementationIdx, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployStableMetaPool = deployStableMetaPool;
+var getDeployedStableMetaPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                return [2 /*return*/, txInfo.logs[txInfo.logs.length - 3].address.toLowerCase()];
+        }
+    });
+}); };
+exports.getDeployedStableMetaPoolAddress = getDeployedStableMetaPoolAddress;
+// ------- CRYPTO POOLS -------
+var _deployCryptoPool = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, maHalfTime, // Seconds
+initialPrice, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var _gamma, _midFee, _outFee, _allowedExtraProfit, _feeGamma, _adjustmentStep, _initialPrice, contract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (name.length > 32)
+                    throw Error("Max name length = 32");
+                if (symbol.length > 10)
+                    throw Error("Max symbol length = 10");
+                if (coins.length !== 2)
+                    throw Error("Invalid number of coins. Must be 2");
+                if (coins[1] === coins[2])
+                    throw Error("Coins must be different");
+                if (A < 4000)
+                    throw Error("A must be >= 4000");
+                if (A > 4 * (Math.pow(10, 9)))
+                    throw Error("A must be <= 4 * 10 ** 9");
+                if (gamma < 1e-8)
+                    throw Error("gamma must be >= 1e-8");
+                if (gamma > 0.02)
+                    throw Error("gamma must be <= 0.02");
+                if (midFee < 0.005)
+                    throw Error("midFee must be >= 0.005");
+                if (midFee > 100)
+                    throw Error("midFee must be <= 100");
+                if (outFee < midFee)
+                    throw Error("outFee must be >= midFee");
+                if (outFee > 100)
+                    throw Error("outFee must be <= 100");
+                if (allowedExtraProfit < 0)
+                    throw Error("allowedExtraProfit must be >= 0");
+                if (allowedExtraProfit > 0.01)
+                    throw Error("allowedExtraProfit must be <= 0.01");
+                if (feeGamma < 0)
+                    throw Error("feeGamma must be >= 0");
+                if (feeGamma > 1)
+                    throw Error("feeGamma must be <= 1");
+                if (adjustmentStep < 0)
+                    throw Error("adjustmentStep must be >= 0");
+                if (adjustmentStep > 1)
+                    throw Error("adjustmentStep must be <= 1");
+                if (maHalfTime < 0)
+                    throw Error("daoFee must be >= 0");
+                if (maHalfTime > 604800)
+                    throw Error("daoFee must be <= 604800");
+                if (initialPrice < 1e-12)
+                    throw Error("initialPrice must be >= 1e-12");
+                if (initialPrice > 1e12)
+                    throw Error("initialPrice must be <= 1e12");
+                _gamma = (0, utils_1.parseUnits)(gamma);
+                _midFee = (0, utils_1.parseUnits)(midFee, 8);
+                _outFee = (0, utils_1.parseUnits)(outFee, 8);
+                _allowedExtraProfit = (0, utils_1.parseUnits)(allowedExtraProfit);
+                _feeGamma = (0, utils_1.parseUnits)(feeGamma);
+                _adjustmentStep = (0, utils_1.parseUnits)(adjustmentStep);
+                _initialPrice = (0, utils_1.parseUnits)(initialPrice);
+                contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.crypto_factory].contract;
+                return [4 /*yield*/, contract.estimateGas.deploy_pool(name, symbol, coins, A, _gamma, _midFee, _outFee, _allowedExtraProfit, _feeGamma, _adjustmentStep, 5000000000, maHalfTime, _initialPrice, curve_1.curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, gas.toNumber()];
+                gasLimit = gas.mul(130).div(100);
+                return [4 /*yield*/, curve_1.curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_pool(name, symbol, coins, A, _gamma, _midFee, _outFee, _allowedExtraProfit, _feeGamma, _adjustmentStep, 5000000000, // 50%
+                    maHalfTime, _initialPrice, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var deployCryptoPoolEstimateGas = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, maHalfTime, // Seconds
+initialPrice) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployCryptoPool(name, symbol, coins, A, gamma, midFee, outFee, allowedExtraProfit, feeGamma, adjustmentStep, maHalfTime, initialPrice, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployCryptoPoolEstimateGas = deployCryptoPoolEstimateGas;
+var deployCryptoPool = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, maHalfTime, // Seconds
+initialPrice) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployCryptoPool(name, symbol, coins, A, gamma, midFee, outFee, allowedExtraProfit, feeGamma, adjustmentStep, maHalfTime, initialPrice, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.deployCryptoPool = deployCryptoPool;
+var getDeployedCryptoPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo, lpTokenAddress, contract;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                lpTokenAddress = txInfo.logs[0].address;
+                contract = new ethers_1.Contract(lpTokenAddress, curve_lp_token_v5_json_1.default, curve_1.curve.provider);
+                return [4 /*yield*/, contract.minter(curve_1.curve.constantOptions)];
+            case 2: return [2 /*return*/, (_a.sent()).toLowerCase()];
+        }
+    });
+}); };
+exports.getDeployedCryptoPoolAddress = getDeployedCryptoPoolAddress;
+// ------- GAUGE -------
+var _deployGauge = function (pool, isCrypto, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var contractAddress, contract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                contractAddress = isCrypto ? curve_1.curve.constants.ALIASES.crypto_factory : curve_1.curve.constants.ALIASES.factory;
+                contract = curve_1.curve.contracts[contractAddress].contract;
+                return [4 /*yield*/, contract.estimateGas.deploy_gauge(pool, curve_1.curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, gas.toNumber()];
+                gasLimit = gas.mul(130).div(100);
+                return [4 /*yield*/, curve_1.curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_gauge(pool, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var deployGaugeEstimateGas = function (pool, isCrypto) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGauge(pool, isCrypto, true)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+exports.deployGaugeEstimateGas = deployGaugeEstimateGas;
+var deployGauge = function (pool, isCrypto) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGauge(pool, isCrypto, false)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+exports.deployGauge = deployGauge;
+var getDeployedGaugeAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                // @ts-ignore
+                return [2 /*return*/, txInfo.events[0].args[txInfo.events[0].args.length - 1].toLowerCase()];
+        }
+    });
+}); };
+exports.getDeployedGaugeAddress = getDeployedGaugeAddress;

package/lib/factory/factory-api.js

@@ -65,7 +65,6 @@ var ethers_1 = require("ethers");
 var ethcall_1 = require("ethcall");
 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 gauge_rewards_only_json_1 = __importDefault(require("../constants/abis/gauge_rewards_only.json"));
 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 constants_1 = require("./constants");
@@ -109,8 +108,8 @@ function setFactoryGaugeContracts(rawPoolList) {
         if (pool.gaugeAddress) {
             var addr = pool.gaugeAddress.toLowerCase();
             _this.contracts[addr] = {
-                contract: new ethers_1.Contract(addr, _this.chainId === 1 ? gauge_factory_json_1.default : _this.chainId === 2222 ? gauge_rewards_only_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 : _this.chainId === 2222 ? gauge_rewards_only_json_1.default : gauge_child_json_1.default),
+                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),
             };
         }
     });
@@ -130,22 +129,6 @@ function setFactoryCoinsContracts(rawPoolList) {
         }
     }
 }
-function setFactoryRewardCoinsContracts(rawPoolList) {
-    var _a;
-    for (var _i = 0, rawPoolList_2 = rawPoolList; _i < rawPoolList_2.length; _i++) {
-        var pool = rawPoolList_2[_i];
-        for (var _b = 0, _c = (_a = pool.gaugeRewards) !== null && _a !== void 0 ? _a : []; _b < _c.length; _b++) {
-            var rewardCoin = _c[_b];
-            var addr = rewardCoin.tokenAddress.toLowerCase();
-            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 getFactoryPoolsDataFromApi(isCrypto) {
     return __awaiter(this, void 0, void 0, function () {
         var network, factoryType, url, response, rawPoolList, mainAddresses, url_1, response_1, poolGaugeDict, _i, _a, gaugeData, i, FACTORY_POOLS_DATA;
@@ -182,7 +165,6 @@ function getFactoryPoolsDataFromApi(isCrypto) {
                         setCryptoFactoryTokenContracts.call(this, rawPoolList);
                     setFactoryGaugeContracts.call(this, rawPoolList);
                     setFactoryCoinsContracts.call(this, rawPoolList);
-                    setFactoryRewardCoinsContracts.call(this, rawPoolList);
                     common_1.setFactoryZapContracts.call(this, isCrypto);
                     FACTORY_POOLS_DATA = {};
                     rawPoolList.forEach(function (pool) {
@@ -310,7 +292,7 @@ function getFactoryPoolsDataFromApi(isCrypto) {
                                 underlying_decimals: coinDecimals,
                                 wrapped_decimals: coinDecimals,
                                 swap_abi: implementationABIDict[pool.implementationAddress],
-                                gauge_abi: _this.chainId === 1 ? gauge_factory_json_1.default : _this.chainId === 2222 ? gauge_rewards_only_json_1.default : gauge_child_json_1.default, // TODO remove RewardsOnly for Kava
+                                gauge_abi: _this.chainId === 1 ? gauge_factory_json_1.default : gauge_child_json_1.default,
                             };
                         }
                     });

package/lib/factory/factory-crypto.d.ts

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

package/lib/factory/factory-crypto.js

@@ -69,6 +69,36 @@ var gauge_child_json_1 = __importDefault(require("../constants/abis/gauge_child.
 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");
+            }
+        });
+    });
+}
 function getCryptoFactoryIdsAndSwapAddresses() {
     return __awaiter(this, void 0, void 0, function () {
         var factoryContract, factoryMulticallContract, poolCount, _a, _b, _c, calls, i, factories, swapAddresses;
@@ -334,40 +364,50 @@ function getCoinAddressDecimalsDict(coinAddresses, existingCoinAddressDecimalsDi
         });
     });
 }
-function getCryptoFactoryPoolData() {
+function getCryptoFactoryPoolData(swapAddress) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, poolIds, swapAddresses, tokenAddresses, gaugeAddresses, _b, poolSymbols, poolNames, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, CRYPTO_FACTORY_POOLS_DATA, i, lpTokenBasePoolIdDict, basePoolIdZapDict, basePoolId, allPoolsData, basePoolCoinNames, basePoolCoinAddresses, basePoolDecimals, basePoolZap;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, getCryptoFactoryIdsAndSwapAddresses.call(this)];
+        var _a, poolIds, swapAddresses, _b, tokenAddresses, gaugeAddresses, _c, poolSymbols, poolNames, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, CRYPTO_FACTORY_POOLS_DATA, i, lpTokenBasePoolIdDict, basePoolIdZapDict, basePoolId, allPoolsData, basePoolCoinNames, basePoolCoinAddresses, basePoolDecimals, basePoolZap;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (!swapAddress) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getRecentlyCreatedCryptoPoolId.call(this, swapAddress)];
                 case 1:
-                    _a = _c.sent(), poolIds = _a[0], swapAddresses = _a[1];
+                    _b = [[_e.sent()], [swapAddress.toLowerCase()]];
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, getCryptoFactoryIdsAndSwapAddresses.call(this)];
+                case 3:
+                    _b = _e.sent();
+                    _e.label = 4;
+                case 4:
+                    _a = _b, poolIds = _a[0], swapAddresses = _a[1];
+                    // const [poolIds, swapAddresses] = await getCryptoFactoryIdsAndSwapAddresses.call(this);
                     setCryptoFactorySwapContracts.call(this, swapAddresses);
                     return [4 /*yield*/, getCryptoFactoryTokenAddresses.call(this, swapAddresses)];
-                case 2:
-                    tokenAddresses = _c.sent();
+                case 5:
+                    tokenAddresses = _e.sent();
                     setCryptoFactoryTokenContracts.call(this, tokenAddresses);
                     return [4 /*yield*/, getCryptoFactoryGaugeAddresses.call(this, swapAddresses)];
-                case 3:
-                    gaugeAddresses = _c.sent();
+                case 6:
+                    gaugeAddresses = _e.sent();
                     setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
                     return [4 /*yield*/, getCryptoFactorySymbolsAndNames.call(this, tokenAddresses)];
-                case 4:
-                    _b = _c.sent(), poolSymbols = _b[0], poolNames = _b[1];
+                case 7:
+                    _c = _e.sent(), poolSymbols = _c[0], poolNames = _c[1];
                     return [4 /*yield*/, getCryptoFactoryCoinAddresses.call(this, swapAddresses)];
-                case 5:
-                    coinAddresses = _c.sent();
+                case 8:
+                    coinAddresses = _e.sent();
                     setCryptoFactoryCoinsContracts.call(this, coinAddresses);
                     return [4 /*yield*/, getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses)];
-                case 6:
-                    underlyingCoinAddresses = _c.sent();
+                case 9:
+                    underlyingCoinAddresses = _e.sent();
                     existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
                     return [4 /*yield*/, getCoinAddressNameDict.call(this, coinAddresses, existingCoinAddressNameDict)];
-                case 7:
-                    coinAddressNameDict = _c.sent();
+                case 10:
+                    coinAddressNameDict = _e.sent();
                     return [4 /*yield*/, getCoinAddressDecimalsDict.call(this, coinAddresses, this.constants.DECIMALS)];
-                case 8:
-                    coinAddressDecimalsDict = _c.sent();
+                case 11:
+                    coinAddressDecimalsDict = _e.sent();
                     common_1.setFactoryZapContracts.call(this, true);
                     CRYPTO_FACTORY_POOLS_DATA = {};
                     for (i = 0; i < poolIds.length; i++) {

package/lib/factory/factory.d.ts

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

package/lib/factory/factory.js

@@ -84,6 +84,36 @@ var BLACK_LIST = {
     42161: [],
 };
 var deepFlatten = function (arr) { return [].concat.apply([], arr.map(function (v) { return (Array.isArray(v) ? deepFlatten(v) : v); })); };
+function getRecentlyCreatedPoolId(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.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-v2-".concat(poolCount - i)];
+                    _e.label = 4;
+                case 4:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 5: throw Error("Unknown pool");
+            }
+        });
+    });
+}
 function getFactoryIdsAndSwapAddresses() {
     return __awaiter(this, void 0, void 0, function () {
         var factoryContract, factoryMulticallContract, poolCount, _a, _b, _c, calls, i, factories, swapAddresses, blacklist;
@@ -375,44 +405,53 @@ function getFactoryIsMeta(factorySwapAddresses) {
         });
     });
 }
-function getFactoryPoolData() {
+function getFactoryPoolData(swapAddress) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, poolIds, swapAddresses, implementations, implementationABIDict, swapABIs, gaugeAddresses, _b, poolSymbols, poolNames, referenceAssets, coinAddresses, existingCoinAddressNameDict, coinAddressNameDict, coinAddressDecimalsDict, isMeta, implementationBasePoolIdDict, basePoolIds, FACTORY_POOLS_DATA, _loop_2, this_1, i;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, getFactoryIdsAndSwapAddresses.call(this)];
+        var _a, poolIds, swapAddresses, _b, implementations, implementationABIDict, 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) {
+                case 0:
+                    if (!swapAddress) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getRecentlyCreatedPoolId.call(this, swapAddress)];
                 case 1:
-                    _a = _c.sent(), poolIds = _a[0], swapAddresses = _a[1];
+                    _b = [[_e.sent()], [swapAddress.toLowerCase()]];
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, getFactoryIdsAndSwapAddresses.call(this)];
+                case 3:
+                    _b = _e.sent();
+                    _e.label = 4;
+                case 4:
+                    _a = _b, poolIds = _a[0], swapAddresses = _a[1];
                     return [4 /*yield*/, getFactoryImplementations.call(this, swapAddresses)];
-                case 2:
-                    implementations = _c.sent();
+                case 5:
+                    implementations = _e.sent();
                     implementationABIDict = constants_1.FACTORY_CONSTANTS[this.chainId].implementationABIDict;
                     swapABIs = implementations.map(function (addr) { return implementationABIDict[addr]; });
                     setFactorySwapContracts.call(this, swapAddresses, swapABIs);
                     return [4 /*yield*/, getFactoryGaugeAddresses.call(this, swapAddresses)];
-                case 3:
-                    gaugeAddresses = _c.sent();
+                case 6:
+                    gaugeAddresses = _e.sent();
                     setFactoryGaugeContracts.call(this, gaugeAddresses);
                     return [4 /*yield*/, getFactorySymbolsAndNames.call(this, swapAddresses)];
-                case 4:
-                    _b = _c.sent(), poolSymbols = _b[0], poolNames = _b[1];
+                case 7:
+                    _c = _e.sent(), poolSymbols = _c[0], poolNames = _c[1];
                     return [4 /*yield*/, getFactoryReferenceAssets.call(this, swapAddresses)];
-                case 5:
-                    referenceAssets = _c.sent();
+                case 8:
+                    referenceAssets = _e.sent();
                     return [4 /*yield*/, getFactoryCoinAddresses.call(this, swapAddresses)];
-                case 6:
-                    coinAddresses = _c.sent();
+                case 9:
+                    coinAddresses = _e.sent();
                     setFactoryCoinsContracts.call(this, coinAddresses);
                     existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
                     return [4 /*yield*/, getCoinAddressNameDict.call(this, coinAddresses, existingCoinAddressNameDict)];
-                case 7:
-                    coinAddressNameDict = _c.sent();
+                case 10:
+                    coinAddressNameDict = _e.sent();
                     return [4 /*yield*/, getCoinAddressDecimalsDict.call(this, coinAddresses, this.constants.DECIMALS)];
-                case 8:
-                    coinAddressDecimalsDict = _c.sent();
+                case 11:
+                    coinAddressDecimalsDict = _e.sent();
                     return [4 /*yield*/, getFactoryIsMeta.call(this, swapAddresses)];
-                case 9:
-                    isMeta = _c.sent();
+                case 12:
+                    isMeta = _e.sent();
                     implementationBasePoolIdDict = constants_1.FACTORY_CONSTANTS[this.chainId].implementationBasePoolIdDict;
                     basePoolIds = implementations.map(function (addr) { return implementationBasePoolIdDict[addr]; });
                     common_1.setFactoryZapContracts.call(this, false);