@curvefi/api 2.71.0 → 2.71.2

package/lib/cached.d.ts

@@ -1,7 +1,7 @@
 import { IDict, IExtendedPoolDataFromApi, INetworkName, IPoolType } from "./interfaces.js";
 export declare const _getPoolsFromApi: (network: INetworkName, poolType: IPoolType, isLiteChain?: boolean) => Promise<IExtendedPoolDataFromApi>;
-export declare const _getPoolTotalLiquidityFromApi: (network: INetworkName, poolId: string, address: string, isCrypto: boolean, isLiteChain: boolean) => Promise<string | undefined>;
 export declare const _setPoolsFromApi: (network: INetworkName, isLiteChain: boolean, data: Record<IPoolType, IExtendedPoolDataFromApi>) => void;
 export declare const _getAllPoolsFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IExtendedPoolDataFromApi[]>;
+export declare const _getPoolTotalLiquidityFromApi: (network: INetworkName, address: string, isLiteChain: boolean) => Promise<string | undefined>;
 export declare const _getUsdPricesFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IDict<number>>;
 export declare const _getCrvApyFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IDict<[number, number]>>;

package/lib/cached.js

@@ -74,18 +74,21 @@ export const _getPoolsFromApi = (network_1, poolType_1, ...args_1) => __awaiter(
     const { poolsDict } = yield _getCachedData(network, isLiteChain);
     return poolsDict[poolType];
 });
-export const _getPoolTotalLiquidityFromApi = (network, poolId, address, isCrypto, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
-    const poolType = poolId.startsWith("factory") ? poolId.replace(/-\d+$/, '').replace(/-v2$/, '') : isCrypto ? "crypto" : "main";
-    const { poolData } = yield _getPoolsFromApi(network, poolType, isLiteChain);
-    const poolAddress = address.toLowerCase();
-    const poolEntry = poolData.find((data) => data.address.toLowerCase() === poolAddress);
-    return poolEntry ? String(poolEntry.usdTotal) : undefined;
-});
 export const _setPoolsFromApi = (network, isLiteChain, data) => _getCachedData.set(createCache(data), network, isLiteChain);
 export const _getAllPoolsFromApi = (network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
     const { poolLists } = yield _getCachedData(network, isLiteChain);
     return poolLists;
 });
