@curvefi/api 2.39.0 → 2.40.1

package/README.md

@@ -1573,4 +1573,69 @@ import curve from "@curvefi/api";
     const underlyingBalances = await pool.stats.underlyingBalances();
     // [ '30.0', '0.02' ]
 })()
+```
+
+### Deploy tricrypto pool
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0 });
+
+    const coins = [
+        "0xC581b735A1688071A1746c968e0798D642EDE491", // EURT
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
+    ];
+
+    // Deploy pool
+    
+    const deployPoolTx = await curve.tricryptoFactory.deployPool(
+        "Test tricrypto pool",
+        "TTP",
+        coins,
+        400000,
+        0.0000725,
+        0.25,
+        0.45,
+        0.000002,
+        0.00023,
+        0.000146,
+        600,
+        [1700, 27000]
+    );
+    // ContractTransactionResponse {
+    //     provider: JsonRpcProvider {},
+    //     blockNumber: 17393463,
+    //     blockHash: '0x7f393493d7eb30b39aeef3118b51925426946eb83b72b18946f0da8c7bec40a0',
+    //     ...
+    // }
+    const poolAddress = await curve.tricryptoFactory.getDeployedPoolAddress(deployPoolTx);
+    // 0x2889302a794dA87fBF1D6Db415C1492194663D13
+    
+    // Deploy gauge
+    
+    const deployGaugeTx = await curve.tricryptoFactory.deployGauge(poolAddress);
+    // ContractTransactionResponse {
+    //     provider: JsonRpcProvider {},
+    //     blockNumber: 17393463,
+    //     blockHash: '0x7f393493d7eb30b39aeef3118b51925426946eb83b72b18946f0da8c7bec40a0',
+    //     ...
+    // }
+    const gaugeAddress = await curve.factory.getDeployedGaugeAddress(deployGaugeTx);
+    // 0x60d3d7ebbc44dc810a743703184f062d00e6db7e
+
+    // Deposit & Stake
+
+    const poolId = await curve.tricryptoFactory.fetchRecentlyDeployedPool(poolAddress);
+    // factory-tricrypto-2
+    const pool = curve.getPool(poolId);
+
+    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    // [ '30', '0.017647058823529412', '0.00111111' ]
+    await pool.depositAndStake(amounts);
+    const underlyingBalances = await pool.stats.underlyingBalances();
+    // [ '30', '0.017647058823529412', '0.00111111' ]
+})()
 ```

package/lib/external-api.d.ts

@@ -1,6 +1,6 @@
 import memoize from "memoizee";
-import { IExtendedPoolDataFromApi, ISubgraphPoolData, IDict, INetworkName } from "./interfaces";
-export declare const _getPoolsFromApi: ((network: INetworkName, poolType: "main" | "crypto" | "factory" | "factory-crvusd" | "factory-crypto" | "factory-tricrypto") => Promise<IExtendedPoolDataFromApi>) & memoize.Memoized<(network: INetworkName, poolType: "main" | "crypto" | "factory" | "factory-crvusd" | "factory-crypto" | "factory-tricrypto") => Promise<IExtendedPoolDataFromApi>>;
+import { IExtendedPoolDataFromApi, ISubgraphPoolData, IDict, INetworkName, IPoolType } from "./interfaces";
+export declare const _getPoolsFromApi: ((network: INetworkName, poolType: IPoolType) => Promise<IExtendedPoolDataFromApi>) & memoize.Memoized<(network: INetworkName, poolType: IPoolType) => Promise<IExtendedPoolDataFromApi>>;
 export declare const _getAllPoolsFromApi: (network: INetworkName) => Promise<IExtendedPoolDataFromApi[]>;
 export declare const _getSubgraphData: ((network: INetworkName) => Promise<{
     poolsData: ISubgraphPoolData[];

package/lib/external-api.js

@@ -62,6 +62,7 @@ export var _getAllPoolsFromApi = function (network) { return __awaiter(void 0, v
                     _getPoolsFromApi(network, "factory"),
                     _getPoolsFromApi(network, "factory-crvusd"),
                     _getPoolsFromApi(network, "factory-crypto"),
+                    _getPoolsFromApi(network, "factory-tricrypto"),
                 ])];
             case 1: return [2 /*return*/, _a.sent()];
         }

