@curvefi/api 2.69.18 → 2.70.1

package/README.md

@@ -325,6 +325,98 @@ import curve from "@curvefi/api";
 })()
 ````
 
+### Building a pool from external data (getPoolByData)
+
+`curve.getPoolByData(data)` builds a fully working pool from an externally supplied descriptor,
+without calling `fetchPools` first. Use it when the pool metadata comes from your own source
+(backend, cache, DB) instead of Curve's API. curve resolves all the ABIs (swap / gauge / zap / LP)
+itself from `poolType` + `implementationAddress` + `isMetaPool` — you don't pass any ABI.
+
+The descriptor (`IExternalPoolData`) mirrors the shape of the `getPools/{network}/{poolType}` API:
+
+```ts
+interface IExternalPoolData {
+    poolType: 'factory' | 'factory-crvusd' | 'factory-crypto' | 'factory-twocrypto' | 'factory-tricrypto' | 'factory-stable-ng',
+    address: string,                                                          // swap address
+    coins: { address: string, symbol: string, decimals: number | string }[],
+    id?: string,                                                              // registry handle; defaults to address
+    name?: string,
+    symbol?: string,
+    lpTokenAddress?: string,                                                  // separate LP token for old crypto pools; defaults to address
+    gaugeAddress?: string,
+    implementationAddress?: string,                                           // REQUIRED for 'factory' (old stable) and 'factory-tricrypto'
+    isMetaPool?: boolean,
+    basePoolAddress?: string,                                                 // REQUIRED when isMetaPool
+    assetTypeName?: string,
+}
+```
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
+
+    const pool = curve.getPoolByData({
+        poolType: 'factory-stable-ng',
+        address: '0x...',
+        isMetaPool: false,
+        coins: [
+            { address: '0x...', symbol: 'USDC', decimals: 6 },
+            { address: '0x...', symbol: 'USDT', decimals: 6 },
+        ],
+    });
+
+    // From here the pool behaves exactly like one returned by curve.getPool(...)
+    pool.underlyingCoins;      // ['USDC', 'USDT']
+    await pool.deposit(['1', '1']);
+})()
+```
+
+### Meta pools: base pool dependencies
+
+A meta pool is built on top of a base pool, and its descriptor does **not** carry the base pool's
+coins/decimals — so the base pool must already be present in the instance before you build the meta
+pool. If the base is a plain/main pool (e.g. `3pool`) it is always available right after `init`, but
+if the base is itself a factory pool you must build it first.
+
+Two helpers let the frontend resolve this without try/catch:
+
+- **`curve.isBasePoolsReady(data): boolean`** — `true` if the pool can be built right now (always `true` for non-meta pools).
+- **`curve.getRequiredBasePools(data): string[]`** — addresses of the base pools that still need to be built (empty ⇒ ready).
+
+The base pool address is derived from the descriptor (`basePoolAddress`, or the last coin for crypto
+meta pools). The frontend looks that address up in its own data, builds it, and re-checks:
+
+```ts
+// Recursively make sure every base pool of `data` is initialized, then build the pool.
+function ensurePool(data) {
+    if (!curve.isBasePoolsReady(data)) {
+        for (const baseAddress of curve.getRequiredBasePools(data)) {
+            const baseData = myDataSource.getByAddress(baseAddress); // your descriptor for the base pool
+            ensurePool(baseData);                                    // base may itself be a meta pool
+        }
+    }
+    return curve.getPoolByData(data);
+}
+
+const pool = ensurePool(metaDescriptor);
+```
+
+The typical frontend loop:
+
+```ts
+if (!curve.isBasePoolsReady(desc)) {
+    const need = curve.getRequiredBasePools(desc);        // e.g. ['0x383e…']
+    need.forEach((addr) => curve.getPoolByData(myDataSource.getByAddress(addr)));
+    // curve.isBasePoolsReady(desc) === true now
+}
+const pool = curve.getPoolByData(desc);
+```
+
+As a safety net, if you call `getPoolByData` on a meta pool before its base is ready it throws an error
+carrying the missing addresses on `error.missingBasePools`.
+
 ### Pool fields
 ```ts
 import curve from "@curvefi/api";

package/lib/curve.js

@@ -298,7 +298,7 @@ export class Curve {
                 ...this.getTricryptoFactoryPoolList(),
             ];
         };