+export const _getPoolTotalLiquidityFromApi = (network, address, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
+    const poolAddress = address.toLowerCase();
+    const poolLists = yield _getAllPoolsFromApi(network, isLiteChain);
+    for (const { poolData } of poolLists) {
+        const poolEntry = poolData.find((data) => data.address.toLowerCase() === poolAddress);
+        if (poolEntry)
+            return String(poolEntry.usdTotal);
+    }
+    return undefined;
+});
 export const _getUsdPricesFromApi = (network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
     const { usdPrices } = yield _getCachedData(network, isLiteChain);
     return usdPrices;

package/lib/constants/factory/stable.js

@@ -322,7 +322,7 @@ export const basePoolIdZapDictArbitrum = {
         address: "0x803A2B40c5a9BB2B86DD630B274Fa2A9202874C2".toLowerCase(),
         ABI: MetaZapFantomABI,
     },
-    "factory-v2-41": {
+    fraxbp: {
         address: "0x58AC91f5BE7dC0c35b24B96B19BAc55FBB8E705e".toLowerCase(),
         ABI: MetaZapFantomABI,
     },
@@ -332,7 +332,7 @@ export const basePoolIdZapDictOptimism = {
         address: "0x167e42a1c7ab4be03764a2222aac57f5f6754411".toLowerCase(),
         ABI: factoryDepositABI,
     },
-    "factory-v2-16": {
+    fraxbp: {
         address: "0x4244eB811D6e0Ef302326675207A95113dB4E1F8".toLowerCase(),
         ABI: MetaZapFantomABI,
     },

package/lib/constants/pools/arbitrum.js

@@ -32,6 +32,30 @@ export const POOLS_DATA_ARBITRUM = lowerCasePoolDataAddresses({
         swap_abi: twopoolSwapABI,
         gauge_abi: gaugeChildABI,
     },
+    fraxbp: {
+        name: "fraxbp",
+        full_name: "fraxbp",
+        symbol: "fraxbp",
+        reference_asset: "USD",
+        swap_address: '0xC9B8a3FDECB9D5b218d02555a8Baf332E5B740d5',
+        token_address: '0xC9B8a3FDECB9D5b218d02555a8Baf332E5B740d5',
+        gauge_address: '0x95285Ea6fF14F80A2fD3989a6bAb993Bd6b5fA13',
+        is_plain: true,
+        underlying_coins: ['FRAX', 'USDC.e'],
+        wrapped_coins: ['FRAX', 'USDC.e'],
+        underlying_coin_addresses: [
+            '0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F',
+            '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
+        ],
+        wrapped_coin_addresses: [
+            '0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F',
+            '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
+        ],
+        underlying_decimals: [18, 6],
+        wrapped_decimals: [18, 6],
+        swap_abi: twopoolSwapABI,
+        gauge_abi: gaugeChildABI,
+    },
     tricrypto: {
         name: "tricrypto",
         full_name: "tricrypto",

package/lib/constants/pools/avalanche.js

@@ -142,7 +142,7 @@ export const POOLS_DATA_AVALANCHE = lowerCasePoolDataAddresses({
         deposit_address: '0x9f2Fa7709B30c75047980a0d70A106728f0Ef2db',
         is_meta: true,
         is_crypto: true,
-        base_pool: 'factory-v2-99',
+        base_pool: '0x0974d9d3bc463fa17497aafc3a87535553298fbe',
         meta_coin_idx: 0,
         underlying_coins: ['USDC', 'USDt', 'BTC.b', 'AVAX'],
         wrapped_coins: ['2CRV', 'BTC.b', 'WAVAX'],

package/lib/constants/pools/optimism.js

@@ -1,5 +1,6 @@
 import { lowerCasePoolDataAddresses } from "../utils.js";
 import tripoolSwapABI from '../abis/3pool-optimism/swap.json' with { type: 'json' };
+import twopoolSwapABI from '../abis/2pool/swap.json' with { type: 'json' };
 import wstETHSwapABI from '../abis/wsteth/swap.json' with { type: 'json' };
 import gaugeChildABI from '../abis/gauge_child.json' with { type: 'json' };
 export const POOLS_DATA_OPTIMISM = lowerCasePoolDataAddresses({
@@ -29,6 +30,30 @@ export const POOLS_DATA_OPTIMISM = lowerCasePoolDataAddresses({
         swap_abi: tripoolSwapABI,
         gauge_abi: gaugeChildABI,
     },
+    fraxbp: {
+        name: "fraxbp",
+        full_name: "fraxbp",
+        symbol: "fraxbp",
+        reference_asset: 'USD',
+        is_plain: true,
+        swap_address: '0x29A3d66B30Bc4AD674A4FDAF27578B64f6afbFe7',
+        token_address: '0x29A3d66B30Bc4AD674A4FDAF27578B64f6afbFe7',
+        gauge_address: '0x4B960396011A914B4ccCC3b33DFEE83A97A9D766',
+        underlying_coins: ['FRAX', 'USDC.e'],
+        wrapped_coins: ['FRAX', 'USDC.e'],
+        underlying_coin_addresses: [
+            '0x2E3D870790dC77A83DD1d18184Acc7439A53f475',
+            '0x7F5c764cBc14f9669B88837ca1490cCa17c31607',
+        ],
+        wrapped_coin_addresses: [
+            '0x2E3D870790dC77A83DD1d18184Acc7439A53f475',
+            '0x7F5c764cBc14f9669B88837ca1490cCa17c31607',
+        ],
+        underlying_decimals: [18, 6],
+        wrapped_decimals: [18, 6],
+        swap_abi: twopoolSwapABI,
+        gauge_abi: gaugeChildABI,
+    },
     wsteth: {
         name: "wsteth",
         full_name: "wsteth",

package/lib/curve.js

@@ -12,6 +12,7 @@ import { Contract as MulticallContract, Provider as MulticallProvider } from "@c
 import { NETWORK_CONSTANTS } from "./constants/network_constants.js";
 import { CRYPTO_FACTORY_CONSTANTS, STABLE_FACTORY_CONSTANTS } from "./constants/factory/index.js";
 import { getFactoryPoolData } from "./factory/factory.js";
+import { getLastFactoryPoolIndex } from "./factory/common.js";
 import { getFactoryPoolsDataFromApi } from "./factory/factory-api.js";
 import { getCryptoFactoryPoolData } from "./factory/factory-crypto.js";
 import { getTricryptoFactoryPoolData } from "./factory/factory-tricrypto.js";
@@ -193,52 +194,52 @@ export class Curve {
         this.fetchNewFactoryPools = () => __awaiter(this, void 0, void 0, function* () {
             if (!("factory" in this.constants.ALIASES))
                 return [];
-            const currentPoolIds = Object.keys(this.constants.FACTORY_POOLS_DATA);
-            const lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
-            const poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, lastPoolIdx + 1));
+            const fromIdx = yield getLastFactoryPoolIndex.call(this, this.constants.ALIASES.factory);
+            const poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, fromIdx));
+            const newPoolIds = Object.keys(poolData).filter((id) => !(id in this.constants.FACTORY_POOLS_DATA));
             this.constants.FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.FACTORY_POOLS_DATA), poolData);
             this._updateDecimalsAndGauges(this.constants.FACTORY_POOLS_DATA);
-            return Object.keys(poolData);
+            return newPoolIds;
         });
         this.fetchNewCryptoFactoryPools = () => __awaiter(this, void 0, void 0, function* () {
             if (!("crypto_factory" in this.constants.ALIASES))
                 return [];
-            const currentPoolIds = Object.keys(this.constants.CRYPTO_FACTORY_POOLS_DATA);
-            const lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
-            const poolData = lowerCasePoolDataAddresses(yield getCryptoFactoryPoolData.call(this, lastPoolIdx + 1));
+            const fromIdx = yield getLastFactoryPoolIndex.call(this, this.constants.ALIASES.crypto_factory);
+            const poolData = lowerCasePoolDataAddresses(yield getCryptoFactoryPoolData.call(this, fromIdx));
+            const newPoolIds = Object.keys(poolData).filter((id) => !(id in this.constants.CRYPTO_FACTORY_POOLS_DATA));
             this.constants.CRYPTO_FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.CRYPTO_FACTORY_POOLS_DATA), poolData);
             this._updateDecimalsAndGauges(this.constants.CRYPTO_FACTORY_POOLS_DATA);
-            return Object.keys(poolData);
+            return newPoolIds;
         });
         this.fetchNewStableNgFactoryPools = () => __awaiter(this, void 0, void 0, function* () {
             if (!("stable_ng_factory" in this.constants.ALIASES))
                 return [];
-            const currentPoolIds = Object.keys(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
-            const lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[3]);
-            const poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, lastPoolIdx + 1, undefined, this.constants.ALIASES.stable_ng_factory));
+            const fromIdx = yield getLastFactoryPoolIndex.call(this, this.constants.ALIASES.stable_ng_factory);
+            const poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, fromIdx, undefined, this.constants.ALIASES.stable_ng_factory));
+            const newPoolIds = Object.keys(poolData).filter((id) => !(id in this.constants.STABLE_NG_FACTORY_POOLS_DATA));
             this.constants.STABLE_NG_FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.STABLE_NG_FACTORY_POOLS_DATA), poolData);
             this._updateDecimalsAndGauges(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
-            return Object.keys(poolData);
+            return newPoolIds;
         });
         this.fetchNewTwocryptoFactoryPools = () => __awaiter(this, void 0, void 0, function* () {
             if (!("twocrypto_factory" in this.constants.ALIASES))
                 return [];
-            const currentPoolIds = Object.keys(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA);
-            const lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
-            const poolData = lowerCasePoolDataAddresses(yield getTwocryptoFactoryPoolData.call(this, lastPoolIdx + 1));
+            const fromIdx = yield getLastFactoryPoolIndex.call(this, this.constants.ALIASES.twocrypto_factory);
+            const poolData = lowerCasePoolDataAddresses(yield getTwocryptoFactoryPoolData.call(this, fromIdx));
+            const newPoolIds = Object.keys(poolData).filter((id) => !(id in this.constants.TWOCRYPTO_FACTORY_POOLS_DATA));
             this.constants.TWOCRYPTO_FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.TWOCRYPTO_FACTORY_POOLS_DATA), poolData);
             this._updateDecimalsAndGauges(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA);
