@curvefi/api 2.38.0 → 2.40.0

package/lib/factory/factory-tricrypto.js

@@ -0,0 +1,303 @@
+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];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { curve } from "../curve.js";
+import ERC20ABI from "../constants/abis/ERC20.json" assert { type: 'json' };
+import tricryptoFactorySwapABI from "../constants/abis/factory-tricrypto/factory-tricrypto-pool.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' };
+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.tricrypto_factory].contract;
+                    _a = Number;
+                    _c = (_b = curve).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-tricrypto-".concat(poolCount - i)];
+                    _e.label = 4;
+                case 4:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 5: 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.tricrypto_factory].contract;
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
+                    _a = Number;
+                    _c = (_b = curve).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-tricrypto-".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; })]];
+            }
+        });
+    });
+}
+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(); }); });
+}
+function getPoolsData(factorySwapAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, gaugeAddresses, coinAddresses;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
+                    calls = [];
+                    for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
+                        addr = factorySwapAddresses_1[_i];
+                        calls.push(factoryMulticallContract.get_gauge(addr));
+                        calls.push(factoryMulticallContract.get_coins(addr));
+                    }
+                    return [4 /*yield*/, this.multicallProvider.all(calls)];
+                case 1:
+                    res = _a.sent();
+                    gaugeAddresses = res.filter(function (a, i) { return i % 2 == 0; }).map(function (a) { return a.toLowerCase(); });
+                    coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 2 == 1; }));
+                    return [2 /*return*/, [gaugeAddresses, coinAddresses]];
+            }
+        });
+    });
+}
+function setCryptoFactorySwapContracts(factorySwapAddresses) {
+    var _this = this;
+    factorySwapAddresses.forEach(function (addr) {
+        _this.setContract(addr, tricryptoFactorySwapABI);
+    });
+}
+function setCryptoFactoryTokenContracts(factoryTokenAddresses) {
+    var _this = this;
+    factoryTokenAddresses.forEach(function (addr) {
+        _this.setContract(addr, ERC20ABI);
+    });
+}
+function setCryptoFactoryGaugeContracts(factoryGaugeAddresses) {
+    var _this = this;
+    factoryGaugeAddresses.filter(function (addr) { return addr !== curve.constants.ZERO_ADDRESS; }).forEach(function (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];
+        if (addr in this.contracts)
+            continue;
+        this.setContract(addr, ERC20ABI);
+    }
+}
+function getCryptoFactoryUnderlyingCoinAddresses(coinAddresses) {
+    var _this = this;
+    return __spreadArray([], coinAddresses.map(function (coins) { return coins.map(function (c) { return c === _this.constants.NATIVE_TOKEN.wrappedAddress ? _this.constants.NATIVE_TOKEN.address : c; }); }), true);
+}
+function getExistingCoinAddressNameDict() {
+    var dict = {};
+    var _loop_1 = function (poolData) {
+        poolData.wrapped_coin_addresses.forEach(function (addr, i) {
+            if (!(addr.toLowerCase() in dict)) {
+                dict[addr.toLowerCase()] = poolData.wrapped_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);
+    }
+    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(curve.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;
+                    coinAddrDecimalsDict[this.constants.NATIVE_TOKEN.address] = 18;
+                    return [2 /*return*/, [tokenSymbols, tokenNames, coinAddrNamesDict, coinAddrDecimalsDict]];
+            }
+        });
+    });
+}
+export function getTricryptoFactoryPoolData(fromIdx, swapAddress) {
+    if (fromIdx === void 0) { fromIdx = 0; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, poolIds, swapAddresses, _b, _c, gaugeAddresses, coinAddresses, underlyingCoinAddresses, existingCoinAddressNameDict, _e, poolSymbols, poolNames, coinAddressNameDict, coinAddressDecimalsDict, TRICRYPTO_FACTORY_POOLS_DATA, i;
+        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(), gaugeAddresses = _c[0], coinAddresses = _c[1];
+                    setCryptoFactorySwapContracts.call(this, swapAddresses);
+                    setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
+                    setCryptoFactoryCoinsContracts.call(this, coinAddresses);
+                    underlyingCoinAddresses = getCryptoFactoryUnderlyingCoinAddresses.call(this, coinAddresses);
+                    existingCoinAddressNameDict = getExistingCoinAddressNameDict.call(this);
+                    return [4 /*yield*/, getCoinsData.call(this, swapAddresses, coinAddresses, existingCoinAddressNameDict, this.constants.DECIMALS)];
+                case 6:
+                    _e = _f.sent(), poolSymbols = _e[0], poolNames = _e[1], coinAddressNameDict = _e[2], coinAddressDecimalsDict = _e[3];
+                    TRICRYPTO_FACTORY_POOLS_DATA = {};
+                    for (i = 0; i < poolIds.length; i++) {
+                        TRICRYPTO_FACTORY_POOLS_DATA[poolIds[i]] = {
+                            name: poolNames[i],
+                            full_name: poolNames[i],
+                            symbol: poolSymbols[i],
+                            reference_asset: "CRYPTO",
+                            swap_address: swapAddresses[i],
+                            token_address: swapAddresses[i],
+                            gauge_address: gaugeAddresses[i],
+                            is_crypto: true,
+                            is_plain: underlyingCoinAddresses[i].toString() === coinAddresses[i].toString(),
+                            is_factory: true,
+                            underlying_coins: __spreadArray([], underlyingCoinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
+                            wrapped_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
+                            underlying_coin_addresses: underlyingCoinAddresses[i],
+                            wrapped_coin_addresses: coinAddresses[i],
+                            underlying_decimals: __spreadArray([], underlyingCoinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
+                            wrapped_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
+                            swap_abi: tricryptoFactorySwapABI,
+                            gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+                        };
+                    }
+                    return [2 /*return*/, TRICRYPTO_FACTORY_POOLS_DATA];
+            }
+        });
+    });
+}