package/lib/factory/deploy.d.ts

@@ -8,9 +8,12 @@ export declare const setOracle: (poolAddress: string, oracleAddress?: string, me
 export declare const deployStableMetaPoolEstimateGas: (basePool: string, name: string, symbol: string, coin: string, A: number | string, fee: number | string, implementationIdx: 0 | 1) => Promise<number>;
 export declare const deployStableMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number | string, fee: number | string, implementationIdx: 0 | 1) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedStableMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
-export declare const deployCryptoPoolEstimateGas: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, maHalfTime: number | string, initialPrice: number | string) => Promise<number>;
-export declare const deployCryptoPool: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, maHalfTime: number | string, initialPrice: number | string) => Promise<ethers.ContractTransactionResponse>;
+export declare const deployCryptoPoolEstimateGas: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, maHalfTime: number, initialPrice: number | string) => Promise<number>;
+export declare const deployCryptoPool: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, maHalfTime: number, initialPrice: number | string) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedCryptoPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
-export declare const deployGaugeEstimateGas: (pool: string, isCrypto: boolean) => Promise<number>;
-export declare const deployGauge: (pool: string, isCrypto: boolean) => Promise<ethers.ContractTransactionResponse>;
+export declare const deployTricryptoPoolEstimateGas: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, emaTime: number, initialPrices: (number | string)[]) => Promise<number>;
+export declare const deployTricryptoPool: (name: string, symbol: string, coins: string[], A: number | string, gamma: number | string, midFee: number | string, outFee: number | string, allowedExtraProfit: number | string, feeGamma: number | string, adjustmentStep: number | string, emaTime: number, initialPrices: (number | string)[]) => Promise<ethers.ContractTransactionResponse>;
+export declare const getDeployedTricryptoPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+export declare const deployGaugeEstimateGas: (pool: string, factory: string) => Promise<number>;
+export declare const deployGauge: (pool: string, factory: string) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;

package/lib/factory/deploy.js