-            return Object.keys(poolData);
+            return newPoolIds;
         });
         this.fetchNewTricryptoFactoryPools = () => __awaiter(this, void 0, void 0, function* () {
             if (!("tricrypto_factory" in this.constants.ALIASES))
                 return [];
-            const currentPoolIds = Object.keys(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
-            const lastPoolIdx = currentPoolIds.length === 0 ? -1 : Number(currentPoolIds[currentPoolIds.length - 1].split("-")[2]);
-            const poolData = lowerCasePoolDataAddresses(yield getTricryptoFactoryPoolData.call(this, lastPoolIdx + 1));
+            const fromIdx = yield getLastFactoryPoolIndex.call(this, this.constants.ALIASES.tricrypto_factory);
+            const poolData = lowerCasePoolDataAddresses(yield getTricryptoFactoryPoolData.call(this, fromIdx));
+            const newPoolIds = Object.keys(poolData).filter((id) => !(id in this.constants.TRICRYPTO_FACTORY_POOLS_DATA));
             this.constants.TRICRYPTO_FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.TRICRYPTO_FACTORY_POOLS_DATA), poolData);
             this._updateDecimalsAndGauges(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
-            return Object.keys(poolData);
+            return newPoolIds;
         });
         this.fetchRecentlyDeployedFactoryPool = (poolAddress) => __awaiter(this, void 0, void 0, function* () {
             if (!("factory" in this.constants.ALIASES))

package/lib/external-api.js

@@ -13,7 +13,7 @@ import { getLiteDeploymentFromApi2, getLiteNetworksFromApi2, getLitePoolsFromApi
 // Core chains that ARE fully configured in the library (static POOLS_DATA / ALIASES /
 // implementationABIDict) but whose live pool data is NOT indexed by prices.curve.finance.
 // Their factory pools live in api2 instead, so we fetch from there while keeping them core
-// (static main/crypto pools + on-chain reconcile + impl-ABI dict all keep working).
+// (static main/crypto pools + impl-ABI dict all keep working).
 const API2_BACKED_CORE_CHAINS = ["avalanche"];
 const uncached_getPoolsFromApi = (network, poolType, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
     if (isLiteChain || API2_BACKED_CORE_CHAINS.includes(network))

package/lib/factory/common.d.ts

@@ -2,3 +2,4 @@ import { ICurve, IPoolDataShort } from "../interfaces";
 import { type Curve } from "../curve.js";
 export declare function setFactoryZapContracts(this: ICurve, isCrypto: boolean): void;
 export declare function getPoolIdByAddress(this: Curve, poolList: IPoolDataShort[], address: string): string;
+export declare function getLastFactoryPoolIndex(this: Curve, factoryAddress: string): Promise<number>;

package/lib/factory/common.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { getPoolIdBySwapAddress } from "../utils.js";
 export function setFactoryZapContracts(isCrypto) {
     var _a;
@@ -20,3 +29,10 @@ export function getPoolIdByAddress(poolList, address) {
         return getPoolIdBySwapAddress.call(this, address.toLowerCase());
     }
 }
+export function getLastFactoryPoolIndex(factoryAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const factoryContract = this.contracts[factoryAddress].contract;
+        const poolCount = Number(this.formatUnits(yield factoryContract.pool_count(this.constantOptions), 0));
+        return poolCount === 0 ? 0 : poolCount - 1;
+    });
+}

package/lib/factory/factory-api.js

@@ -17,44 +17,11 @@ import tricryptoFactorySwapABI from "../constants/abis/factory-tricrypto/factory
 import tricryptoFactoryEthDisabledSwapABI from "../constants/abis/factory-tricrypto/factory-tricrypto-pool-eth-disabled.json" with { type: "json" };
 import { getPoolIdByAddress, setFactoryZapContracts } from "./common.js";
 import { _getPoolsFromApi } from "../cached.js";
-import { assetTypeNameHandler, getPoolName, isStableNgPool } from "../utils.js";
+import { assetTypeNameHandler, getPoolName } from "../utils.js";
 import StableNgBasePoolZapABI from "../constants/abis/stable-ng-base-pool-zap.json" with { type: "json" };
 import MetaStableSwapNGABI from "../constants/abis/factory-stable-ng/meta-stableswap-ng.json" with { type: "json" };
 import PlainStableSwapNGABI from "../constants/abis/factory-stable-ng/plain-stableswap-ng.json" with { type: "json" };
 import { isYBPool } from "../constants/ybPools.js";
-const FACTORY_ALIAS_BY_TYPE = {
-    "factory": "factory",
-    "factory-crvusd": "crvusd_factory",
-    "factory-crypto": "crypto_factory",
-    "factory-twocrypto": "twocrypto_factory",
-    "factory-tricrypto": "tricrypto_factory",
-    "factory-stable-ng": "stable_ng_factory",
-};
-const ID_PREFIX_BY_FACTORY_TYPE = {
-    "factory": "factory-v2",
-    "factory-crvusd": "factory-crvusd",
-    "factory-crypto": "factory-crypto",
-    "factory-twocrypto": "factory-twocrypto",
-    "factory-tricrypto": "factory-tricrypto",
-    "factory-stable-ng": "factory-stable-ng",
-};
-function reconcilePoolIdsWithChain(poolList, factoryType) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const factoryAddress = this.constants.ALIASES[FACTORY_ALIAS_BY_TYPE[factoryType]];
-        const factoryMulticallContract = this.contracts[factoryAddress].multicallContract;
-        const poolCount = Number(this.formatUnits(yield this.contracts[factoryAddress].contract.pool_count(this.constantOptions), 0));
-        const calls = [];
-        for (let i = 0; i < poolCount; i++)
-            calls.push(factoryMulticallContract.pool_list(i));
-        const addresses = (yield this.multicallProvider.all(calls));
-        const indexByAddress = new Map();
-        addresses.forEach((address, i) => indexByAddress.set(address.toLowerCase(), i));
-        const prefix = ID_PREFIX_BY_FACTORY_TYPE[factoryType];
-        return poolList
-            .filter((pool) => indexByAddress.has(pool.address))
-            .map((pool) => (Object.assign(Object.assign({}, pool), { id: `${prefix}-${indexByAddress.get(pool.address)}` })));
-    });
-}
 export const lowerCasePoolDataAddresses = (poolsData) => {
     var _a;
     for (const poolData of poolsData) {
@@ -124,8 +91,7 @@ function setFactoryCoinsContracts(rawPoolList) {
 export function getFactoryPoolsDataFromApi(factoryType) {
     return __awaiter(this, void 0, void 0, function* () {
         const network = this.constants.NETWORK_NAME;
-        let rawPoolList = lowerCasePoolDataAddresses((yield _getPoolsFromApi(network, factoryType, this.isLiteChain)).poolData);
-        rawPoolList = yield reconcilePoolIdsWithChain.call(this, rawPoolList, factoryType);
+        const rawPoolList = lowerCasePoolDataAddresses((yield _getPoolsFromApi(network, factoryType, this.isLiteChain)).poolData);
         return buildFactoryPoolsData.call(this, factoryType, rawPoolList);
     });
 }
@@ -231,6 +197,7 @@ export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
                     deposit_abi: basePoolZap.ABI,
                     in_api: true,
                     is_ng,
+                    factory_type: factoryType,
                 };
             }
             else {
@@ -255,6 +222,7 @@ export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                     in_api: true,
                     is_ng,
+                    factory_type: factoryType,
                 };
             }
         }