package/lib/index.d.ts

@@ -81,14 +81,27 @@ declare const curve: {
         fetchPools: (useApi?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
-        deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: string | number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
+        deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
-        getDeployed: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
-            deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: string | number, initialPrice: string | number) => Promise<number>;
+            deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: number, initialPrice: string | number) => Promise<number>;
+            deployGauge: (poolAddress: string) => Promise<number>;
+        };
+    };
+    tricryptoFactory: {
+        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchNewPools: () => Promise<string[]>;
+        getPoolList: () => string[];
+        deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, emaTime: number, initialPrices: (string | number)[]) => Promise<ethers.ContractTransactionResponse>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
+        estimateGas: {
+            deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, emaTime: number, initialPrices: (string | number)[]) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
         };
     };

package/lib/index.js

@@ -40,7 +40,7 @@ import { getBestRouteAndOutput, swapExpected, swapPriceImpact, swapIsApproved, s
 import { curve as _curve } from "./curve.js";
 import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, lastBlockhash, checkBlockhash, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, } from "./boosting.js";
 import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, getUsdRate, getTVL, getCoinsData, getVolume, } from "./utils.js";
-import { deployStablePlainPool, deployStablePlainPoolEstimateGas, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, deployCryptoPool, deployCryptoPoolEstimateGas, deployGauge, deployGaugeEstimateGas, getDeployedStablePlainPoolAddress, getDeployedStableMetaPoolAddress, getDeployedCryptoPoolAddress, getDeployedGaugeAddress, } from './factory/deploy.js';
+import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, } from './factory/deploy.js';
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -91,7 +91,7 @@ var curve = {
         setOracle: setOracle,
         deployMetaPool: deployStableMetaPool,
         deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, deployGauge(poolAddress, false)];