-        this.getPoolsData = () => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.constants.POOLS_DATA), this.constants.FACTORY_POOLS_DATA), this.constants.CRVUSD_FACTORY_POOLS_DATA), this.constants.CRYPTO_FACTORY_POOLS_DATA), this.constants.STABLE_NG_FACTORY_POOLS_DATA), this.constants.TWOCRYPTO_FACTORY_POOLS_DATA), this.constants.TRICRYPTO_FACTORY_POOLS_DATA), this.constants.LLAMMAS_DATA));
+        this.getPoolsData = () => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.constants.POOLS_DATA), this.constants.FACTORY_POOLS_DATA), this.constants.CRVUSD_FACTORY_POOLS_DATA), this.constants.CRYPTO_FACTORY_POOLS_DATA), this.constants.STABLE_NG_FACTORY_POOLS_DATA), this.constants.TWOCRYPTO_FACTORY_POOLS_DATA), this.constants.TRICRYPTO_FACTORY_POOLS_DATA), this.constants.EXTERNAL_POOLS_DATA), this.constants.LLAMMAS_DATA));
         this.getGaugeImplementation = (factoryType) => this.constants.FACTORY_GAUGE_IMPLEMENTATIONS[factoryType] || this.constants.ZERO_ADDRESS;
         this.getNetworkConstants = () => {
             return this.constants;
@@ -340,6 +340,7 @@ export class Curve {
             TWOCRYPTO_FACTORY_POOLS_DATA: {},
             TRICRYPTO_FACTORY_POOLS_DATA: {},
             STABLE_NG_FACTORY_POOLS_DATA: {},
+            EXTERNAL_POOLS_DATA: {},
             BASE_POOLS: {},
             LLAMMAS_DATA: {},
             COINS: {},
@@ -379,6 +380,7 @@ export class Curve {
                 TWOCRYPTO_FACTORY_POOLS_DATA: {},
                 TRICRYPTO_FACTORY_POOLS_DATA: {},
                 STABLE_NG_FACTORY_POOLS_DATA: {},
+                EXTERNAL_POOLS_DATA: {},
                 BASE_POOLS: {},
                 LLAMMAS_DATA: {},
                 COINS: {},
@@ -389,6 +391,7 @@ export class Curve {
             };
             this.initContract = memoizedContract();
             this.initMulticallContract = memoizedMulticallContract();
+            let signerPromise = Promise.resolve(null);
             // JsonRpc provider
             if (providerType.toLowerCase() === 'JsonRpc'.toLowerCase()) {
                 providerSettings = providerSettings;
@@ -405,22 +408,17 @@ export class Curve {
                     this.provider = new ethers.JsonRpcProvider('http://localhost:8545/', undefined, jsonRpcApiProviderOptions);
                 }
                 if (providerSettings.privateKey) {
-                    this.signer = new ethers.Wallet(providerSettings.privateKey, this.provider);
+                    signerPromise = Promise.resolve(new ethers.Wallet(providerSettings.privateKey, this.provider));
                 }
                 else if (!((_b = providerSettings.url) === null || _b === void 0 ? void 0 : _b.startsWith("https://rpc.gnosischain.com"))) {
-                    try {
-                        this.signer = yield this.provider.getSigner();
-                    }
-                    catch (_m) {
-                        this.signer = null;
-                    }
+                    signerPromise = this.provider.getSigner().catch(() => null);
                 }
                 // Web3 provider
             }
             else if (providerType.toLowerCase() === 'Web3'.toLowerCase()) {
                 providerSettings = providerSettings;
                 this.provider = new ethers.BrowserProvider(providerSettings.externalProvider);
-                this.signer = yield this.provider.getSigner();
+                signerPromise = this.provider.getSigner();
                 // Infura provider
             }
             else if (providerType.toLowerCase() === 'Infura'.toLowerCase()) {
@@ -444,7 +442,11 @@ export class Curve {
             else {
                 throw Error('Wrong providerType');
             }
-            const network = this.isNoRPC ? { chainId: options.chainId, name: 'NoRPC' } : yield this.provider.getNetwork();
+            const [signer, network] = yield Promise.all([
+                signerPromise,
+                this.isNoRPC ? Promise.resolve({ chainId: options.chainId, name: 'NoRPC' }) : this.provider.getNetwork(),
+            ]);
+            this.signer = signer;
             console.log("CURVE-JS IS CONNECTED TO NETWORK:", { name: network.name.toUpperCase(), chainId: Number(network.chainId) });
             this.chainId = Number(network.chainId) === 133 || Number(network.chainId) === 31337 ? 1 : Number(network.chainId);
             this.isLiteChain = !(this.chainId in NETWORK_CONSTANTS);
@@ -485,22 +487,15 @@ export class Curve {
                 this.constantOptions = {};
             }
             this.multicallProvider = new MulticallProvider(this.chainId, this.provider);
-            if (this.signer) {
-                try {
-                    this.signerAddress = yield this.signer.getAddress();
-                }
-                catch (_o) {
-                    this.signer = null;
-                }
-            }
-            else {
-                this.signerAddress = '';
-            }
             this.feeData = { gasPrice: options.gasPrice, maxFeePerGas: options.maxFeePerGas, maxPriorityFeePerGas: options.maxPriorityFeePerGas };
             if (options.poolsData) {
                 _setPoolsFromApi(this.constants.NETWORK_NAME, this.isLiteChain, options.poolsData);
             }
-            yield this.updateFeeData();
+            const [signerAddress] = yield Promise.all([
+                this.signer ? this.signer.getAddress().catch(() => { this.signer = null; return ''; }) : Promise.resolve(''),
+                this.updateFeeData(),
+            ]);
+            this.signerAddress = signerAddress;
             for (const pool of Object.values(Object.assign(Object.assign({}, this.constants.POOLS_DATA), this.constants.LLAMMAS_DATA))) {
                 this.setContract(pool.swap_address, pool.swap_abi);
                 if (pool.token_address !== pool.swap_address) {

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

@@ -2,3 +2,4 @@ import { IDict, IFactoryPoolType, IPoolData, IPoolDataFromApi } from "../interfa
 import { type Curve } from "../curve";
 export declare const lowerCasePoolDataAddresses: (poolsData: IPoolDataFromApi[]) => IPoolDataFromApi[];
 export declare function getFactoryPoolsDataFromApi(this: Curve, factoryType: IFactoryPoolType): Promise<IDict<IPoolData>>;
+export declare function buildFactoryPoolsData(this: Curve, factoryType: IFactoryPoolType, rawPoolListInput: IPoolDataFromApi[]): IDict<IPoolData>;

package/lib/factory/factory-api.js

@@ -90,201 +90,209 @@ function setFactoryCoinsContracts(rawPoolList) {
 }
 export function getFactoryPoolsDataFromApi(factoryType) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
         const network = this.constants.NETWORK_NAME;
-        const is_ng = ["factory-stable-ng", "factory-twocrypto", "factory-tricrypto"].includes(factoryType);
-        const isCrypto = ["factory-crypto", "factory-twocrypto", "factory-tricrypto"].includes(factoryType);
-        const implementationABIDict = (_a = this.constants.STABLE_FACTORY_CONSTANTS.implementationABIDict) !== null && _a !== void 0 ? _a : {};
-        let rawPoolList = lowerCasePoolDataAddresses((yield _getPoolsFromApi(network, factoryType, this.isLiteChain)).poolData);
-        if (!isCrypto)
-            rawPoolList = rawPoolList.filter((p) => is_ng || p.implementationAddress in implementationABIDict);
-        // Filter duplications
-        const mainAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address);
-        rawPoolList = rawPoolList.filter((p) => !mainAddresses.includes(p.address));
-        const swapABIs = isCrypto ? [] : rawPoolList.map((pool) => is_ng ?
-            (pool.isMetaPool ? MetaStableSwapNGABI : PlainStableSwapNGABI) :
-            implementationABIDict[pool.implementationAddress]);
-        setFactorySwapContracts.call(this, rawPoolList, swapABIs, factoryType);
-        if (factoryType === "factory-crypto")
-            setCryptoFactoryTokenContracts.call(this, rawPoolList);
-        setFactoryGaugeContracts.call(this, rawPoolList);
-        setFactoryCoinsContracts.call(this, rawPoolList);
-        setFactoryZapContracts.call(this, isCrypto);
-        const FACTORY_POOLS_DATA = {};
-        rawPoolList.forEach((pool, i) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            const nativeToken = this.constants.NATIVE_TOKEN;
-            const isETHEnabled = pool.implementationAddress === ((_a = this.constants.CRYPTO_FACTORY_CONSTANTS.tricryptoDeployImplementations) === null || _a === void 0 ? void 0 : _a.amm_native_transfers_enabled);
-            let coinAddresses = pool.coins.map((c) => c.address);
-            if (this.chainId === 137) {
-                coinAddresses = coinAddresses.map((a) => a === "0x0000000000000000000000000000000000001010" ? nativeToken.wrappedAddress : a);
-            }
-            const coinNames = pool.coins.map((c) => c.symbol);
-            const coinDecimals = pool.coins.map((c) => Number(c.decimals));
-            if (isCrypto) {
-                const wrappedCoinNames = pool.coins.map((c) => c.symbol === nativeToken.symbol ? nativeToken.wrappedSymbol : c.symbol);
-                const underlyingCoinNames = pool.coins.map((c) => {
-                    if (factoryType === 'factory-twocrypto') {
-                        return c.symbol;
-                    }
-                    else if (factoryType === 'factory-tricrypto') {
-                        if (isETHEnabled) {
-                            return c.symbol === nativeToken.wrappedSymbol ? nativeToken.symbol : c.symbol;
-                        }
-                        else {
-                            return c.symbol;
-                        }
-                    }
-                    else {
+        const rawPoolList = lowerCasePoolDataAddresses((yield _getPoolsFromApi(network, factoryType, this.isLiteChain)).poolData);
+        return buildFactoryPoolsData.call(this, factoryType, rawPoolList);
+    });
+}
+export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
+    var _a;
+    const is_ng = ["factory-stable-ng", "factory-twocrypto", "factory-tricrypto"].includes(factoryType);
+    const isCrypto = ["factory-crypto", "factory-twocrypto", "factory-tricrypto"].includes(factoryType);
+    const implementationABIDict = (_a = this.constants.STABLE_FACTORY_CONSTANTS.implementationABIDict) !== null && _a !== void 0 ? _a : {};
+    let rawPoolList = rawPoolListInput;
+    if (!isCrypto)
+        rawPoolList = rawPoolList.filter((p) => is_ng || p.implementationAddress in implementationABIDict);
+    // Filter duplications
+    const mainAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address);
+    rawPoolList = rawPoolList.filter((p) => !mainAddresses.includes(p.address));
+    const swapABIs = isCrypto ? [] : rawPoolList.map((pool) => is_ng ?
+        (pool.isMetaPool ? MetaStableSwapNGABI : PlainStableSwapNGABI) :
+        implementationABIDict[pool.implementationAddress]);
+    setFactorySwapContracts.call(this, rawPoolList, swapABIs, factoryType);
+    if (factoryType === "factory-crypto")
+        setCryptoFactoryTokenContracts.call(this, rawPoolList);
+    setFactoryGaugeContracts.call(this, rawPoolList);
+    setFactoryCoinsContracts.call(this, rawPoolList);
+    setFactoryZapContracts.call(this, isCrypto);
+    const FACTORY_POOLS_DATA = {};
+    rawPoolList.forEach((pool, i) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const nativeToken = this.constants.NATIVE_TOKEN;
+        const isETHEnabled = pool.implementationAddress === ((_a = this.constants.CRYPTO_FACTORY_CONSTANTS.tricryptoDeployImplementations) === null || _a === void 0 ? void 0 : _a.amm_native_transfers_enabled);
+        let coinAddresses = pool.coins.map((c) => c.address);
+        if (this.chainId === 137) {
+            coinAddresses = coinAddresses.map((a) => a === "0x0000000000000000000000000000000000001010" ? nativeToken.wrappedAddress : a);
+        }
+        const coinNames = pool.coins.map((c) => c.symbol);
+        const coinDecimals = pool.coins.map((c) => Number(c.decimals));
+        if (isCrypto) {
+            const wrappedCoinNames = pool.coins.map((c) => c.symbol === nativeToken.symbol ? nativeToken.wrappedSymbol : c.symbol);
+            const underlyingCoinNames = pool.coins.map((c) => {
+                if (factoryType === 'factory-twocrypto') {
+                    return c.symbol;
+                }
+                else if (factoryType === 'factory-tricrypto') {
+                    if (isETHEnabled) {
                         return c.symbol === nativeToken.wrappedSymbol ? nativeToken.symbol : c.symbol;
                     }
-                });
-                const underlyingCoinAddresses = coinAddresses.map((addr) => {
-                    if (factoryType === 'factory-twocrypto') {
-                        return addr;
-                    }
-                    else if (factoryType === 'factory-tricrypto') {
-                        if (isETHEnabled) {
-                            return addr === nativeToken.wrappedAddress ? nativeToken.address : addr;
-                        }
-                        else {
-                            return addr;
-                        }
-                    }
                     else {
-                        return addr === nativeToken.wrappedAddress ? nativeToken.address : addr;
+                        return c.symbol;
                     }
-                });
-                const isPlain = underlyingCoinNames.toString() === wrappedCoinNames.toString();
-                const lpTokenBasePoolIdDict = (_b = this.constants.CRYPTO_FACTORY_CONSTANTS.lpTokenBasePoolIdDict) !== null && _b !== void 0 ? _b : {};
-                const basePoolIdZapDict = (_c = this.constants.CRYPTO_FACTORY_CONSTANTS.basePoolIdZapDict) !== null && _c !== void 0 ? _c : {};
-                const basePoolId = lpTokenBasePoolIdDict[coinAddresses[1]];
-                if (factoryType !== "factory-tricrypto" && factoryType !== "factory-twocrypto" && basePoolId) { // isMeta
-                    const allPoolsData = Object.assign(Object.assign({}, this.constants.POOLS_DATA), FACTORY_POOLS_DATA);
-                    const basePoolCoinNames = [...allPoolsData[basePoolId].underlying_coins];
-                    const basePoolCoinAddresses = [...allPoolsData[basePoolId].underlying_coin_addresses];
-                    const basePoolDecimals = [...allPoolsData[basePoolId].underlying_decimals];
-                    const basePoolZap = basePoolIdZapDict[basePoolId];
-                    this.constants.BASE_POOLS[basePoolId] = this.constants.BASE_POOLS[basePoolId] ? this.constants.BASE_POOLS[basePoolId] + 1 : 1;
-                    FACTORY_POOLS_DATA[pool.id] = {
-                        name: getPoolName(pool.name),
-                        full_name: pool.name,
-                        symbol: pool.symbol,
-                        reference_asset: "CRYPTO",
-                        swap_address: pool.address,
-                        token_address: pool.lpTokenAddress,
-                        gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
-                        deposit_address: basePoolZap.address,
-                        is_meta: true,
-                        is_crypto: true,
-                        is_factory: true,
-                        base_pool: basePoolId,
-                        underlying_coins: [underlyingCoinNames[0], ...basePoolCoinNames],
-                        wrapped_coins: wrappedCoinNames,
-                        underlying_coin_addresses: [underlyingCoinAddresses[0], ...basePoolCoinAddresses],
-                        wrapped_coin_addresses: coinAddresses,
-                        underlying_decimals: [coinDecimals[0], ...basePoolDecimals],
-                        wrapped_decimals: coinDecimals,
-                        swap_abi: cryptoFactorySwapABI,
-                        gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
-                        deposit_abi: basePoolZap.ABI,
-                        in_api: true,
-                        is_ng,
-                    };
                 }
                 else {
-                    FACTORY_POOLS_DATA[pool.id] = {
-                        name: factoryType === "factory-tricrypto" ? pool.name : getPoolName(pool.name),
-                        full_name: pool.name,
-                        symbol: pool.symbol,
-                        reference_asset: "CRYPTO",
-                        swap_address: pool.address,
-                        token_address: pool.lpTokenAddress,
-                        gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
-                        is_crypto: true,
-                        is_plain: isPlain,
-                        is_factory: true,
-                        underlying_coins: underlyingCoinNames,
-                        wrapped_coins: wrappedCoinNames,
-                        underlying_coin_addresses: underlyingCoinAddresses,
-                        wrapped_coin_addresses: coinAddresses,
-                        underlying_decimals: coinDecimals,
-                        wrapped_decimals: coinDecimals,
-                        swap_abi: getSwapAbiByFactoryType.call(this, factoryType, pool),
-                        gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
-                        in_api: true,
-                        is_ng,
-                    };
+                    return c.symbol === nativeToken.wrappedSymbol ? nativeToken.symbol : c.symbol;
                 }
-            }
-            else if (pool.isMetaPool) {
-                const allPoolsData = Object.assign(Object.assign({}, this.constants.POOLS_DATA), FACTORY_POOLS_DATA);
-                const basePoolId = getPoolIdByAddress.call(this, rawPoolList, pool.basePoolAddress);
-                this.constants.BASE_POOLS[basePoolId] = this.constants.BASE_POOLS[basePoolId] ? this.constants.BASE_POOLS[basePoolId] + 1 : 1;
-                const basePoolCoinNames = (_d = allPoolsData[basePoolId]) === null || _d === void 0 ? void 0 : _d.underlying_coins;
-                const basePoolCoinAddresses = (_e = allPoolsData[basePoolId]) === null || _e === void 0 ? void 0 : _e.underlying_coin_addresses;
-                const basePoolDecimals = (_f = allPoolsData[basePoolId]) === null || _f === void 0 ? void 0 : _f.underlying_decimals;
-                const basePoolIdZapDict = (_g = this.constants.STABLE_FACTORY_CONSTANTS.basePoolIdZapDict) !== null && _g !== void 0 ? _g : {};
-                let deposit_address = (_h = this.constants.STABLE_FACTORY_CONSTANTS.stableNgBasePoolZap) !== null && _h !== void 0 ? _h : this.constants.ZERO_ADDRESS;
-                let deposit_abi = StableNgBasePoolZapABI;
-                if (isStableNgPool(basePoolId)) {
-                    this.setContract(deposit_address, StableNgBasePoolZapABI);
+            });
+            const underlyingCoinAddresses = coinAddresses.map((addr) => {
+                if (factoryType === 'factory-twocrypto') {
+                    return addr;
+                }
+                else if (factoryType === 'factory-tricrypto') {
+                    if (isETHEnabled) {
+                        return addr === nativeToken.wrappedAddress ? nativeToken.address : addr;
+                    }
+                    else {
+                        return addr;
+                    }
                 }
                 else {
-                    deposit_address = basePoolIdZapDict[basePoolId].address;
-                    deposit_abi = basePoolIdZapDict[basePoolId].ABI;
+                    return addr === nativeToken.wrappedAddress ? nativeToken.address : addr;
                 }
+            });
+            const isPlain = underlyingCoinNames.toString() === wrappedCoinNames.toString();
+            const lpTokenBasePoolIdDict = (_b = this.constants.CRYPTO_FACTORY_CONSTANTS.lpTokenBasePoolIdDict) !== null && _b !== void 0 ? _b : {};
+            const basePoolIdZapDict = (_c = this.constants.CRYPTO_FACTORY_CONSTANTS.basePoolIdZapDict) !== null && _c !== void 0 ? _c : {};
+            const basePoolId = lpTokenBasePoolIdDict[coinAddresses[1]];
+            if (factoryType !== "factory-tricrypto" && factoryType !== "factory-twocrypto" && basePoolId) { // isMeta
+                const allPoolsData = Object.assign(Object.assign({}, this.getPoolsData()), FACTORY_POOLS_DATA);
+                if (!allPoolsData[basePoolId])
+                    throw new Error(`Base pool "${basePoolId}" of meta pool ${pool.id} (${pool.address}) is not loaded. Build or fetch the base pool before this one.`);
+                const basePoolCoinNames = [...allPoolsData[basePoolId].underlying_coins];
+                const basePoolCoinAddresses = [...allPoolsData[basePoolId].underlying_coin_addresses];
+                const basePoolDecimals = [...allPoolsData[basePoolId].underlying_decimals];
+                const basePoolZap = basePoolIdZapDict[basePoolId];
+                this.constants.BASE_POOLS[basePoolId] = this.constants.BASE_POOLS[basePoolId] ? this.constants.BASE_POOLS[basePoolId] + 1 : 1;
                 FACTORY_POOLS_DATA[pool.id] = {
                     name: getPoolName(pool.name),
                     full_name: pool.name,
                     symbol: pool.symbol,
-                    reference_asset: assetTypeNameHandler(pool.assetTypeName),
+                    reference_asset: "CRYPTO",
                     swap_address: pool.address,
-                    token_address: pool.address,
+                    token_address: pool.lpTokenAddress,
                     gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
-                    deposit_address,
-                    implementation_address: pool.implementationAddress, // Only for testing
+                    deposit_address: basePoolZap.address,
                     is_meta: true,
+                    is_crypto: true,
                     is_factory: true,
                     base_pool: basePoolId,
-                    underlying_coins: [coinNames[0], ...basePoolCoinNames],
-                    wrapped_coins: coinNames,
-                    underlying_coin_addresses: [coinAddresses[0], ...basePoolCoinAddresses],
+                    underlying_coins: [underlyingCoinNames[0], ...basePoolCoinNames],
+                    wrapped_coins: wrappedCoinNames,
+                    underlying_coin_addresses: [underlyingCoinAddresses[0], ...basePoolCoinAddresses],
                     wrapped_coin_addresses: coinAddresses,
                     underlying_decimals: [coinDecimals[0], ...basePoolDecimals],
                     wrapped_decimals: coinDecimals,
-                    swap_abi: swapABIs[i],
+                    swap_abi: cryptoFactorySwapABI,
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
-                    deposit_abi,
+                    deposit_abi: basePoolZap.ABI,
                     in_api: true,
                     is_ng,
                 };
             }
             else {
                 FACTORY_POOLS_DATA[pool.id] = {
-                    name: getPoolName(pool.name),
+                    name: factoryType === "factory-tricrypto" ? pool.name : getPoolName(pool.name),
                     full_name: pool.name,
                     symbol: pool.symbol,
-                    reference_asset: assetTypeNameHandler(pool.assetTypeName),
+                    reference_asset: "CRYPTO",
                     swap_address: pool.address,
-                    token_address: pool.address,
+                    token_address: pool.lpTokenAddress,
                     gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
-                    implementation_address: pool.implementationAddress, // Only for testing
-                    is_plain: true,
+                    is_crypto: true,
+                    is_plain: isPlain,
                     is_factory: true,
-                    underlying_coins: coinNames,
-                    wrapped_coins: coinNames,
-                    underlying_coin_addresses: coinAddresses,
+                    underlying_coins: underlyingCoinNames,
+                    wrapped_coins: wrappedCoinNames,
+                    underlying_coin_addresses: underlyingCoinAddresses,
                     wrapped_coin_addresses: coinAddresses,
                     underlying_decimals: coinDecimals,
                     wrapped_decimals: coinDecimals,
-                    swap_abi: swapABIs[i],
+                    swap_abi: getSwapAbiByFactoryType.call(this, factoryType, pool),
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                     in_api: true,
                     is_ng,
                 };
             }
-        });
-        return FACTORY_POOLS_DATA;
+        }
+        else if (pool.isMetaPool) {
+            const allPoolsData = Object.assign(Object.assign({}, this.getPoolsData()), FACTORY_POOLS_DATA);
+            const basePoolId = getPoolIdByAddress.call(this, rawPoolList, pool.basePoolAddress);
+            if (!allPoolsData[basePoolId])
+                throw new Error(`Base pool "${pool.basePoolAddress}" of meta pool ${pool.id} (${pool.address}) is not loaded. Build or fetch the base pool before this one.`);
+            this.constants.BASE_POOLS[basePoolId] = this.constants.BASE_POOLS[basePoolId] ? this.constants.BASE_POOLS[basePoolId] + 1 : 1;
+            const basePoolCoinNames = (_d = allPoolsData[basePoolId]) === null || _d === void 0 ? void 0 : _d.underlying_coins;
+            const basePoolCoinAddresses = (_e = allPoolsData[basePoolId]) === null || _e === void 0 ? void 0 : _e.underlying_coin_addresses;
+            const basePoolDecimals = (_f = allPoolsData[basePoolId]) === null || _f === void 0 ? void 0 : _f.underlying_decimals;
+            const basePoolIdZapDict = (_g = this.constants.STABLE_FACTORY_CONSTANTS.basePoolIdZapDict) !== null && _g !== void 0 ? _g : {};
+            let deposit_address = (_h = this.constants.STABLE_FACTORY_CONSTANTS.stableNgBasePoolZap) !== null && _h !== void 0 ? _h : this.constants.ZERO_ADDRESS;
+            let deposit_abi = StableNgBasePoolZapABI;
+            if (isStableNgPool(basePoolId)) {
+                this.setContract(deposit_address, StableNgBasePoolZapABI);
+            }
+            else {
+                deposit_address = basePoolIdZapDict[basePoolId].address;
+                deposit_abi = basePoolIdZapDict[basePoolId].ABI;
+            }
+            FACTORY_POOLS_DATA[pool.id] = {
+                name: getPoolName(pool.name),
+                full_name: pool.name,
+                symbol: pool.symbol,
+                reference_asset: assetTypeNameHandler(pool.assetTypeName),
+                swap_address: pool.address,
+                token_address: pool.address,
+                gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
+                deposit_address,
+                implementation_address: pool.implementationAddress, // Only for testing
+                is_meta: true,
+                is_factory: true,
+                base_pool: basePoolId,
+                underlying_coins: [coinNames[0], ...basePoolCoinNames],
+                wrapped_coins: coinNames,
+                underlying_coin_addresses: [coinAddresses[0], ...basePoolCoinAddresses],
+                wrapped_coin_addresses: coinAddresses,
+                underlying_decimals: [coinDecimals[0], ...basePoolDecimals],
+                wrapped_decimals: coinDecimals,
+                swap_abi: swapABIs[i],
+                gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+                deposit_abi,
+                in_api: true,
+                is_ng,
+            };
+        }
+        else {
+            FACTORY_POOLS_DATA[pool.id] = {
+                name: getPoolName(pool.name),
+                full_name: pool.name,
+                symbol: pool.symbol,
+                reference_asset: assetTypeNameHandler(pool.assetTypeName),
+                swap_address: pool.address,
+                token_address: pool.address,
+                gauge_address: pool.gaugeAddress ? pool.gaugeAddress : this.constants.ZERO_ADDRESS,
+                implementation_address: pool.implementationAddress, // Only for testing
+                is_plain: true,
+                is_factory: true,
+                underlying_coins: coinNames,
+                wrapped_coins: coinNames,
+                underlying_coin_addresses: coinAddresses,
+                wrapped_coin_addresses: coinAddresses,
+                underlying_decimals: coinDecimals,
+                wrapped_decimals: coinDecimals,
+                swap_abi: swapABIs[i],
+                gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+                in_api: true,
+                is_ng,
+            };
+        }
     });
+    return FACTORY_POOLS_DATA;
 }

package/lib/index.d.ts

@@ -43,6 +43,9 @@ export declare const createCurve: () => {
     PoolTemplate: typeof PoolTemplate;
     getBasePools: () => Promise<import("./interfaces.js").IBasePoolShortItem[]>;
     getPool: (poolIdOrAddress: string) => PoolTemplate;
+    getPoolByData: (data: import("./interfaces.js").IExternalPoolData) => PoolTemplate;
+    getRequiredBasePools: (data: import("./interfaces.js").IExternalPoolData) => string[];
+    isBasePoolsReady: (data: import("./interfaces.js").IExternalPoolData) => boolean;
     getUsdRate: (coin: string) => Promise<number>;
     getGasPriceFromL1: () => Promise<number>;
     getGasPriceFromL2: () => Promise<number>;
@@ -377,6 +380,9 @@ declare const _default: {
     PoolTemplate: typeof PoolTemplate;
     getBasePools: () => Promise<import("./interfaces.js").IBasePoolShortItem[]>;
     getPool: (poolIdOrAddress: string) => PoolTemplate;
+    getPoolByData: (data: import("./interfaces.js").IExternalPoolData) => PoolTemplate;
+    getRequiredBasePools: (data: import("./interfaces.js").IExternalPoolData) => string[];
+    isBasePoolsReady: (data: import("./interfaces.js").IExternalPoolData) => boolean;
     getUsdRate: (coin: string) => Promise<number>;
     getGasPriceFromL1: () => Promise<number>;
     getGasPriceFromL2: () => Promise<number>;

package/lib/index.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { PoolTemplate, getPool } from "./pools/index.js";
+import { PoolTemplate, getPool, getPoolByData, getRequiredBasePools, isBasePoolsReady } from "./pools/index.js";
 import { getUserPoolListByLiquidity, getUserPoolListByClaimable, getUserPoolList, getUserLiquidityUSD, getUserClaimable, } from "./pools/utils.js";
 import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapPopulateApprove, swapEstimateGas, swap, populateSwap, getSwappedAmount, approveFromCalldata, approveFromCalldataEstimateGas, swapFromCalldata, swapFromCalldataEstimateGas, setRouterBlacklist, } from "./router.js";
 import { isSupported, assertIsSupported, allowedToBridge, bridgeCost, bridgeIsApproved, bridgeApproveEstimateGas, bridgeApprove, bridgeEstimateGas, bridge, getSupportedNetworks, } from "./bridge.js";
@@ -43,6 +43,9 @@ export const createCurve = () => {
         PoolTemplate: PoolTemplate.bind(_curve),
         getBasePools: getBasePools.bind(_curve),
         getPool: getPool.bind(_curve),
+        getPoolByData: getPoolByData.bind(_curve),
+        getRequiredBasePools: getRequiredBasePools.bind(_curve),
+        isBasePoolsReady: isBasePoolsReady.bind(_curve),
         getUsdRate: getUsdRate.bind(_curve),
         getGasPriceFromL1: getGasPriceFromL1.bind(_curve),
         getGasPriceFromL2: getGasPriceFromL2.bind(_curve),

package/lib/interfaces.d.ts

@@ -81,6 +81,7 @@ export interface INetworkConstants {
     CRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
     TWOCRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
     TRICRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+    EXTERNAL_POOLS_DATA?: IDict<IPoolData>;
     BASE_POOLS: IDict<number>;
     LLAMMAS_DATA: IDict<IPoolData>;
     COINS: IDict<string>;
@@ -170,6 +171,25 @@ export interface IPoolDataShort {
     id: string;
     address: string;
 }
+export interface IExternalPoolData {
+    poolType: IFactoryPoolType;
+    address: string;
+    coins: {
+        address: string;
+        symbol: string;
+        decimals: number | string;
+    }[];
+    id?: string;
+    name?: string;
+    symbol?: string;
+    lpTokenAddress?: string;
+    gaugeAddress?: string;
+    implementationAddress?: string;
+    isMetaPool?: boolean;
+    basePoolAddress?: string;
+    assetTypeName?: string;
+    gaugeRewards?: IRewardFromApi[];
+}
 export type IRoutePoolData = Pick<IPoolData, 'is_lending' | 'wrapped_coin_addresses' | 'underlying_coin_addresses' | 'token_address'>;
 export interface IExtendedPoolDataFromApi {
     poolData: IPoolDataFromApi[];

package/lib/pools/index.d.ts

@@ -1,3 +1,3 @@
-import { getPool } from "./poolConstructor.js";
+import { getPool, getPoolByData, getRequiredBasePools, isBasePoolsReady } from "./poolConstructor.js";
 import { PoolTemplate } from "./PoolTemplate.js";
-export { getPool, PoolTemplate, };
+export { getPool, getPoolByData, getRequiredBasePools, isBasePoolsReady, PoolTemplate, };

package/lib/pools/index.js

@@ -1,3 +1,3 @@
-import { getPool } from "./poolConstructor.js";
+import { getPool, getPoolByData, getRequiredBasePools, isBasePoolsReady } from "./poolConstructor.js";
 import { PoolTemplate } from "./PoolTemplate.js";
-export { getPool, PoolTemplate, };
+export { getPool, getPoolByData, getRequiredBasePools, isBasePoolsReady, PoolTemplate, };

package/lib/pools/poolConstructor.d.ts

@@ -1,3 +1,7 @@
 import { type Curve } from "../curve.js";
 import { PoolTemplate } from "./PoolTemplate.js";
+import type { IExternalPoolData } from "../interfaces.js";
 export declare function getPool(this: Curve, poolIdOrAddress: string): PoolTemplate;
+export declare function getRequiredBasePools(this: Curve, data: IExternalPoolData): string[];
+export declare function isBasePoolsReady(this: Curve, data: IExternalPoolData): boolean;
+export declare function getPoolByData(this: Curve, data: IExternalPoolData): PoolTemplate;

package/lib/pools/poolConstructor.js

@@ -16,6 +16,8 @@ import { swapCryptoMetaFactoryMixin, swapMetaFactoryMixin, swapMixin, swapTricry
 import { swapWrappedExpectedAndApproveMixin, swapWrappedMixin, swapWrappedRequiredMixin, swapWrappedTricrypto2Mixin, } from "./mixins/swapWrappedMixins.js";
 import { findAbiSignature, getCountArgsOfMethodByAbi, getPoolIdBySwapAddress } from "../utils.js";
 import { StatsPool } from "./subClasses/statsPool.js";
+import { lowerCasePoolDataAddresses } from "../constants/utils.js";
+import { buildFactoryPoolsData, lowerCasePoolDataAddresses as lowerCaseApiPoolAddresses } from "../factory/factory-api.js";
 export function getPool(poolIdOrAddress) {
     const poolId = poolIdOrAddress.toLowerCase().startsWith('0x') ? getPoolIdBySwapAddress.call(this, poolIdOrAddress.toLowerCase()) : poolIdOrAddress;
     if (!poolId) {
@@ -225,3 +227,59 @@ export function getPool(poolIdOrAddress) {
     }
     return new Pool(poolId, this);
 }
+function resolveBasePoolAddress(data) {
+    if (!data.isMetaPool)
+        return null;
+    if (data.basePoolAddress)
+        return data.basePoolAddress.toLowerCase();
+    if (data.coins.length)
+        return data.coins[data.coins.length - 1].address.toLowerCase();
+    return null;
+}
+function isPoolLoaded(address) {
+    const a = address.toLowerCase();
+    return Object.values(this.getPoolsData()).some((pd) => pd.swap_address.toLowerCase() === a || pd.token_address.toLowerCase() === a);
+}
+export function getRequiredBasePools(data) {
+    const base = resolveBasePoolAddress(data);
+    return base && !isPoolLoaded.call(this, base) ? [base] : [];
+}
+export function isBasePoolsReady(data) {
+    return getRequiredBasePools.call(this, data).length === 0;
+}
+export function getPoolByData(data) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const id = ((_a = data.id) !== null && _a !== void 0 ? _a : data.address).toLowerCase();
+    const missingBasePools = getRequiredBasePools.call(this, data);
+    if (missingBasePools.length) {
+        const err = new Error(`Pool ${id} is a meta pool whose base pool ${missingBasePools.join(", ")} is not initialized. Call getPoolByData for the base pool(s) first.`);
+        err.missingBasePools = missingBasePools;
+        throw err;
+    }
+    const rawPool = {
+        id,
+        name: (_b = data.name) !== null && _b !== void 0 ? _b : id,
+        symbol: (_c = data.symbol) !== null && _c !== void 0 ? _c : "",
+        assetTypeName: (_d = data.assetTypeName) !== null && _d !== void 0 ? _d : "unknown",
+        address: data.address,
+        isMetaPool: (_e = data.isMetaPool) !== null && _e !== void 0 ? _e : false,
+        basePoolAddress: data.basePoolAddress,
+        lpTokenAddress: (_f = data.lpTokenAddress) !== null && _f !== void 0 ? _f : data.address,
+        gaugeAddress: data.gaugeAddress,
+        implementation: "",
+        implementationAddress: (_g = data.implementationAddress) !== null && _g !== void 0 ? _g : "",
+        coins: data.coins.map((c) => ({ address: c.address, symbol: c.symbol, decimals: String(c.decimals), usdPrice: 0 })),
+        gaugeRewards: (_h = data.gaugeRewards) !== null && _h !== void 0 ? _h : [],
+        usdTotal: 0,
+        totalSupply: 0,
+        amplificationCoefficient: "0",
+        gaugeCrvApy: [null, null],
+    };
+    const rawPoolList = lowerCaseApiPoolAddresses([rawPool]);
+    const builtData = lowerCasePoolDataAddresses(buildFactoryPoolsData.call(this, data.poolType, rawPoolList));
+    if (!builtData[id]) {
+        throw new Error(`Could not resolve ABI for pool ${id} (poolType=${data.poolType}, implementation=${(_j = data.implementationAddress) !== null && _j !== void 0 ? _j : "none"}). The implementation is unknown to curve for this poolType.`);
+    }
+    this.constants.EXTERNAL_POOLS_DATA = Object.assign(Object.assign({}, this.constants.EXTERNAL_POOLS_DATA), builtData);
+    return getPool.call(this, id);
+}

package/lib/route-finder.worker.js

@@ -100,7 +100,7 @@ export function routeFinderWorker() {
         }
         return _removeDuplications(targetRoutesByTvl, targetRoutesByLength).map((r) => r.route);
     };
-    if (typeof addEventListener === 'undefined') {
+    if (typeof Worker === 'undefined') {
         return findRoutes; // for nodejs
     }
     addEventListener('message', (e) => {

package/lib/route-graph.worker.js

@@ -531,7 +531,7 @@ export function routeGraphWorker() {
         console.log(`Read ${allPools.length} pools`, `${Date.now() - start}ms, routerGraph: ${Object.keys(routerGraph).length} items`);
         return routerGraph;
     };
-    if (typeof addEventListener === 'undefined') {
+    if (typeof Worker === 'undefined') {
         return createRouteGraph; // for nodejs
     }
     addEventListener('message', (e) => {

package/package.json

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