@@ -103,7 +103,7 @@ oracleAddress, methodName, estimateGas) { return __awaiter(void 0, void 0, void
                 contract = curve.contracts[contractAddress].contract;
                 args = [name, symbol, _coins, _A, _fee, assetType, implementationIdx];
                 if (useProxy || setOracle)
-                    args.push(curve.parseUnits((emaTime / Math.log(2)).toFixed(0), 0));
+                    args.push(parseUnits(Math.floor(emaTime / Math.log(2)), 0));
                 if (setOracle) {
                     methodId = methodName === "0x00000000" ? "0x00000000" : ethers.id(methodName).substring(0, 10);
                     args.push(methodId, oracleAddress);
@@ -301,7 +301,7 @@ initialPrice, estimateGas) { return __awaiter(void 0, void 0, void 0, function (
                     throw Error("Max symbol length = 10");
                 if (coins.length !== 2)
                     throw Error("Invalid number of coins. Must be 2");
-                if (coins[1] === coins[2])
+                if (coins[0] === coins[1])
                     throw Error("Coins must be different");
                 if (BN(A).lt(4000))
                     throw Error("A must be >= 4000. Passed A = ".concat(A));
@@ -402,14 +402,137 @@ export var getDeployedCryptoPoolAddress = function (tx) { return __awaiter(void
         }
     });
 }); };
+// ------- TRICRYPTO POOLS -------
+var _deployTricryptoPool = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, emaTime, // Seconds
+initialPrices, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var _A, _gamma, _midFee, _outFee, _allowedExtraProfit, _feeGamma, _adjustmentStep, _emaTime, _initialPrices, contract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (name.length > 64)
+                    throw Error("Max name length = 64");
+                if (symbol.length > 32)
+                    throw Error("Max symbol length = 32");
+                if (coins.length !== 3)
+                    throw Error("Invalid number of coins. Must be 3");
+                if (coins[0] === coins[1] || coins[1] === coins[2] || coins[0] === coins[2])
+                    throw Error("Coins must be different");
+                if (BN(A).lt(2700))
+                    throw Error("A must be >= 2700. Passed A = ".concat(A));
+                if (BN(A).gt(27 * (Math.pow(10, 7))))
+                    throw Error("A must be <= 27 * 10 ** 7. Passed A = ".concat(A));
+                if (BN(gamma).lt(1e-8))
+                    throw Error("gamma must be >= 1e-8. Passed gamma = ".concat(gamma));
+                if (BN(gamma).gt(0.05))
+                    throw Error("gamma must be <= 0.05. Passed gamma = ".concat(gamma));
+                if (BN(midFee).lt(0))
+                    throw Error("midFee must be >= 0. Passed midFee = ".concat(midFee));
+                if (BN(midFee).gt(100))
+                    throw Error("midFee must be <= 100. Passed midFee = ".concat(midFee));
+                if (BN(outFee).lt(BN(midFee)))
+                    throw Error("outFee must be >= midFee. Passed outFee = ".concat(outFee, " < midFee = ").concat(midFee));
+                if (BN(outFee).gt(100))
+                    throw Error("outFee must be <= 100. Passed outFee = ".concat(outFee));
+                if (BN(allowedExtraProfit).lt(0))
+                    throw Error("allowedExtraProfit must be >= 0. Passed allowedExtraProfit = ".concat(allowedExtraProfit));
+                if (BN(allowedExtraProfit).gt(1))
+                    throw Error("allowedExtraProfit must be <= 1. Passed allowedExtraProfit = ".concat(allowedExtraProfit));
+                if (BN(feeGamma).lt(0))
+                    throw Error("feeGamma must be >= 0. Passed feeGamma = ".concat(feeGamma));
+                if (BN(feeGamma).gt(1))
+                    throw Error("feeGamma must be <= 1. Passed feeGamma = ".concat(feeGamma));
+                if (BN(adjustmentStep).lt(0))
+                    throw Error("adjustmentStep must be >= 0. Passed adjustmentStep=".concat(adjustmentStep));
+                if (BN(adjustmentStep).gt(1))
+                    throw Error("adjustmentStep must be <= 1. Passed adjustmentStep=".concat(adjustmentStep));
+                if (BN(emaTime).lt(60))
+                    throw Error("maHalfTime must be >= 60. Passed maHalfTime=".concat(emaTime));
+                if (BN(emaTime).gt(604800))
+                    throw Error("maHalfTime must be <= 604800. Passed maHalfTime=".concat(emaTime));
+                if (initialPrices.length !== 2)
+                    throw Error("Invalid number of initial prices. Must be 2");
+                if (BN(initialPrices[0]).lt(1e-12))
+                    throw Error("initialPrices[0] must be >= 1e-12. Passed initialPrices[0]=".concat(initialPrices[0]));
+                if (BN(initialPrices[0]).gt(1e12))
+                    throw Error("initialPrices[0] must be <= 1e12. Passed initialPrices[0]=".concat(initialPrices[0]));
+                if (BN(initialPrices[1]).lt(1e-12))
+                    throw Error("initialPrices[1] must be >= 1e-12. Passed initialPrices[1]=".concat(initialPrices[1]));
+                if (BN(initialPrices[1]).gt(1e12))
+                    throw Error("initialPrices[1] must be <= 1e12. Passed initialPrices[1]=".concat(initialPrices[1]));
+                _A = parseUnits(A, 0);
+                _gamma = parseUnits(gamma);
+                _midFee = parseUnits(midFee, 8);
+                _outFee = parseUnits(outFee, 8);
+                _allowedExtraProfit = parseUnits(allowedExtraProfit);
+                _feeGamma = parseUnits(feeGamma);
+                _adjustmentStep = parseUnits(adjustmentStep);
+                _emaTime = parseUnits(Math.floor(emaTime / Math.log(2)), 0);
+                _initialPrices = [parseUnits(initialPrices[0]), parseUnits(initialPrices[1])];
+                contract = curve.contracts[curve.constants.ALIASES.tricrypto_factory].contract;
+                return [4 /*yield*/, contract.deploy_pool.estimateGas(name, symbol, coins, curve.constants.NATIVE_TOKEN.wrappedAddress, 0, _A, _gamma, _midFee, _outFee, _feeGamma, _allowedExtraProfit, _adjustmentStep, _emaTime, _initialPrices, curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, Number(gas)];
+                gasLimit = mulBy1_3(gas);
+                return [4 /*yield*/, curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_pool(name, symbol, coins, curve.constants.NATIVE_TOKEN.wrappedAddress, 0, _A, _gamma, _midFee, _outFee, _feeGamma, _allowedExtraProfit, _adjustmentStep, _emaTime, _initialPrices, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var deployTricryptoPoolEstimateGas = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, emaTime, // Seconds
+initialPrices) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployTricryptoPool(name, symbol, coins, A, gamma, midFee, outFee, allowedExtraProfit, feeGamma, adjustmentStep, emaTime, initialPrices, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var deployTricryptoPool = function (name, symbol, coins, A, gamma, midFee, // %
+outFee, // %
+allowedExtraProfit, feeGamma, adjustmentStep, emaTime, // Seconds
+initialPrices) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployTricryptoPool(name, symbol, coins, A, gamma, midFee, outFee, allowedExtraProfit, feeGamma, adjustmentStep, emaTime, initialPrices, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var getDeployedTricryptoPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo, i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                if (!txInfo)
+                    throw Error("Can't get tx info");
+                for (i = txInfo.logs.length - 1; i > -1; i--) {
+                    if ("args" in txInfo.logs[i]) {
+                        // @ts-ignore
+                        return [2 /*return*/, txInfo.logs[i].args[0]];
+                    }
+                }
+                throw Error("Can't get deployed tricrypto pool address");
+        }
+    });
+}); };
 // ------- GAUGE -------