+            return [2 /*return*/, deployGauge(poolAddress, _curve.constants.ALIASES.factory)];
         }); }); },
         getDeployedPlainPoolAddress: getDeployedStablePlainPoolAddress,
         getDeployedMetaPoolAddress: getDeployedStableMetaPoolAddress,
@@ -102,7 +102,7 @@ var curve = {
             setOracle: setOracleEstimateGas,
             deployMetaPool: deployStableMetaPoolEstimateGas,
             deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, deployGaugeEstimateGas(poolAddress, false)];
+                return [2 /*return*/, deployGaugeEstimateGas(poolAddress, _curve.constants.ALIASES.factory)];
             }); }); },
         },
     },
@@ -116,16 +116,33 @@ var curve = {
         getPoolList: _curve.getCryptoFactoryPoolList,
         deployPool: deployCryptoPool,
         deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, deployGauge(poolAddress, true)];
+            return [2 /*return*/, deployGauge(poolAddress, _curve.constants.ALIASES.crypto_factory)];
         }); }); },
-        getDeployed: getDeployedStablePlainPoolAddress,
         getDeployedPoolAddress: getDeployedCryptoPoolAddress,
         getDeployedGaugeAddress: getDeployedGaugeAddress,
         fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedCryptoFactoryPool,
         estimateGas: {
             deployPool: deployCryptoPoolEstimateGas,
             deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, deployGaugeEstimateGas(poolAddress, true)];
+                return [2 /*return*/, deployGaugeEstimateGas(poolAddress, _curve.constants.ALIASES.crypto_factory)];
+            }); }); },
+        },
+    },
+    tricryptoFactory: {
+        fetchPools: _curve.fetchTricryptoFactoryPools,
+        fetchNewPools: _curve.fetchNewTricryptoFactoryPools,
+        getPoolList: _curve.getTricryptoFactoryPoolList,
+        deployPool: deployTricryptoPool,
+        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, deployGauge(poolAddress, _curve.constants.ALIASES.tricrypto_factory)];
+        }); }); },
+        getDeployedPoolAddress: getDeployedTricryptoPoolAddress,
+        getDeployedGaugeAddress: getDeployedGaugeAddress,
+        fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedTricryptoFactoryPool,
+        estimateGas: {
+            deployPool: deployTricryptoPoolEstimateGas,
+            deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, deployGaugeEstimateGas(poolAddress, _curve.constants.ALIASES.tricrypto_factory)];
             }); }); },
         },
     },

package/lib/interfaces.d.ts