@@ -270,7 +238,7 @@ export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
             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)) {
+            if (allPoolsData[basePoolId].is_ng) {
                 this.setContract(deposit_address, StableNgBasePoolZapABI);
             }
             else {
@@ -301,6 +269,7 @@ export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
                 deposit_abi,
                 in_api: true,
                 is_ng,
+                factory_type: factoryType,
             };
         }
         else {
@@ -325,6 +294,7 @@ export function buildFactoryPoolsData(factoryType, rawPoolListInput) {
                 gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                 in_api: true,
                 is_ng,
+                factory_type: factoryType,
             };
         }
     });

package/lib/factory/factory-crypto.js

@@ -20,7 +20,7 @@ function getRecentlyCreatedCryptoPoolId(swapAddress) {
         for (let i = 1; i <= poolCount; i++) {
             const address = yield factoryContract.pool_list(poolCount - i);
             if (address.toLowerCase() === swapAddress.toLowerCase())
-                return `factory-crypto-${poolCount - i}`;
+                return address.toLowerCase();
         }
         throw Error("Unknown pool");
     });
@@ -36,7 +36,7 @@ function getCryptoFactoryIdsAndSwapAddresses() {
         }
         if (calls.length === 0)
             return [[], []];
-        let factories = (yield this.multicallProvider.all(calls)).map((addr, i) => ({ id: `factory-crypto-${fromIdx + i}`, address: addr.toLowerCase() }));
+        let factories = (yield this.multicallProvider.all(calls)).map((addr) => ({ id: addr.toLowerCase(), address: addr.toLowerCase() }));
         const swapAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address.toLowerCase());
         factories = factories.filter((f) => !swapAddresses.includes(f.address));
         return [factories.map((f) => f.id), factories.map((f) => f.address)];