-var _deployGauge = function (pool, isCrypto, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
-    var contractAddress, contract, gas, gasLimit;
+var _deployGauge = function (pool, factory, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var contract, gas, gasLimit;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                contractAddress = isCrypto ? curve.constants.ALIASES.crypto_factory : curve.constants.ALIASES.factory;
-                contract = curve.contracts[contractAddress].contract;
+                contract = curve.contracts[factory].contract;
                 return [4 /*yield*/, contract.deploy_gauge.estimateGas(pool, curve.constantOptions)];
             case 1:
                 gas = _a.sent();
@@ -424,15 +547,15 @@ var _deployGauge = function (pool, isCrypto, estimateGas) { return __awaiter(voi
         }
     });
 }); };
-export var deployGaugeEstimateGas = function (pool, isCrypto) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+export var deployGaugeEstimateGas = function (pool, factory) { 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 0: return [4 /*yield*/, _deployGauge(pool, factory, true)];
         case 1: return [2 /*return*/, _a.sent()];
     }
 }); }); };
-export var deployGauge = function (pool, isCrypto) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+export var deployGauge = function (pool, factory) { 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 0: return [4 /*yield*/, _deployGauge(pool, factory, false)];
         case 1: return [2 /*return*/, _a.sent()];
     }
 }); }); };

package/lib/index.d.ts

@@ -81,13 +81,13 @@ 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>;
         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>;
         };
     };
@@ -95,7 +95,15 @@ 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, 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>;
+        };
     };
     estimateGas: {
         ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string, isMax?: boolean) => 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,7 +116,7 @@ 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)];
         }); }); },
         getDeployedPoolAddress: getDeployedCryptoPoolAddress,
         getDeployedGaugeAddress: getDeployedGaugeAddress,
@@ -124,7 +124,7 @@ var curve = {
         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)];
             }); }); },
         },
     },
