@curvefi/api 2.51.3 → 2.52.0

package/README.md

@@ -1590,6 +1590,65 @@ import curve from "@curvefi/api";
 })()
 ```
 
+### Deploy stable-ng plain pool
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0 });
+
+    const coins = [
+        "0xae7ab96520de3a18e5e111b5eaab095312d7fe84", // stETH
+        "0xac3e018457b222d93114458476f3e3416abbe38f", // sfrxETH
+    ];
+
+    //0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+    const assetTypes = [2, 1] as Array<0 | 1 | 2 | 3>;
+
+    const oracleAddresses = [
+        '0x0000000000000000000000000000000000000000',
+        '0xac3e018457b222d93114458476f3e3416abbe38f',
+    ];
+
+    const methodNames = [
+        '',
+        'pricePerShare',
+    ];
+    // OR 
+    //const methodNames = [
+    //  '0x00000000',
+    //  'pricePerShare',
+    //];
+    
+    
+    // Deploy pool
+    
+    const deployPoolTx = await curve.stableNgFactory.deployPlainPool('Test pool', 'test', coins, 5, 0.05, 5, assetTypes, 0, 600, oracleAddresses, methodNames);
+    // {
+    //     accessList:null
+    //     blockHash: "0x981c86a28d1e4a675dae3e14868d62683c02c7906082ba78f5304a45cfd55c38"
+    //     blockNumber: 18628729
+    //     chainId: 1n
+    //     data: "0x5bcd3d83000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000004c4b40000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000002580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000095465737420706f6f6c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000474657374000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000ae7ab96520de3a18e5e111b5eaab095312d7fe84000000000000000000000000ac3e018457b222d93114458476f3e3416abbe38f00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d8a452bc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ac3e018457b222d93114458476f3e3416abbe38f"
+    //     from: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+    //     gasLimit: 7046085n
+    //     gasPrice: 0n
+    //     hash: "0xcbd866d6c4c6294b33d5797bdbf5666aad99a4f7fd461f472aeb95121929242b"
+    //     index: undefined
+    //     maxFeePerGas: null
+    //     maxPriorityFeePerGas: null
+    //     nonce: 565
+    //     to: "0x6A8cbed756804B16E05E741eDaBd5cB544AE21bf"
+    //     type: 0
+    //     value: 0n
+    // }
+    
+    const poolAddress = await curve.stableNgFactory.getDeployedPlainPoolAddress(deployPoolTx);
+    // 0x0816bc9ced716008c88bb8940c297e9c9167755e
+})()
+```
+
 ### Deploy stable meta pool
 
 ```ts
@@ -1650,6 +1709,45 @@ import curve from "@curvefi/api";
 })()
 ```
 
+### Deploy stable-ng meta pool
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0 });
+
+    const basePool = "0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7";  // 3pool address
+    const coin = "0xac3e018457b222d93114458476f3e3416abbe38f"; // sfrxETH
+    const oracleAddress = '0xac3e018457b222d93114458476f3e3416abbe38f';
+    const methodName = 'pricePerShare';
+
+    // Deploy pool
+
+    const deployPoolTx = curve.stableNgFactory.deployMetaPool(basePool, 'Test pool', 'test', coin, 5, 0.05, 5, 600, 1, 0, methodName, oracleAddress);
+    // OR const deployPoolTx = curve.stableNgFactory.deployMetaPool(basePool, 'Test pool', 'test',coin, 5, 0.05, 5, 600, 1);
+    // {
+    //     accessList: null
+    //     blockHash: "0xff6f39ee2dae6940d8a061925bd67d9e1e85947f85a7d65c1eef81abdbba023d"
+    //     blockNumber: 18628730
+    //     chainId: 1n
+    //     data: "0xdf8c5d73000000000000000000000000bebc44782c7db0a1a60cb6fe97d0b483032ff1c7000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000ac3e018457b222d93114458476f3e3416abbe38f000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000004c4b400000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000025800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d8a452bc00000000000000000000000000000000000000000000000000000000000000000000000000000000ac3e018457b222d93114458476f3e3416abbe38f00000000000000000000000000000000000000000000000000000000000000095465737420706f6f6c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047465737400000000000000000000000000000000000000000000000000000000"
+    //     from: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+    //     gasLimit: 7215295n
+    //     gasPrice: 0n
+    //     hash: "0xdada197e9264ea5697216e68eaae8304f45d490a10e230023bbb32568df622f5"
+    //     index: undefined
+    //     maxFeePerGas: null
+    //     maxPriorityFeePerGas: null
+    //     nonce: 566
+    //     to: "0x6A8cbed756804B16E05E741eDaBd5cB544AE21bf"
+    //     type: 0
+    //     value: 0n
+    // }
+    const poolAddress = await curve.factory.getDeployedMetaPoolAddress(deployPoolTx);
+    // 0xd3797c5da2cf2db453b995fb8f7a9199f4106ad9
+```
+
 ### Deploy crypto pool
 
 ```ts