@@ -247,6 +247,7 @@ export function getCryptoFactoryPoolData() {
                     swap_abi: cryptoFactorySwapABI,
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                     deposit_abi: basePoolZap.ABI,
+                    factory_type: "factory-crypto",
                 };
             }
             else {
@@ -269,6 +270,7 @@ export function getCryptoFactoryPoolData() {
                     wrapped_decimals: [...coinAddresses[i].map((addr) => coinAddressDecimalsDict[addr])],
                     swap_abi: cryptoFactorySwapABI,
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
+                    factory_type: "factory-crypto",
                 };
             }
         }

package/lib/factory/factory-tricrypto.js

@@ -20,7 +20,7 @@ function getRecentlyCreatedCryptoPoolId(swapAddress) {
         for (let i = 1; i <= poolCount; i++) {
             const address = yield factoryContract.pool_list(poolCount - i);
             if (address.toLowerCase() === swapAddress.toLowerCase())
-                return `factory-tricrypto-${poolCount - i}`;
+                return address.toLowerCase();
         }
         throw Error("Unknown pool");
     });
@@ -36,7 +36,7 @@ function getCryptoFactoryIdsAndSwapAddresses() {
         }
         if (calls.length === 0)
             return [[], []];
-        let factories = (yield this.multicallProvider.all(calls)).map((addr, i) => ({ id: `factory-tricrypto-${fromIdx + i}`, address: addr.toLowerCase() }));
+        let factories = (yield this.multicallProvider.all(calls)).map((addr) => ({ id: addr.toLowerCase(), address: addr.toLowerCase() }));
         const swapAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address.toLowerCase());
         factories = factories.filter((f) => !swapAddresses.includes(f.address));
         return [factories.map((f) => f.id), factories.map((f) => f.address)];
@@ -215,6 +215,7 @@ export function getTricryptoFactoryPoolData() {
                 swap_abi: isETHEnabled ? tricryptoFactorySwapABI : tricryptoFactoryEthDisabledSwapABI,
                 gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                 is_ng: true,
+                factory_type: "factory-tricrypto",
             };
         }
         return TRICRYPTO_FACTORY_POOLS_DATA;

package/lib/factory/factory-twocrypto.js

@@ -21,7 +21,7 @@ function getRecentlyCreatedCryptoPoolId(swapAddress) {
         for (let i = 1; i <= poolCount; i++) {
             const address = yield factoryContract.pool_list(poolCount - i);
             if (address.toLowerCase() === swapAddress.toLowerCase())
-                return `factory-twocrypto-${poolCount - i}`;
+                return address.toLowerCase();
         }
         throw Error("Unknown pool");
     });
@@ -37,7 +37,7 @@ function getTwocryptoFactoryIdsAndSwapAddresses() {
         }
         if (calls.length === 0)
             return [[], []];
-        let factories = (yield this.multicallProvider.all(calls)).map((addr, i) => ({ id: `factory-twocrypto-${fromIdx + i}`, address: addr.toLowerCase() }));
+        let factories = (yield this.multicallProvider.all(calls)).map((addr) => ({ id: addr.toLowerCase(), address: addr.toLowerCase() }));
         const swapAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address.toLowerCase());
         factories = factories.filter((f) => !swapAddresses.includes(f.address));
         return [factories.map((f) => f.id), factories.map((f) => f.address)];