@@ -132,15 +132,19 @@ var curve = {
         fetchPools: _curve.fetchTricryptoFactoryPools,
         fetchNewPools: _curve.fetchNewTricryptoFactoryPools,
         getPoolList: _curve.getTricryptoFactoryPoolList,
-        // deployPool: deployCryptoPool,
-        // deployGauge: async (poolAddress: string): Promise<ethers.ContractTransactionResponse> => deployGauge(poolAddress, true),
-        // getDeployedPoolAddress: getDeployedCryptoPoolAddress,
-        // getDeployedGaugeAddress: getDeployedGaugeAddress,
+        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: deployCryptoPoolEstimateGas,
-        //     deployGauge: async (poolAddress: string): Promise<number> => deployGaugeEstimateGas(poolAddress, true),
-        // },
+        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)];
+            }); }); },
+        },
     },
     estimateGas: {
         ensureAllowance: ensureAllowanceEstimateGas,

package/lib/interfaces.d.ts

@@ -5,6 +5,7 @@ export interface IDict<T> {
 }
 export type INetworkName = "ethereum" | "optimism" | "xdai" | "polygon" | "fantom" | "moonbeam" | "kava" | "arbitrum" | "celo" | "avalanche" | "aurora";
 export type IChainId = 1 | 10 | 100 | 137 | 250 | 1284 | 2222 | 42161 | 42220 | 43114 | 1313161554;
+export type IPoolType = "main" | "crypto" | "factory" | "factory-crvusd" | "factory-crypto" | "factory-tricrypto";
 export type REFERENCE_ASSET = 'USD' | 'EUR' | 'BTC' | 'ETH' | 'LINK' | 'CRYPTO' | 'OTHER';
 export interface IPoolData {
     name: 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(),
                         ];
@@ -157,7 +157,7 @@ var PoolTemplate = /** @class */ (function () {
         this.statsTotalLiquidity = function (useApi) {
             if (useApi === void 0) { useApi = true; }
             return __awaiter(_this, void 0, void 0, function () {
-                var stablecoinContract, collateralContract, ammContract, _c, _balance_x, _fee_x, _balance_y, _fee_y, collateralRate, stablecoinTvlBN, collateralTvlBN, network, poolType, poolsData, totalLiquidity_1, balances, promises, _i, _d, addr, prices, totalLiquidity;
+                var stablecoinContract, collateralContract, ammContract, _c, _balance_x, _fee_x, _balance_y, _fee_y, collateralRate, stablecoinTvlBN, collateralTvlBN, network, poolType, factoryType, poolsData, totalLiquidity_1, balances, promises, _i, _d, addr, prices, totalLiquidity;
                 var _this = this;
                 return __generator(this, function (_e) {
                     switch (_e.label) {
@@ -184,12 +184,12 @@ var PoolTemplate = /** @class */ (function () {
                             if (!useApi) return [3 /*break*/, 5];
                             network = curve.constants.NETWORK_NAME;
                             poolType = this.isCrypto ? "crypto" : "main";
-                            if (this.id.startsWith("factory-v2-"))
+                            if (this.id.startsWith("factory")) {
                                 poolType = "factory";
-                            if (this.id.startsWith("factory-crvusd-"))
-                                poolType = "factory-crvusd";
-                            if (this.id.startsWith("factory-crypto-"))
-                                poolType = "factory-crypto";
+                                factoryType = this.id.split("-")[1];
+                                if (factoryType)
+                                    poolType += "-" + factoryType;
+                            }
                             return [4 /*yield*/, _getPoolsFromApi(network, poolType)];
                         case 4:
                             poolsData = (_e.sent()).poolData;
@@ -376,7 +376,7 @@ var PoolTemplate = /** @class */ (function () {
                             if (this.gauge === curve.constants.ZERO_ADDRESS)
                                 return [2 /*return*/, []];
                             isDisabledChain = [1313161554].includes(curve.chainId);
-                            if (!(curve.chainId === 1 || (useApi && !isDisabledChain))) return [3 /*break*/, 2];
+                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
                             return [4 /*yield*/, _getRewardsFromApi()];
                         case 1:
                             rewards = _d.sent();
@@ -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;
@@ -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/package.json

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