@curvefi/api 2.72.2 → 2.72.4

package/README.md

@@ -1986,6 +1986,28 @@ import curve from "@curvefi/api";
 })()
 ```
 
+### Fetch a single pool by address from blockchain
+
+`curve.fetchPoolByAddress` fetches one factory pool by its swap address using only RPC (no API).
+It auto-detects which factory the pool belongs to, so you don't need to know the pool type in
+advance, and merges the pool into the corresponding pool data. It returns the pool id (which can
+be passed to `curve.getPool`). If the pool is already loaded it returns its id without any RPC call,
+and it throws if the address doesn't belong to any known factory.
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0 });
+
+    const poolId = await curve.fetchPoolByAddress("0xffb7f90354c496210c471459133da2e452d8138a");
+    // 0xffb7f90354c496210c471459133da2e452d8138a
+
+    const pool = curve.getPool(poolId);
+    // pool.name === "SWAN/WETH"
+})()
+```
+
 ### Deploy stable plain pool
 
 ```ts

package/lib/curve.d.ts

@@ -78,6 +78,10 @@ export declare class Curve implements ICurve {
     fetchRecentlyDeployedStableNgFactoryPool: (poolAddress: string) => Promise<string>;
     fetchRecentlyDeployedTwocryptoFactoryPool: (poolAddress: string) => Promise<string>;
     fetchRecentlyDeployedTricryptoFactoryPool: (poolAddress: string) => Promise<string>;
+    private _getRpcFactoryDescriptors;
+    private _detectPoolFactory;
+    private _findLoadedFactoryPoolId;
+    fetchPoolByAddress: (poolAddress: string) => Promise<string>;
     getMainPoolList: () => string[];
     getFactoryPoolList: () => string[];
     getCrvusdFactoryPoolList: () => string[];

package/lib/curve.js

@@ -281,6 +281,54 @@ export class Curve {
             this._updateDecimalsAndGauges(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
             return Object.keys(poolData)[0]; // id
         });
+        this.fetchPoolByAddress = (poolAddress) => __awaiter(this, void 0, void 0, function* () {
+            if (this.isNoRPC)
+                throw Error("curve.fetchPoolByAddress requires an RPC connection");
+            const swapAddress = poolAddress.toLowerCase();
+            const loaded = this._findLoadedFactoryPoolId(swapAddress);
+            if (loaded)
+                return loaded;
+            const descriptor = yield this._detectPoolFactory(swapAddress);
+            if (!descriptor)
+                throw Error(`Pool ${poolAddress} does not belong to any known factory`);
+            let poolData;
+            switch (descriptor.kind) {
+                case "factory":
+                    poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, 0, swapAddress, descriptor.factoryAddress, true));
+                    this.constants.FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.FACTORY_POOLS_DATA), poolData);
+                    this._updateDecimalsAndGauges(this.constants.FACTORY_POOLS_DATA);
+                    break;
+                case "factory-crvusd":
+                    poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, 0, swapAddress, descriptor.factoryAddress, true));
+                    this.constants.CRVUSD_FACTORY_POOLS_DATA = Object.assign(Object.assign({}, this.constants.CRVUSD_FACTORY_POOLS_DATA), poolData);
+                    this._updateDecimalsAndGauges(this.constants.CRVUSD_FACTORY_POOLS_DATA);
+                    break;
+                case "factory-stable-ng":
+                    poolData = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, 0, swapAddress, descriptor.factoryAddress, true));
+                    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);
+                    break;
+                case "factory-crypto":
+                    poolData = lowerCasePoolDataAddresses(yield getCryptoFactoryPoolData.call(this, 0, swapAddress, true));
+                    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);
+                    break;
+                case "factory-twocrypto":
+                    poolData = lowerCasePoolDataAddresses(yield getTwocryptoFactoryPoolData.call(this, 0, swapAddress, true));
+                    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);
+                    break;
+                case "factory-tricrypto":
+                    poolData = lowerCasePoolDataAddresses(yield getTricryptoFactoryPoolData.call(this, 0, swapAddress, true));
+                    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);
+                    break;
+            }
+            const id = Object.keys(poolData)[0];
+            if (!id)
+                throw Error(`Pool ${poolAddress} could not be loaded (unsupported implementation)`);
+            return id;
+        });
         this.getMainPoolList = () => Object.keys(this.constants.POOLS_DATA);
         this.getFactoryPoolList = () => Object.keys(this.constants.FACTORY_POOLS_DATA);
         this.getCrvusdFactoryPoolList = () => Object.keys(this.constants.CRVUSD_FACTORY_POOLS_DATA);
@@ -673,6 +721,54 @@ export class Curve {
         this.constants.DECIMALS = Object.assign(Object.assign({}, this.constants.DECIMALS), extractDecimals(pools));
         this.constants.GAUGES = [...this.constants.GAUGES, ...extractGauges.call(this, pools)];
     }
+    _getRpcFactoryDescriptors() {
+        const aliases = this.constants.ALIASES;
+        const descriptors = [
+            { kind: "factory-stable-ng", alias: "stable_ng_factory" },
+            { kind: "factory", alias: "factory" },
+            { kind: "factory-crvusd", alias: "crvusd_factory" },
+            { kind: "factory-crypto", alias: "crypto_factory" },
+            { kind: "factory-twocrypto", alias: "twocrypto_factory" },
+            { kind: "factory-tricrypto", alias: "tricrypto_factory" },
+        ];
+        return descriptors
+            .filter((d) => (d.alias in aliases) && aliases[d.alias] !== this.constants.ZERO_ADDRESS)
+            .map((d) => ({ kind: d.kind, factoryAddress: aliases[d.alias] }));
+    }
+    _detectPoolFactory(poolAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const descriptors = this._getRpcFactoryDescriptors();
+            const matches = yield Promise.all(descriptors.map((d) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const contract = (_a = this.contracts[d.factoryAddress]) === null || _a === void 0 ? void 0 : _a.contract;
+                if (!contract)
+                    return null;
+                try {
+                    const coins = yield contract.get_coins(poolAddress, this.constantOptions);
+                    return coins.some((c) => c !== this.constants.ZERO_ADDRESS) ? d : null;
+                }
+                catch (_b) {
+                    return null;
+                }
+            })));
+            return (_a = matches.find(Boolean)) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    _findLoadedFactoryPoolId(swapAddress) {
+        const dicts = [
+            this.constants.FACTORY_POOLS_DATA,
+            this.constants.CRVUSD_FACTORY_POOLS_DATA,
+            this.constants.STABLE_NG_FACTORY_POOLS_DATA,
+            this.constants.CRYPTO_FACTORY_POOLS_DATA,
+            this.constants.TWOCRYPTO_FACTORY_POOLS_DATA,
+            this.constants.TRICRYPTO_FACTORY_POOLS_DATA,
+        ];
+        for (const dict of dicts)
+            if (swapAddress in dict)
+                return swapAddress;
+        return null;
+    }
     setCustomFeeData(customFeeData) {
         this.feeData = Object.assign(Object.assign({}, this.feeData), customFeeData);
     }

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

@@ -1,2 +1,2 @@
 import { ICurve, IDict, IPoolData } from "../interfaces";
-export declare function getCryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string): Promise<IDict<IPoolData>>;
+export declare function getCryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string, skipRecentlyCreatedCheck?: boolean): Promise<IDict<IPoolData>>;

package/lib/factory/factory-crypto.js

@@ -193,10 +193,10 @@ function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, e
     });
 }
 export function getCryptoFactoryPoolData() {
-    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress) {
+    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, skipRecentlyCreatedCheck = false) {
         var _a, _b;
         const [poolIds, swapAddresses] = swapAddress ?
-            [[yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
+            [[skipRecentlyCreatedCheck ? swapAddress.toLowerCase() : yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
             : yield getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};

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

@@ -1,2 +1,2 @@
 import { ICurve, IDict, IPoolData } from "../interfaces";
-export declare function getTricryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string): Promise<IDict<IPoolData>>;
+export declare function getTricryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string, skipRecentlyCreatedCheck?: boolean): Promise<IDict<IPoolData>>;

package/lib/factory/factory-tricrypto.js

@@ -162,10 +162,10 @@ function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, e
     });
 }
 export function getTricryptoFactoryPoolData() {
-    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress) {
+    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, skipRecentlyCreatedCheck = false) {
         var _a;
         const [poolIds, swapAddresses] = swapAddress ?
-            [[yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
+            [[skipRecentlyCreatedCheck ? swapAddress.toLowerCase() : yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
             : yield getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};

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

@@ -1,2 +1,2 @@
 import { ICurve, IDict, IPoolData } from "../interfaces";
-export declare function getTwocryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string): Promise<IDict<IPoolData>>;
+export declare function getTwocryptoFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string, skipRecentlyCreatedCheck?: boolean): Promise<IDict<IPoolData>>;

package/lib/factory/factory-twocrypto.js

@@ -168,9 +168,9 @@ function getCoinsData(tokenAddresses, coinAddresses, existingCoinAddrNameDict, e
     });
 }
 export function getTwocryptoFactoryPoolData() {
-    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress) {
+    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, skipRecentlyCreatedCheck = false) {
         const [poolIds, swapAddresses] = swapAddress ?
-            [[yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
+            [[skipRecentlyCreatedCheck ? swapAddress.toLowerCase() : yield getRecentlyCreatedCryptoPoolId.call(this, swapAddress)], [swapAddress.toLowerCase()]]
             : yield getTwocryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};

package/lib/factory/factory.d.ts

@@ -7,4 +7,4 @@ export declare function getBasePools(this: Curve, factoryAddress: string, rawSwa
     ids: string[];
     addresses: string[];
 }>;
-export declare function getFactoryPoolData(this: Curve, fromIdx?: number, swapAddress?: string, factoryAddress?: string): Promise<IDict<IPoolData>>;
+export declare function getFactoryPoolData(this: Curve, fromIdx?: number, swapAddress?: string, factoryAddress?: string, skipRecentlyCreatedCheck?: boolean): Promise<IDict<IPoolData>>;

package/lib/factory/factory.js

@@ -224,10 +224,10 @@ function getCoinsData(coinAddresses, existingCoinAddrNameDict, existingCoinAddrD
     });
 }
 export function getFactoryPoolData() {
-    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, factoryAddress = this.constants.ALIASES.factory) {
+    return __awaiter(this, arguments, void 0, function* (fromIdx = 0, swapAddress, factoryAddress = this.constants.ALIASES.factory, skipRecentlyCreatedCheck = false) {
         var _a, _b, _c, _e;
         const [rawPoolIds, rawSwapAddresses] = swapAddress ?
-            [[yield getRecentlyCreatedPoolId.call(this, swapAddress, factoryAddress)], [swapAddress.toLowerCase()]]
+            [[skipRecentlyCreatedCheck ? swapAddress.toLowerCase() : yield getRecentlyCreatedPoolId.call(this, swapAddress, factoryAddress)], [swapAddress.toLowerCase()]]
             : yield getFactoryIdsAndSwapAddresses.call(this, fromIdx, factoryAddress);
         if (rawPoolIds.length === 0)
             return {};

package/lib/index.d.ts

@@ -75,6 +75,7 @@ export declare const createCurve: () => {
     getNetworkConstants: () => import("./interfaces.js").INetworkConstants;
     getIsLiteChain: () => boolean;
     isNoRPC: boolean;
+    fetchPoolByAddress: (poolAddress: string) => Promise<string>;
     factory: {
         fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
@@ -414,6 +415,7 @@ declare const _default: {
     getNetworkConstants: () => import("./interfaces.js").INetworkConstants;
     getIsLiteChain: () => boolean;
     isNoRPC: boolean;
+    fetchPoolByAddress: (poolAddress: string) => Promise<string>;
     factory: {
         fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;

package/lib/index.js

@@ -67,6 +67,7 @@ export const createCurve = () => {
         getNetworkConstants: _curve.getNetworkConstants.bind(_curve),
         getIsLiteChain: _curve.getIsLiteChain.bind(_curve),
         isNoRPC: _curve.isNoRPC,
+        fetchPoolByAddress: _curve.fetchPoolByAddress.bind(_curve),
         factory: {
             fetchPools: _curve.fetchFactoryPools.bind(_curve),
             fetchNewPools: _curve.fetchNewFactoryPools.bind(_curve),

package/lib/prices-api.d.ts

@@ -16,6 +16,7 @@ export interface IPricesGauge {
     gauge_weight: string;
     gauge_relative_weight: number;
     gauge_type: string;
+    creation_date: string;
 }
 export declare const getGaugesOverview: () => Promise<IPricesGauge[]>;
 export declare const getPoolsFromPricesApi: (network: INetworkName, poolType: IPoolType) => Promise<IExtendedPoolDataFromApi>;

package/lib/prices-api.js

@@ -45,15 +45,21 @@ const _getGaugesOverview = memoize(() => __awaiter(void 0, void 0, void 0, funct
     maxAge: 5 * 60 * 1000,
 });
 const getGaugeAddressByPoolAddress = (network) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+    var _a;
     const { gauges } = yield _getGaugesOverview();
-    const map = new Map();
+    const newestGaugeByPoolAddress = new Map();
     for (const gauge of gauges !== null && gauges !== void 0 ? gauges : []) {
-        if (((_a = gauge.pool) === null || _a === void 0 ? void 0 : _a.chain) !== network || gauge.gauge_type !== "Liquidity")
+        // LMCallback gauges reward LlamaLend borrowers who use this pool's LP token as collateral.
+        // LPs can't stake in them, so they must not replace the pool's real gauge.
+        if (((_a = gauge.pool) === null || _a === void 0 ? void 0 : _a.chain) !== network || gauge.gauge_type === "LMCallback")
             continue;
-        map.set(gauge.pool.address.toLowerCase(), ((_b = gauge.effective_address) !== null && _b !== void 0 ? _b : gauge.address).toLowerCase());
+        const poolAddress = gauge.pool.address.toLowerCase();
+        const current = newestGaugeByPoolAddress.get(poolAddress);
+        // A pool can have several gauges when one was redeployed, keep the newest instead of relying on API order.
+        if (!current || gauge.creation_date > current.creation_date)
+            newestGaugeByPoolAddress.set(poolAddress, gauge);
     }
-    return map;
+    return new Map(Array.from(newestGaugeByPoolAddress, ([poolAddress, gauge]) => { var _a; return [poolAddress, ((_a = gauge.effective_address) !== null && _a !== void 0 ? _a : gauge.address).toLowerCase()]; }));
 });
 export const getGaugesOverview = () => __awaiter(void 0, void 0, void 0, function* () {
     const { gauges } = yield _getGaugesOverview();

package/package.json

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