@@ -207,6 +207,7 @@ export function getTwocryptoFactoryPoolData() {
                 swap_abi: twocryptoFactorySwapABI,
                 gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                 is_ng: true,
+                factory_type: "factory-twocrypto",
             };
         }
         return TWOCRYPTO_FACTORY_POOLS_DATA;

package/lib/factory/factory.js

@@ -15,7 +15,7 @@ import factoryGaugeABI from "../constants/abis/gauge_factory.json" with { type:
 import gaugeChildABI from "../constants/abis/gauge_child.json" with { type: "json" };
 import StableNgBasePoolZapABI from "../constants/abis/stable-ng-base-pool-zap.json" with { type: "json" };
 import { getPoolIdByAddress, setFactoryZapContracts } from "./common.js";
-import { getPoolName, isStableNgPool } from "../utils.js";
+import { getPoolName } from "../utils.js";
 import { formatUnits } from "../constants/utils.js";
 export const BLACK_LIST = {
     1: [
@@ -61,12 +61,11 @@ export function getBasePools(factoryAddress, rawSwapAddresses, tmpPools) {
 function getRecentlyCreatedPoolId(swapAddress, factoryAddress) {
     return __awaiter(this, void 0, void 0, function* () {
         const factoryContract = this.contracts[factoryAddress].contract;
-        const prefix = factoryAddress === this.constants.ALIASES.factory ? 'factory-v2' : 'factory-stable-ng';
         const poolCount = Number(this.formatUnits(yield factoryContract.pool_count(this.constantOptions), 0));
         for (let i = 1; i <= poolCount; i++) {
             const address = yield factoryContract.pool_list(poolCount - i);
             if (address.toLowerCase() === swapAddress.toLowerCase())
-                return `${prefix}-${poolCount - i}`;
+                return address.toLowerCase();
         }
         throw Error("Unknown pool");
     });
@@ -84,9 +83,7 @@ function getFactoryIdsAndSwapAddresses() {
         }
         if (calls.length === 0)
             return [[], []];
-        const prefix = factoryAddress === this.constants.ALIASES.factory ? "factory-v2-" :
-            factoryAddress === this.constants.ALIASES.crvusd_factory ? "factory-crvusd-" : "factory-stable-ng-";
-        let factories = (yield this.multicallProvider.all(calls)).map((addr, i) => ({ id: prefix + (fromIdx + i), address: addr.toLowerCase() }));
+        let factories = (yield this.multicallProvider.all(calls)).map((addr) => ({ id: addr.toLowerCase(), address: addr.toLowerCase() }));
         const swapAddresses = Object.values(this.constants.POOLS_DATA).map((pool) => pool.swap_address.toLowerCase());
         const blacklist = (_a = BLACK_LIST[this.chainId]) !== null && _a !== void 0 ? _a : [];
         factories = factories.filter((f) => !swapAddresses.includes(f.address) && !blacklist.includes(f.address));
@@ -228,13 +225,15 @@ function getCoinsData(coinAddresses, existingCoinAddrNameDict, existingCoinAddrD
 }
 export function getFactoryPoolData() {
     return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, factoryAddress = this.constants.ALIASES.factory) {
-        var _a, _b, _c;
+        var _a, _b, _c, _e;
         const [rawPoolIds, rawSwapAddresses] = swapAddress ?
             [[yield getRecentlyCreatedPoolId.call(this, swapAddress, factoryAddress)], [swapAddress.toLowerCase()]]
             : yield getFactoryIdsAndSwapAddresses.call(this, fromIdx, factoryAddress);
         if (rawPoolIds.length === 0)
             return {};
         const is_ng = factoryAddress === this.constants.ALIASES.stable_ng_factory;
+        const factory_type = factoryAddress === this.constants.ALIASES.crvusd_factory ? "factory-crvusd" :
+            is_ng ? "factory-stable-ng" : "factory";
         const [rawImplementations, rawGauges, rawOldGauges, rawReferenceAssets, rawPoolSymbols, rawPoolNames, rawIsMeta, rawCoinAddresses] = yield getPoolsData.call(this, rawSwapAddresses, factoryAddress);
         const poolIds = [];
         const swapAddresses = [];
@@ -298,6 +297,7 @@ export function getFactoryPoolData() {
                     swap_abi: swapABIs[i],
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                     is_ng,
+                    factory_type,
                 };
             }
             else {
@@ -309,7 +309,7 @@ export function getFactoryPoolData() {
                 this.constants.BASE_POOLS[basePools.ids[i]] = this.constants.BASE_POOLS[basePools.ids[i]] ? this.constants.BASE_POOLS[basePools.ids[i]] + 1 : 1;
                 let deposit_address = (_c = this.constants.STABLE_FACTORY_CONSTANTS.stableNgBasePoolZap) !== null && _c !== void 0 ? _c : this.constants.ZERO_ADDRESS;
                 let deposit_abi = StableNgBasePoolZapABI;
-                if (isStableNgPool(basePools.ids[i])) {
+                if ((_e = allPoolsData[basePools.ids[i]]) === null || _e === void 0 ? void 0 : _e.is_ng) {
                     this.setContract(deposit_address, StableNgBasePoolZapABI);
                 }
                 else {
@@ -339,6 +339,7 @@ export function getFactoryPoolData() {
                     gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                     deposit_abi,
                     is_ng,
+                    factory_type,
                 };
             }
         }

package/lib/interfaces.d.ts

@@ -31,6 +31,7 @@ export interface IPoolData {
     is_factory?: boolean;
     is_llamma?: boolean;
     is_ng?: boolean;
+    factory_type?: IFactoryPoolType;
     base_pool?: string;
     meta_coin_idx?: number;
     underlying_coins: string[];

package/lib/lite-api.js

@@ -66,10 +66,10 @@ const _getApi2PoolsData = memoize((chainId) => __awaiter(void 0, void 0, void 0,
     promise: true,
     maxAge: 5 * 60 * 1000,
 });
-const adaptLitePool = (pool, poolType) => {
+const adaptLitePool = (pool) => {
     var _a, _b, _c, _d, _e, _f, _g;
     return ({
-        id: pool.id.replace(pool.registry_id, poolType),
+        id: pool.address.toLowerCase(),
         name: pool.name,
         symbol: pool.symbol,
         assetTypeName: null,
@@ -111,7 +111,7 @@ export const getLitePoolsFromApi2 = (network, poolType) => __awaiter(void 0, voi
         return { poolData: [], tvl: 0, tvlAll: 0 };
     const { pool_data, tvl } = yield _getApi2PoolsData(chainId);
     const poolsOfType = (pool_data !== null && pool_data !== void 0 ? pool_data : []).filter((pool) => API2_REGISTRY_TO_POOL_TYPE[pool.registry_id] === poolType);
-    const poolData = poolsOfType.map((pool) => adaptLitePool(pool, poolType));
+    const poolData = poolsOfType.map((pool) => adaptLitePool(pool));
     return {
         poolData,
         tvl: poolData.reduce((sum, p) => sum + p.usdTotal, 0),

package/lib/pools/PoolTemplate.js

@@ -757,7 +757,7 @@ export class PoolTemplate extends CorePool {
             const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
                 if (this.curve.isLiteChain) {
-                    const prices = this.id.includes('twocrypto')
+                    const prices = this.factoryType === 'factory-twocrypto'
                         ? [
                             1,
                             Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
@@ -1415,7 +1415,7 @@ export class PoolTemplate extends CorePool {
             const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
                 if (this.curve.isLiteChain) {
-                    const prices = this.id.includes('twocrypto')
+                    const prices = this.factoryType === 'factory-twocrypto'
                         ? [
                             1,
                             Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
@@ -1550,7 +1550,7 @@ export class PoolTemplate extends CorePool {
             const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
                 if (this.curve.isLiteChain) {
-                    const prices = this.id.includes('twocrypto')
+                    const prices = this.factoryType === 'factory-twocrypto'
                         ? [
                             1,
                             Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),

package/lib/pools/subClasses/corePool.d.ts

@@ -1,6 +1,6 @@
 import { type Curve } from "../../curve.js";
 import { IGaugePool } from "./gaugePool.js";
-import { IPoolData } from "../../interfaces";
+import { IFactoryPoolType, IPoolData } from "../../interfaces";
 export interface ICorePool {
     id: string;
     name: string;
@@ -23,6 +23,7 @@ export interface ICorePool {
     isMetaFactory: boolean;
     isNg: boolean;
     isLlamma: boolean;
+    factoryType: IFactoryPoolType | null;
     basePool: string;
     metaCoinIdx: number;
     underlyingCoins: string[];
@@ -57,6 +58,7 @@ export declare class CorePool implements ICorePool {
     isMetaFactory: boolean;
     isNg: boolean;
     isLlamma: boolean;
+    factoryType: IFactoryPoolType | null;
     basePool: string;
     metaCoinIdx: number;
     underlyingCoins: string[];

package/lib/pools/subClasses/corePool.js

@@ -27,6 +27,7 @@ export class CorePool {
         this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
         this.isNg = poolData.is_ng || false;
         this.isLlamma = poolData.is_llamma || false;
+        this.factoryType = poolData.factory_type || null;
         this.basePool = poolData.base_pool || '';
         this.metaCoinIdx = this.isMeta ? (_a = poolData.meta_coin_idx) !== null && _a !== void 0 ? _a : poolData.wrapped_coins.length - 1 : -1;
         this.underlyingCoins = poolData.underlying_coins;

package/lib/pools/subClasses/statsPool.js

@@ -107,7 +107,7 @@ export class StatsPool {
                 return stablecoinTvlBN.plus(collateralTvlBN).toString();
             }
             if (useApi) {
-                const totalLiquidity = yield _getPoolTotalLiquidityFromApi(curve.constants.NETWORK_NAME, this.pool.id, this.pool.address, this.pool.isCrypto, curve.isLiteChain);
+                const totalLiquidity = yield _getPoolTotalLiquidityFromApi(curve.constants.NETWORK_NAME, this.pool.address, curve.isLiteChain);
                 if (totalLiquidity !== undefined)
                     return totalLiquidity;
             }

package/lib/prices-api.js

@@ -28,16 +28,6 @@ export const PRICES_POOL_TYPE_TO_LEGACY = {
     stableswapng: "factory-stable-ng",
     twocryptong: "factory-twocrypto",
 };
-const ID_PREFIX_BY_POOL_TYPE = {
-    "main": "main",
-    "crypto": "crypto",
-    "factory": "factory-v2",
-    "factory-crvusd": "factory-crvusd",
-    "factory-crypto": "factory-crypto",
-    "factory-twocrypto": "factory-twocrypto",
-    "factory-tricrypto": "factory-tricrypto",
-    "factory-stable-ng": "factory-stable-ng",
-};
 function fetchJson(url) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -67,12 +57,11 @@ export const getGaugesOverview = () => __awaiter(void 0, void 0, void 0, functio
     const { gauges } = yield _getGaugesOverview();
     return gauges !== null && gauges !== void 0 ? gauges : [];
 });
-const getPoolId = (poolType, indexWithinType) => `${ID_PREFIX_BY_POOL_TYPE[poolType]}-${indexWithinType}`;
-const adaptPoolFromPricesApi = (pool, id, gaugeAddressByPoolAddress) => {
+const adaptPoolFromPricesApi = (pool, gaugeAddressByPoolAddress) => {
     var _a, _b, _c, _d, _e;
     const coins = [...pool.coins].sort((a, b) => a.pool_index - b.pool_index).slice(0, pool.n_coins);
     return {
-        id,
+        id: pool.address.toLowerCase(),
         name: pool.name,
         symbol: (_a = pool.lp_token_symbol) !== null && _a !== void 0 ? _a : pool.name,
         assetTypeName: null,
@@ -113,7 +102,7 @@ export const getPoolsFromPricesApi = (network, poolType) => __awaiter(void 0, vo
     const poolsOfType = chainData.data
         .filter((pool) => PRICES_POOL_TYPE_TO_LEGACY[pool.pool_type] === poolType)
         .sort((a, b) => a.creation_block_number - b.creation_block_number);
-    const poolData = poolsOfType.map((pool, i) => adaptPoolFromPricesApi(pool, getPoolId(poolType, i), gaugeAddressByPoolAddress));
+    const poolData = poolsOfType.map((pool) => adaptPoolFromPricesApi(pool, gaugeAddressByPoolAddress));
     return {
         poolData,
         tvl: poolData.reduce((sum, p) => sum + p.usdTotal, 0),

package/lib/router.js

@@ -27,10 +27,10 @@ export function setRouterBlacklist(blacklist) {
     delete this._getBestRoute;
 }
 function _getTVL(poolId_1, _a) {
-    return __awaiter(this, arguments, void 0, function* (poolId, { is_crypto, is_llamma, swap_address }) {
+    return __awaiter(this, arguments, void 0, function* (poolId, { is_llamma, swap_address }) {
         // LLAMMA liquidity must be calculated on-chain, even when the API has an entry.
         if (!is_llamma) {
-            const totalLiquidity = yield _getPoolTotalLiquidityFromApi(this.constants.NETWORK_NAME, poolId, swap_address, is_crypto !== null && is_crypto !== void 0 ? is_crypto : false, this.isLiteChain);
+            const totalLiquidity = yield _getPoolTotalLiquidityFromApi(this.constants.NETWORK_NAME, swap_address, this.isLiteChain);
             if (totalLiquidity !== undefined)
                 return Number(totalLiquidity);
         }

package/lib/utils.d.ts

@@ -102,7 +102,6 @@ export declare const findAbiFunction: (abi: Abi, methodName: string) => AbiFunct
 export declare const getCountArgsOfMethodByAbi: (abi: Abi, methodName: string) => number;
 export declare const findAbiSignature: (abi: Abi, methodName: string, signature: string) => AbiFunction | undefined;
 export declare const getPoolName: (name: string) => string;
-export declare const isStableNgPool: (name: string) => boolean;
 export declare const assetTypeNameHandler: (assetTypeName: string | null) => REFERENCE_ASSET;
 export declare function getBasePools(this: Curve): Promise<IBasePoolShortItem[]>;
 export declare function log(fnName: string, ...args: unknown[]): void;

package/lib/utils.js

@@ -779,7 +779,6 @@ export const getPoolName = (name) => {
         return separatedName[0].trim();
     }
 };
-export const isStableNgPool = (name) => name.includes('factory-stable-ng');
 export const assetTypeNameHandler = (assetTypeName) => {
     if (!assetTypeName || assetTypeName.toUpperCase() === 'UNKNOWN') {
         return 'OTHER';

package/package.json

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