@@ -76,7 +76,10 @@ export interface ICurve {
         ALIASES: IDict<string>;
         POOLS_DATA: IDict<IPoolData>;
         FACTORY_POOLS_DATA: IDict<IPoolData>;
+        CRVUSD_FACTORY_POOLS_DATA: IDict<IPoolData>;
         CRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+        TRICRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+        LLAMMAS_DATA: IDict<IPoolData>;
         COINS: IDict<string>;
         DECIMALS: IDict<number>;
         GAUGES: string[];

package/lib/pools/PoolTemplate.js

@@ -78,7 +78,7 @@ var PoolTemplate = /** @class */ (function () {
                         calls = [
                             multicallContract.get_virtual_price(),
                             multicallContract.fee(),
-                            multicallContract.admin_fee(),
+                            "admin_fee" in multicallContract ? multicallContract.admin_fee() : multicallContract.ADMIN_FEE(),
                             multicallContract.A(),
                             lpMulticallContract.totalSupply(),
                         ];
@@ -464,7 +464,7 @@ var PoolTemplate = /** @class */ (function () {
                                 if (!BN(a).eq(BN(seedAmounts_1[i])))
                                     throw Error("Amounts must be = ".concat(seedAmounts_1));
                             });
-                            return [2 /*return*/, parseUnits(Math.sqrt(Number(amounts[0]) * Number(amounts[1])))];
+                            return [2 /*return*/, parseUnits(Math.sqrt(amounts.map(Number).reduce(function (a, b) { return a * b; })))];
                         case 6:
                             _c.trys.push([6, 11, , 13]);
                             contract = curve.contracts[curve.constants.ALIASES.stable_calc].contract;
@@ -1082,7 +1082,7 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
-        var poolData = __assign(__assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA), curve.constants.LLAMMAS_DATA)[id];
+        var poolData = curve.getPoolsData()[id];
         this.id = id;
         this.name = poolData.name;
         this.fullName = poolData.full_name;
@@ -1283,23 +1283,36 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.cryptoSeedAmounts = function (amount1) {
         return __awaiter(this, void 0, void 0, function () {
-            var decimals, amount1BN, priceScaleBN, _c;
+            var decimals, amount1BN, priceScaleBN, _c, priceScaleBN;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         if (!this.isCrypto)
                             throw Error("cryptoSeedAmounts method doesn't exist for stable pools");
                         decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
-                        if (decimals.length > 2)
-                            throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 2");
                         amount1BN = BN(amount1);
                         if (amount1BN.lte(0))
                             throw Error("Initial deposit amounts must be > 0");
+                        if (!(decimals.length === 2)) return [3 /*break*/, 2];
                         _c = toBN;
                         return [4 /*yield*/, curve.contracts[this.address].contract.price_scale(curve.constantOptions)];
                     case 1:
                         priceScaleBN = _c.apply(void 0, [_d.sent()]);
                         return [2 /*return*/, [_cutZeros(amount1BN.toFixed(decimals[0])), _cutZeros(amount1BN.div(priceScaleBN).toFixed(decimals[1]))]];
+                    case 2:
+                        if (!(decimals.length === 3)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, curve.multicallProvider.all([
+                                curve.contracts[this.address].multicallContract.price_scale(0),
+                                curve.contracts[this.address].multicallContract.price_scale(1),
+                            ])];
+                    case 3:
+                        priceScaleBN = (_d.sent()).map(function (_p) { return toBN(_p); });
+                        return [2 /*return*/, [
+                                _cutZeros(amount1BN.toFixed(decimals[0])),
+                                _cutZeros(amount1BN.div(priceScaleBN[0]).toFixed(decimals[1])),
+                                _cutZeros(amount1BN.div(priceScaleBN[1]).toFixed(decimals[2])),
+                            ]];
+                    case 4: throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 3");
                 }
             });
         });

package/lib/router.js

@@ -136,7 +136,7 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
             case 0:
                 inputCoinAddress = inputCoinAddress.toLowerCase();
                 outputCoinAddress = outputCoinAddress.toLowerCase();
-                ALL_POOLS = Object.entries(__assign(__assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA), curve.constants.LLAMMAS_DATA));
+                ALL_POOLS = Object.entries(curve.getPoolsData());
                 return [4 /*yield*/, _getAmplificationCoefficientsFromApi()];
             case 1:
                 amplificationCoefficientDict = _s.sent();

package/lib/utils.js

@@ -391,14 +391,14 @@ export var ensureAllowance = function (coins, amounts, spender, isMax) {
     });
 };
 export var getPoolIdBySwapAddress = function (swapAddress) {
-    var poolsData = __assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA);
+    var poolsData = curve.getPoolsData();
     return Object.entries(poolsData).filter(function (_a) {
         var _ = _a[0], poolData = _a[1];
         return poolData.swap_address.toLowerCase() === swapAddress.toLowerCase();
     })[0][0];
 };
 var _getTokenAddressBySwapAddress = function (swapAddress) {
-    var poolsData = __assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA);
+    var poolsData = curve.getPoolsData();
     var res = Object.entries(poolsData).filter(function (_a) {
         var _ = _a[0], poolData = _a[1];
         return poolData.swap_address.toLowerCase() === swapAddress.toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/api",
-  "version": "2.38.0",
+  "version": "2.40.0",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",