package/lib/curve.d.ts

@@ -86,6 +86,7 @@ declare class Curve implements ICurve {
     fetchTricryptoFactoryPools: (useApi?: boolean) => Promise<void>;
     fetchStableNgFactoryPools: (useApi?: boolean) => Promise<void>;
     fetchNewFactoryPools: () => Promise<string[]>;
+    fetchNewStableNgFactoryPools: () => Promise<string[]>;
     fetchNewCryptoFactoryPools: () => Promise<string[]>;
     fetchNewTricryptoFactoryPools: () => Promise<string[]>;
     fetchRecentlyDeployedFactoryPool: (poolAddress: string) => Promise<string>;

package/lib/curve.js

@@ -630,6 +630,23 @@ var Curve = /** @class */ (function () {
                 }
             });
         }); };
+        this.fetchNewStableNgFactoryPools = function () { return __awaiter(_this, void 0, void 0, function () {
+            var currentPoolIds, lastPoolIdx, poolData, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        currentPoolIds = Object.keys(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
+                        lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
+                        _a = lowerCasePoolDataAddresses;
+                        return [4 /*yield*/, getFactoryPoolData.call(this, lastPoolIdx + 1)];
+                    case 1:
+                        poolData = _a.apply(void 0, [_b.sent()]);
+                        this.constants.STABLE_NG_FACTORY_POOLS_DATA = __assign(__assign({}, this.constants.FACTORY_POOLS_DATA), poolData);
+                        this._updateDecimalsAndGauges(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
+                        return [2 /*return*/, Object.keys(poolData)];
+                }
+            });
+        }); };
         this.fetchNewCryptoFactoryPools = function () { return __awaiter(_this, void 0, void 0, function () {
             var currentPoolIds, lastPoolIdx, poolData, _a;
             return __generator(this, function (_b) {

package/lib/factory/deploy.d.ts

@@ -1,12 +1,16 @@
 import { ethers } from "ethers";
 export declare const deployStablePlainPoolEstimateGas: (name: string, symbol: string, coins: string[], A: number | string, fee: number | string, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3 | 4 | 5, emaTime?: number, oracleAddress?: string, methodName?: string) => Promise<number>;
 export declare const deployStablePlainPool: (name: string, symbol: string, coins: string[], A: number | string, fee: number | string, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3 | 4 | 5, emaTime?: number, oracleAddress?: string, methodName?: string) => Promise<ethers.ContractTransactionResponse>;
+export declare const deployStableNgPlainPoolEstimateGas: (name: string, symbol: string, coins: string[], A: number | string, fee: number | string, offpegFeeMultiplier: number | string, assetTypes: Array<0 | 1 | 2 | 3>, implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<number>;
+export declare const deployStableNgPlainPool: (name: string, symbol: string, coins: string[], A: number | string, fee: number | string, offpegFeeMultiplier: number | string, assetTypes: Array<0 | 1 | 2 | 3>, implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedStablePlainPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
 export declare const _setOracle: (poolAddress: string, oracleAddress: string, methodName: string, estimateGas: boolean) => Promise<ethers.ContractTransactionResponse | number>;
 export declare const setOracleEstimateGas: (poolAddress: string, oracleAddress?: string, methodName?: string) => Promise<number>;
 export declare const setOracle: (poolAddress: string, oracleAddress?: string, methodName?: string) => Promise<ethers.ContractTransactionResponse>;
 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 deployStableNgMetaPoolEstimateGas: (basePool: string, name: string, symbol: string, coin: string, A: number | string, fee: number | string, offpegFeeMultiplier: number | string, assetType: 0 | 1 | 2 | 3, emaTime: number, implementationIdx: 0, methodName: string, oracleAddress: string) => Promise<number>;
+export declare const deployStableNgMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number | string, fee: number | string, offpegFeeMultiplier: number | string, emaTime: number, implementationIdx: 0, assetType: 0 | 1 | 2 | 3, methodName: string, oracleAddress: string) => 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, 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>;

package/lib/factory/deploy.js

@@ -155,6 +155,108 @@ oracleAddress, methodName) {
         });
     });
 };
+var _deployStableNgPlainPool = function (name, symbol, coins, A, fee, // %
+offpegFeeMultiplier, assetTypes, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+implementationIdx, emaTime, // seconds
+oracleAddresses, methodNames, estimateGas) {
+    if (emaTime === void 0) { emaTime = 600; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _oracleAddresses, _methodNames, _A, _fee, _coins, contractAddress, contract, methodIds, args, gas, gasLimit;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.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 < 1)
+                        throw Error("Invalid number of coins. Must be more than 1");
+                    if (coins.length > 9)
+                        throw Error("Invalid number of coins. Must be less than 9");
+                    if (BN(fee).lt(0.04))
+                        throw Error("fee must be >= 0.04%. Passed fee = ".concat(fee));
+                    if (BN(fee).gt(1))
+                        throw Error("fee must be <= 1%. Passed fee = ".concat(fee));
+                    if (oracleAddresses.length === 0) {
+                        _oracleAddresses = new Array(coins.length).fill(curve.constants.ZERO_ADDRESS);
+                    }
+                    else {
+                        _oracleAddresses = oracleAddresses;
+                    }
+                    if (methodNames.length === 0) {
+                        _methodNames = new Array(coins.length).fill("0x00000000");
+                    }
+                    else {
+                        _methodNames = methodNames;
+                    }
+                    if (coins.length !== assetTypes.length)
+                        throw Error("Invalid length of assetTypes. Must be same coins length");
+                    if (coins.length !== _oracleAddresses.length)
+                        throw Error("Invalid length of oracleAddresses. Must be same coins length");
+                    if (coins.length !== _methodNames.length)
+                        throw Error("Invalid length of methodNames. Must be same coins length");
+                    assetTypes.forEach(function (item, index) {
+                        if (![0, 1, 2, 3].includes(item))
+                            throw Error("Invalid assetType. Must be one of: 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626 for assetTypes[".concat(index, "]"));
+                    });
+                    if (![0].includes(implementationIdx))
+                        throw Error("Invalid implementationIdx. Must be 0");
+                    if (emaTime <= 0)
+                        throw Error("emaTime must be > 0. Passed emaTime = ".concat(emaTime));
+                    _A = parseUnits(A, 0);
+                    _fee = parseUnits(fee, 8);
+                    _coins = coins;
+                    contractAddress = curve.constants.ALIASES.stable_ng_factory;
+                    contract = curve.contracts[contractAddress].contract;
+                    methodIds = [];
+                    _methodNames.forEach(function (item) {
+                        if (item === '0x00000000' || item === '') {
+                            methodIds.push('0x00000000');
+                        }
+                        else {
+                            methodIds.push(ethers.id(item).substring(0, 10));
+                        }
+                    });
+                    args = [name, symbol, _coins, _A, _fee, offpegFeeMultiplier, emaTime, implementationIdx, assetTypes, methodIds, _oracleAddresses];
+                    console.log(args);
+                    return [4 /*yield*/, (_a = contract.deploy_plain_pool).estimateGas.apply(_a, __spreadArray(__spreadArray([], args, false), [curve.constantOptions], false))];
+                case 1:
+                    gas = _b.sent();
+                    if (estimateGas)
+                        return [2 /*return*/, smartNumber(gas)];
+                    gasLimit = mulBy1_3(DIGas(gas));
+                    return [4 /*yield*/, curve.updateFeeData()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, contract.deploy_plain_pool.apply(contract, __spreadArray(__spreadArray([], args, false), [__assign(__assign({}, curve.options), { gasLimit: gasLimit })], false))];
+                case 3: return [2 /*return*/, _b.sent()];
+            }
+        });
+    });
+};
+export var deployStableNgPlainPoolEstimateGas = function (name, symbol, coins, A, fee, // %
+offpegFeeMultiplier, assetTypes, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+implementationIdx, emaTime, // seconds
+oracleAddresses, methodNames) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableNgPlainPool(name, symbol, coins, A, fee, offpegFeeMultiplier, assetTypes, implementationIdx, emaTime, oracleAddresses, methodNames, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var deployStableNgPlainPool = function (name, symbol, coins, A, fee, // %
+offpegFeeMultiplier, assetTypes, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+implementationIdx, emaTime, // seconds
+oracleAddresses, methodNames) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableNgPlainPool(name, symbol, coins, A, fee, offpegFeeMultiplier, assetTypes, implementationIdx, emaTime, oracleAddresses, methodNames, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
 export var getDeployedStablePlainPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
     var txInfo;
     return __generator(this, function (_a) {
@@ -266,6 +368,70 @@ implementationIdx) { return __awaiter(void 0, void 0, void 0, function () {
         }
     });
 }); };
+var _deployStableNgMetaPool = function (basePool, name, symbol, coin, A, fee, // %
+offpegFeeMultiplier, assetType, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+emaTime, // seconds
+implementationIdx, methodName, oracleAddress, estimateGas) {
+    if (emaTime === void 0) { emaTime = 600; }
+    if (implementationIdx === void 0) { implementationIdx = 0; }
+    if (methodName === void 0) { methodName = "0x00000000"; }
+    if (oracleAddress === void 0) { oracleAddress = curve.constants.ZERO_ADDRESS; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _A, _fee, methodId, 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 (BN(fee).lt(0.04))
+                        throw Error("fee must be >= 0.04%. Passed fee = ".concat(fee));
+                    if (BN(fee).gt(1))
+                        throw Error("fee must be <= 1%. Passed fee = ".concat(fee));
+                    if (![0, 1].includes(implementationIdx))
+                        throw Error("Invalid implementationIdx. Must be one 0 or 1");
+                    _A = parseUnits(A, 0);
+                    _fee = parseUnits(fee, 8);
+                    methodId = methodName === "0x00000000" ? "0x00000000" : ethers.id(methodName).substring(0, 10);
+                    contract = curve.contracts[curve.constants.ALIASES.stable_ng_factory].contract;
+                    return [4 /*yield*/, contract.deploy_metapool.estimateGas(basePool, name, symbol, coin, _A, _fee, offpegFeeMultiplier, emaTime, implementationIdx, assetType, methodId, oracleAddress, curve.constantOptions)];
+                case 1:
+                    gas = _a.sent();
+                    if (estimateGas)
+                        return [2 /*return*/, smartNumber(gas)];
+                    gasLimit = mulBy1_3(DIGas(gas));
+                    return [4 /*yield*/, curve.updateFeeData()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, contract.deploy_metapool(basePool, name, symbol, coin, _A, _fee, offpegFeeMultiplier, emaTime, implementationIdx, assetType, methodId, oracleAddress, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                case 3: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+export var deployStableNgMetaPoolEstimateGas = function (basePool, name, symbol, coin, A, fee, // %
+offpegFeeMultiplier, assetType, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+emaTime, // seconds
+implementationIdx, methodName, oracleAddress) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableNgMetaPool(basePool, name, symbol, coin, A, fee, offpegFeeMultiplier, assetType, emaTime, implementationIdx, methodName, oracleAddress, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var deployStableNgMetaPool = function (basePool, name, symbol, coin, A, fee, // %
+offpegFeeMultiplier, emaTime, // seconds
+implementationIdx, assetType, // 0 = Standard, 1 = Oracle, 2 = Rebasing, 3 = ERC4626
+methodName, oracleAddress) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _deployStableNgMetaPool(basePool, name, symbol, coin, A, fee, offpegFeeMultiplier, assetType, emaTime, implementationIdx, methodName, oracleAddress, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
 export var getDeployedStableMetaPoolAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
     var txInfo, i, basePoolId, basePool;
     return __generator(this, function (_a) {

package/lib/index.d.ts

@@ -95,7 +95,16 @@ declare const curve: {
     };
     stableNgFactory: {
         fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
+        deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<ethers.ContractTransactionResponse>;
+        deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, offpegFeeMultiplier: string | number, emaTime: number, implementationIdx: 0, assetType: 0 | 1 | 2 | 3, methodName: string, oracleAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        getDeployedPlainPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        estimateGas: {
+            deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<number>;
+            deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetType: 0 | 1 | 2 | 3, emaTime: number, implementationIdx: 0, methodName: string, oracleAddress: string) => Promise<number>;
+        };
     };
     cryptoFactory: {
         fetchPools: (useApi?: boolean) => Promise<void>;

package/lib/index.js

@@ -40,7 +40,7 @@ import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceIm
 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, lastEthBlock, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, lastBlockSent, blockToSend, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, } from "./boosting.js";
 import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, getUsdRate, getGasPriceFromL1, getGasPriceFromL2, getTVL, getCoinsData, getVolume, hasDepositAndStake, hasRouter, } from "./utils.js";
-import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, deployGaugeSidechain, deployGaugeSidechainEstimateGas, deployGaugeMirror, deployGaugeMirrorEstimateGas, getDeployedGaugeMirrorAddress, getDeployedGaugeMirrorAddressByTx, } from './factory/deploy.js';
+import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, deployGaugeSidechain, deployGaugeSidechainEstimateGas, deployGaugeMirror, deployGaugeMirrorEstimateGas, getDeployedGaugeMirrorAddress, getDeployedGaugeMirrorAddressByTx, deployStableNgPlainPool, deployStableNgPlainPoolEstimateGas, deployStableNgMetaPool, deployStableNgMetaPoolEstimateGas, } from './factory/deploy.js';
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -135,7 +135,16 @@ var curve = {
     },
     stableNgFactory: {
         fetchPools: _curve.fetchStableNgFactoryPools,
+        fetchNewPools: _curve.fetchNewStableNgFactoryPools,
         getPoolList: _curve.getStableNgFactoryPoolList,
+        deployPlainPool: deployStableNgPlainPool,
+        deployMetaPool: deployStableNgMetaPool,
+        getDeployedPlainPoolAddress: getDeployedStablePlainPoolAddress,
+        getDeployedMetaPoolAddress: getDeployedStableMetaPoolAddress,
+        estimateGas: {
+            deployPlainPool: deployStableNgPlainPoolEstimateGas,
+            deployMetaPool: deployStableNgMetaPoolEstimateGas,
+        },
     },
     cryptoFactory: {
         fetchPools: _curve.fetchCryptoFactoryPools,

package/package.json

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