@curvefi/api 2.66.30 → 2.66.31

package/lib/pools/poolConstructor.js

@@ -1,27 +1,26 @@
-import { curve } from "../curve.js";
 import { PoolTemplate } from "./PoolTemplate.js";
-import { poolBalancesMetaMixin, poolBalancesLendingMixin } from "./mixins/poolBalancesMixin.js";
-import { depositBalancedAmountsMixin, depositBalancedAmountsCryptoMixin, depositWrappedBalancedAmountsMixin, depositWrappedBalancedAmountsCryptoMixin } from "./mixins/depositBalancedAmountsMixins.js";
-import { depositMetaFactoryMixin, depositCryptoMetaFactoryMixin, depositZapMixin, depositLendingOrCryptoMixin, depositPlainMixin } from "./mixins/depositMixins.js";
+import { poolBalancesLendingMixin, poolBalancesMetaMixin } from "./mixins/poolBalancesMixin.js";
+import { depositBalancedAmountsCryptoMixin, depositBalancedAmountsMixin, depositWrappedBalancedAmountsCryptoMixin, depositWrappedBalancedAmountsMixin, } from "./mixins/depositBalancedAmountsMixins.js";
+import { depositCryptoMetaFactoryMixin, depositLendingOrCryptoMixin, depositMetaFactoryMixin, depositPlainMixin, depositZapMixin, } from "./mixins/depositMixins.js";
 import { depositWrapped2argsMixin, depositWrapped3argsMixin } from "./mixins/depositWrappedMixins.js";
-import { withdrawExpectedMixin, withdrawExpectedLendingOrCryptoMixin, withdrawExpectedMetaMixin, withdrawWrappedExpectedMixin } from "./mixins/withdrawExpectedMixins.js";
-import { withdrawMetaFactoryMixin, withdrawCryptoMetaFactoryMixin, withdrawZapMixin, withdrawLendingOrCryptoMixin, withdrawPlainMixin } from "./mixins/withdrawMixins.js";
+import { withdrawExpectedLendingOrCryptoMixin, withdrawExpectedMetaMixin, withdrawExpectedMixin, withdrawWrappedExpectedMixin, } from "./mixins/withdrawExpectedMixins.js";
+import { withdrawCryptoMetaFactoryMixin, withdrawLendingOrCryptoMixin, withdrawMetaFactoryMixin, withdrawPlainMixin, withdrawZapMixin, } from "./mixins/withdrawMixins.js";
 import { withdrawWrapped2argsMixin, withdrawWrapped3argsMixin } from "./mixins/withdrawWrappedMixins.js";
-import { withdrawImbalanceMetaFactoryMixin, withdrawImbalanceZapMixin, withdrawImbalanceLendingMixin, withdrawImbalancePlainMixin } from "./mixins/withdrawImbalanceMixins.js";
-import { withdrawImbalanceWrapped2argsMixin, withdrawImbalanceWrapped3argsMixin } from "./mixins/withdrawImbalanceWrappedMixins.js";
-import { withdrawOneCoinExpectedMetaFactoryMixin, withdrawOneCoinExpectedZapMixin, withdrawOneCoinExpected3argsMixin, withdrawOneCoinExpected2argsMixin } from "./mixins/withdrawOneCoinExpectedMixins.js";
-import { withdrawOneCoinMetaFactoryMixin, withdrawOneCoinCryptoMetaFactoryMixin, withdrawOneCoinZapMixin, withdrawOneCoinLendingOrCryptoMixin, withdrawOneCoinPlainMixin } from "./mixins/withdrawOneCoinMixins.js";
-import { withdrawOneCoinWrappedExpected2argsMixin, withdrawOneCoinWrappedExpected3argsMixin } from "./mixins/withdrawOneCoinWrappedExpectedMixins.js";
-import { withdrawOneCoinWrappedLendingOrCryptoMixin, withdrawOneCoinWrappedMixin } from "./mixins/withdrawOneCoinWrappedMixins.js";
-import { swapTricrypto2Mixin, swapMetaFactoryMixin, swapCryptoMetaFactoryMixin, swapMixin } from "./mixins/swapMixins.js";
-import { swapWrappedExpectedAndApproveMixin, swapWrappedTricrypto2Mixin, swapWrappedMixin, swapWrappedRequiredMixin, } from "./mixins/swapWrappedMixins.js";
-import { getCountArgsOfMethodByAbi, findAbiSignature } from "../utils.js";
+import { withdrawImbalanceLendingMixin, withdrawImbalanceMetaFactoryMixin, withdrawImbalancePlainMixin, withdrawImbalanceZapMixin, } from "./mixins/withdrawImbalanceMixins.js";
+import { withdrawImbalanceWrapped2argsMixin, withdrawImbalanceWrapped3argsMixin, } from "./mixins/withdrawImbalanceWrappedMixins.js";
+import { withdrawOneCoinExpected2argsMixin, withdrawOneCoinExpected3argsMixin, withdrawOneCoinExpectedMetaFactoryMixin, withdrawOneCoinExpectedZapMixin, } from "./mixins/withdrawOneCoinExpectedMixins.js";
+import { withdrawOneCoinCryptoMetaFactoryMixin, withdrawOneCoinLendingOrCryptoMixin, withdrawOneCoinMetaFactoryMixin, withdrawOneCoinPlainMixin, withdrawOneCoinZapMixin, } from "./mixins/withdrawOneCoinMixins.js";
+import { withdrawOneCoinWrappedExpected2argsMixin, withdrawOneCoinWrappedExpected3argsMixin, } from "./mixins/withdrawOneCoinWrappedExpectedMixins.js";
+import { withdrawOneCoinWrappedLendingOrCryptoMixin, withdrawOneCoinWrappedMixin, } from "./mixins/withdrawOneCoinWrappedMixins.js";
+import { swapCryptoMetaFactoryMixin, swapMetaFactoryMixin, swapMixin, swapTricrypto2Mixin } from "./mixins/swapMixins.js";
+import { swapWrappedExpectedAndApproveMixin, swapWrappedMixin, swapWrappedRequiredMixin, swapWrappedTricrypto2Mixin, } from "./mixins/swapWrappedMixins.js";
+import { findAbiSignature, getCountArgsOfMethodByAbi } from "../utils.js";
 import { StatsPool } from "./subClasses/statsPool.js";
-export const getPool = (poolId) => {
-    const poolDummy = new PoolTemplate(poolId);
+export function getPool(poolId) {
+    const poolDummy = new PoolTemplate(poolId, this);
     class Pool extends PoolTemplate {
-        constructor(poolId) {
-            super(poolId);
+        constructor(poolId, curve) {
+            super(poolId, curve);
             this.stats = new StatsPool(this);
             this.configureStats(poolDummy);
         }
@@ -62,7 +61,7 @@ export const getPool = (poolId) => {
     else if (poolDummy.zap && poolId !== 'susd') {
         Object.assign(Pool.prototype, depositZapMixin);
     }
-    else if (getCountArgsOfMethodByAbi(curve.contracts[poolDummy.address].abi, 'add_liquidity') > 2) {
+    else if (getCountArgsOfMethodByAbi(this.contracts[poolDummy.address].abi, 'add_liquidity') > 2) {
         Object.assign(Pool.prototype, depositLendingOrCryptoMixin);
     }
     else {
@@ -99,7 +98,7 @@ export const getPool = (poolId) => {
     else if (poolDummy.zap && poolId !== 'susd') {
         Object.assign(Pool.prototype, withdrawZapMixin);
     }
-    else if (getCountArgsOfMethodByAbi(curve.contracts[poolDummy.address].abi, 'remove_liquidity') > 2) {
+    else if (getCountArgsOfMethodByAbi(this.contracts[poolDummy.address].abi, 'remove_liquidity') > 2) {
         Object.assign(Pool.prototype, withdrawLendingOrCryptoMixin);
     }
     else {
@@ -165,7 +164,7 @@ export const getPool = (poolId) => {
     else if (poolDummy.zap) { // including susd
         Object.assign(Pool.prototype, withdrawOneCoinZapMixin);
     }
-    else if (getCountArgsOfMethodByAbi(curve.contracts[poolDummy.address].abi, 'remove_liquidity_one_coin') > 3) {
+    else if (getCountArgsOfMethodByAbi(this.contracts[poolDummy.address].abi, 'remove_liquidity_one_coin') > 3) {
         Object.assign(Pool.prototype, withdrawOneCoinLendingOrCryptoMixin);
     }
     else {
@@ -190,11 +189,11 @@ export const getPool = (poolId) => {
         }
     }
     // swap and swapEstimateGas
-    if (findAbiSignature(curve.contracts[poolDummy.address].abi, 'exchange', 'uint256,uint256,uint256,uint256,bool') &&
-        !(curve.chainId === 100 && poolDummy.id === "tricrypto")) { // tricrypto2 (eth), tricrypto (arbitrum), avaxcrypto (avalanche); 100 is xDAI
+    if (findAbiSignature(this.contracts[poolDummy.address].abi, 'exchange', 'uint256,uint256,uint256,uint256,bool') &&
+        !(this.chainId === 100 && poolDummy.id === "tricrypto")) { // tricrypto2 (eth), tricrypto (arbitrum), avaxcrypto (avalanche); 100 is xDAI
         Object.assign(Pool.prototype, swapTricrypto2Mixin);
     }
-    else if (poolDummy.isMetaFactory && (getPool(poolDummy.basePool).isLending || getPool(poolDummy.basePool).isFake || poolDummy.isCrypto)) {
+    else if (poolDummy.isMetaFactory && (getPool.call(this, poolDummy.basePool).isLending || getPool.call(this, poolDummy.basePool).isFake || poolDummy.isCrypto)) {
         if (poolDummy.isCrypto) {
             Object.assign(Pool.prototype, swapCryptoMetaFactoryMixin);
         }
@@ -209,12 +208,12 @@ export const getPool = (poolId) => {
     if (!poolDummy.isPlain && !poolDummy.isFake) {
         Object.assign(Pool.prototype, swapWrappedExpectedAndApproveMixin);
         Object.assign(Pool.prototype, swapWrappedRequiredMixin);
-        if (findAbiSignature(curve.contracts[poolDummy.address].abi, 'exchange', 'uint256,uint256,uint256,uint256,bool')) { // tricrypto2 (eth), tricrypto (arbitrum)
+        if (findAbiSignature(this.contracts[poolDummy.address].abi, 'exchange', 'uint256,uint256,uint256,uint256,bool')) { // tricrypto2 (eth), tricrypto (arbitrum)
             Object.assign(Pool.prototype, swapWrappedTricrypto2Mixin);
         }
         else {
             Object.assign(Pool.prototype, swapWrappedMixin);
         }
     }
-    return new Pool(poolId);
-};
+    return new Pool(poolId, this);
+}

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

@@ -1,4 +1,6 @@
+import { type Curve } from "../../curve.js";
 import { IGaugePool } from "./gaugePool.js";
+import { IPoolData } from "../../interfaces";
 export interface ICorePool {
     id: string;
     name: string;
@@ -33,6 +35,7 @@ export interface ICorePool {
     inApi: boolean;
 }
 export declare class CorePool implements ICorePool {
+    readonly curve: Curve;
     id: string;
     name: string;
     fullName: string;
@@ -64,5 +67,5 @@ export declare class CorePool implements ICorePool {
     wrappedDecimals: number[];
     useLending: boolean[];
     inApi: boolean;
-    constructor(id: string);
+    constructor(id: string, poolData: IPoolData, curve: Curve);
 }

package/lib/pools/subClasses/corePool.js

@@ -1,13 +1,11 @@
-import { curve } from "../../curve.js";
 import { GaugePool } from "./gaugePool.js";
 export class CorePool {
-    constructor(id) {
+    constructor(id, poolData, curve) {
         var _a, _b;
-        const poolsData = curve.getPoolsData();
-        if (!poolsData[id]) {
-            throw new Error(`Pool ${id} not found. Available pools: ${Object.keys(poolsData).join(', ')}`);
+        this.curve = curve;
+        if (!poolData) {
+            throw new Error(`Pool data is required for pool ${id}`);
         }
-        const poolData = poolsData[id];
         this.id = id;
         this.name = poolData.name;
         this.fullName = poolData.full_name;
@@ -15,7 +13,7 @@ export class CorePool {
         this.referenceAsset = poolData.reference_asset;
         this.address = poolData.swap_address;
         this.lpToken = poolData.token_address;
-        this.gauge = new GaugePool(poolData.gauge_address, poolData.name);
+        this.gauge = new GaugePool(poolData.gauge_address, poolData.name, curve);
         this.zap = poolData.deposit_address || null;
         this.sRewardContract = poolData.sCurveRewards_address || null;
         this.rewardContract = poolData.reward_contract || null;

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

@@ -1,4 +1,5 @@
 import { IDict } from '../../interfaces.js';
+import { type Curve } from "../../curve.js";
 export interface IGaugePool {
     address: string;
     poolName: string;
@@ -17,14 +18,15 @@ export interface IGaugePool {
     };
 }
 export declare class GaugePool implements IGaugePool {
-    address: string;
-    poolName: string;
+    readonly address: string;
+    readonly poolName: string;
+    readonly curve: Curve;
     estimateGas: {
         addReward: (rewardToken: string, distributor: string) => Promise<number | number[]>;
         depositRewardApprove: (rewardToken: string, amount: number | string) => Promise<number | number[]>;
         depositReward: (rewardToken: string, amount: string | number, epoch: string | number) => Promise<number | number[]>;
     };
-    constructor(address: string, poolName: string);
+    constructor(address: string, poolName: string, curve: Curve);
     gaugeManager(): Promise<string>;
     gaugeDistributors(): Promise<IDict<string>>;
     gaugeVersion(): Promise<string | null>;

package/lib/pools/subClasses/gaugePool.js

@@ -7,10 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { curve } from "../../curve.js";
 import { DIGas, ensureAllowance, ensureAllowanceEstimateGas, getCoinsData, hasAllowance, mulBy1_3, parseUnits, smartNumber, } from "../../utils.js";
 export class GaugePool {
-    constructor(address, poolName) {
+    constructor(address, poolName, curve) {
+        this.address = address;
+        this.poolName = poolName;
+        this.curve = curve;
         this.address = address;
         this.poolName = poolName;
         this.estimateGas = {
@@ -21,6 +23,7 @@ export class GaugePool {
     }
     gaugeManager() {
         return __awaiter(this, void 0, void 0, function* () {
+            const curve = this.curve;
             if (!this.address || this.address === curve.constants.ZERO_ADDRESS) {
                 return curve.constants.ZERO_ADDRESS;
             }
@@ -28,7 +31,7 @@ export class GaugePool {
                 try {
                     return yield curve.contracts[this.address].contract.manager();
                 }
-                catch (e) {
+                catch (_a) {
                     return curve.constants.ZERO_ADDRESS;
                 }
             }
@@ -36,19 +39,18 @@ export class GaugePool {
     }
     gaugeDistributors() {
         return __awaiter(this, void 0, void 0, function* () {
-            const gaugeContract = yield curve.contracts[this.address].contract;
-            const gaugeMulticallContract = yield curve.contracts[this.address].multicallContract;
-            const rewardCount = Number(curve.formatUnits(yield gaugeContract.reward_count(curve.constantOptions), 0));
+            const { contract: gaugeContract, multicallContract: gaugeMulticallContract } = this.curve.contracts[this.address];
+            const rewardCount = Number(this.curve.formatUnits(yield gaugeContract.reward_count(this.curve.constantOptions), 0));
             let calls = [];
             for (let i = 0; i < rewardCount; i++) {
                 calls.push(gaugeMulticallContract.reward_tokens(i));
             }
-            const rewardTokens = yield curve.multicallProvider.all(calls);
+            const rewardTokens = yield this.curve.multicallProvider.all(calls);
             calls = [];
             for (let i = 0; i < rewardCount; i++) {
                 calls.push(gaugeMulticallContract.reward_data(rewardTokens[i]));
             }
-            const rewardData = yield curve.multicallProvider.all(calls);
+            const rewardData = yield this.curve.multicallProvider.all(calls);
             const gaugeDistributors = {};
             for (let i = 0; i < rewardCount; i++) {
                 gaugeDistributors[rewardTokens[i]] = rewardData[i].distributor;
@@ -58,6 +60,7 @@ export class GaugePool {
     }
     gaugeVersion() {
         return __awaiter(this, void 0, void 0, function* () {
+            const curve = this.curve;
             if (!this.address || this.address === curve.constants.ZERO_ADDRESS) {
                 return null;
             }
@@ -65,7 +68,7 @@ export class GaugePool {
                 try {
                     return yield curve.contracts[this.address].contract.version();
                 }
-                catch (e) {
+                catch (_a) {
                     return null;
                 }
             }
@@ -73,6 +76,7 @@ export class GaugePool {
     }
     _addReward(_reward_token_1, _distributor_1) {
         return __awaiter(this, arguments, void 0, function* (_reward_token, _distributor, estimateGas = false) {
+            const curve = this.curve;
             if (this.address !== curve.constants.ZERO_ADDRESS && this.address) {
                 const gas = yield curve.contracts[this.address].contract.add_reward.estimateGas(_reward_token, _distributor, Object.assign({}, curve.constantOptions));
                 if (estimateGas)
@@ -85,13 +89,11 @@ export class GaugePool {
     }
     addRewardEstimateGas(rewardToken, distributor) {
         return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
             return yield this._addReward(rewardToken, distributor, true);
         });
     }
     addReward(rewardToken, distributor) {
         return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
             return yield this._addReward(rewardToken, distributor);
         });
     }
@@ -104,25 +106,26 @@ export class GaugePool {
     }
     depositRewardIsApproved(rewardToken, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield hasAllowance([rewardToken], [amount], curve.signerAddress, this.address);
+            return yield hasAllowance.call(this.curve, [rewardToken], [amount], this.curve.signerAddress, this.address);
         });
     }
     depositRewardApproveEstimateGas(rewardToken, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield ensureAllowanceEstimateGas([rewardToken], [amount], this.address);
+            return yield ensureAllowanceEstimateGas.call(this.curve, [rewardToken], [amount], this.address);
         });
     }
     depositRewardApprove(rewardToken, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield ensureAllowance([rewardToken], [amount], this.address);
+            return yield ensureAllowance.call(this.curve, [rewardToken], [amount], this.address);
         });
     }
     _depositReward(rewardToken_1, amount_1, epoch_1) {
         return __awaiter(this, arguments, void 0, function* (rewardToken, amount, epoch, estimateGas = false) {
+            const curve = this.curve;
             if (!estimateGas)
-                yield ensureAllowance([rewardToken], [amount], this.address);
+                yield ensureAllowance.call(curve, [rewardToken], [amount], this.address);
             const contract = curve.contracts[this.address].contract;
-            const decimals = (yield getCoinsData(rewardToken))[0].decimals;
+            const decimals = (yield getCoinsData.call(curve, rewardToken))[0].decimals;
             const _amount = parseUnits(amount, decimals);
             const gas = yield contract.deposit_reward_token.estimateGas(rewardToken, _amount, epoch, Object.assign({}, curve.constantOptions));
             if (estimateGas)
@@ -133,13 +136,11 @@ export class GaugePool {
     }
     depositRewardEstimateGas(rewardToken, amount, epoch) {
         return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
             return yield this._depositReward(rewardToken, amount, epoch, true);
         });
     }
     depositReward(rewardToken, amount, epoch) {
         return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
             return yield this._depositReward(rewardToken, amount, epoch);
         });
     }

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

@@ -1,5 +1,6 @@
 import { IReward } from '../../interfaces.js';
 import { PoolTemplate } from "../PoolTemplate.js";
+import memoize from "memoizee";
 export interface IStatsParameters {
     lpTokenSupply: string;
     virtualPrice: string;
@@ -35,6 +36,7 @@ export declare class StatsPool implements IStatsPool {
     wrappedBalances(): Promise<string[]>;
     underlyingBalances(): Promise<string[]>;
     totalLiquidity: (useApi?: boolean) => Promise<string>;
+    totalLiquidityMemoized: ((useApi?: boolean) => Promise<string>) & memoize.Memoized<(useApi?: boolean) => Promise<string>>;
     volume: () => Promise<string>;
     baseApy: () => Promise<{
         day: string;

package/lib/pools/subClasses/statsPool.js

@@ -7,12 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { curve } from "../../curve.js";
 import { _getPoolsFromApi, _getCrvApyFromApi } from '../../cached.js';
 import { _getUsdRate, BN, toBN, _getRewardsFromApi, getVolumeApiController, } from '../../utils.js';
+import memoize from "memoizee";
 export class StatsPool {
     constructor(pool) {
         this.parameters = () => __awaiter(this, void 0, void 0, function* () {
+            const curve = this.pool.curve;
             const multicallContract = curve.contracts[this.pool.address].multicallContract;
             const lpMulticallContract = curve.contracts[this.pool.lpToken].multicallContract;
             const calls = [
@@ -45,7 +46,8 @@ export class StatsPool {
             try {
                 [_virtualPrice, _fee, _adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = (yield curve.multicallProvider.all(calls));
             }
-            catch (e) { // Empty pool
+            catch ( // Empty pool
+            _a) { // Empty pool
                 calls.shift();
                 if (this.pool.isCrypto) {
                     calls.shift();
@@ -84,6 +86,7 @@ export class StatsPool {
             return { lpTokenSupply, virtualPrice, fee, adminFee, A, future_A, initial_A, future_A_time, initial_A_time, gamma, priceOracle, priceScale };
         });
         this.totalLiquidity = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+            const curve = this.pool.curve;
             if (curve.chainId === 1 && this.pool.id === "crveth")
                 return "0";
             if (this.pool.isLlamma) {
@@ -96,7 +99,7 @@ export class StatsPool {
                     collateralContract.balanceOf(this.pool.address),
                     ammContract.admin_fees_y(),
                 ]);
-                const collateralRate = yield _getUsdRate(this.pool.underlyingCoinAddresses[1]);
+                const collateralRate = yield _getUsdRate.call(curve, this.pool.underlyingCoinAddresses[1]);
                 const stablecoinTvlBN = toBN(_balance_x).minus(toBN(_fee_x));
                 const collateralTvlBN = toBN(_balance_y).minus(toBN(_fee_y)).times(collateralRate);
                 return stablecoinTvlBN.plus(collateralTvlBN).toString();
@@ -108,7 +111,7 @@ export class StatsPool {
                     poolType = this.pool.id.replace(/-\d+$/, '');
                     poolType = poolType.replace(/-v2$/, '');
                 }
-                const poolsData = (yield _getPoolsFromApi(network, poolType, curve.isLiteChain)).poolData;
+                const poolsData = (yield _getPoolsFromApi.call(curve, network, poolType, curve.isLiteChain)).poolData;
                 try {
                     const totalLiquidity = poolsData.filter((data) => data.address.toLowerCase() === this.pool.address.toLowerCase())[0].usdTotal;
                     return String(totalLiquidity);
@@ -120,18 +123,23 @@ export class StatsPool {
             const balances = yield this.underlyingBalances();
             const promises = [];
             for (const addr of this.pool.underlyingCoinAddresses) {
-                promises.push(_getUsdRate(addr));
+                promises.push(_getUsdRate.call(curve, addr));
             }
             const prices = yield Promise.all(promises);
             const totalLiquidity = balances.reduce((liquidity, b, i) => liquidity + (Number(b) * prices[i]), 0);
             return totalLiquidity.toFixed(8);
         });
+        this.totalLiquidityMemoized = memoize(this.totalLiquidity.bind(this), {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
         this.volume = () => __awaiter(this, void 0, void 0, function* () {
+            const curve = this.pool.curve;
             if (curve.isLiteChain && curve.chainId !== 146) {
                 throw Error('This method is not supported for the lite version');
             }
             const network = curve.constants.NETWORK_NAME;
-            const { poolsData } = yield getVolumeApiController(network);
+            const { poolsData } = yield getVolumeApiController.call(curve, network);
             const poolData = poolsData.find((d) => d.address.toLowerCase() === this.pool.address);
             if (poolData) {
                 return poolData.volumeUSD.toString();
@@ -139,11 +147,12 @@ export class StatsPool {
             throw Error(`Can't get Volume for ${this.pool.name} (id: ${this.pool.id})`);
         });
         this.baseApy = () => __awaiter(this, void 0, void 0, function* () {
+            const curve = this.pool.curve;
             if (curve.isLiteChain && curve.chainId !== 146) {
                 throw Error('baseApy is not supported for the lite version');
             }
             const network = curve.constants.NETWORK_NAME;
-            const { poolsData } = yield getVolumeApiController(network);
+            const { poolsData } = yield getVolumeApiController.call(curve, network);
             const poolData = poolsData.find((d) => d.address.toLowerCase() === this.pool.address);
             if (poolData) {
                 return {
@@ -155,6 +164,7 @@ export class StatsPool {
         });
         this.tokenApy = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
             var _a;
+            const curve = this.pool.curve;
             if (curve.isLiteChain && curve.chainId !== 146) {
                 throw Error('tokenApy is not supported for the lite version');
             }
@@ -162,18 +172,19 @@ export class StatsPool {
                 throw Error(`${this.pool.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
             const isDisabledChain = [1313161554].includes(curve.chainId); // Disable Aurora
             if (useApi && !isDisabledChain) {
-                const crvAPYs = yield _getCrvApyFromApi();
+                const crvAPYs = yield _getCrvApyFromApi(curve.constants.NETWORK_NAME, curve.isLiteChain);
                 const poolCrvApy = (_a = crvAPYs[this.pool.gauge.address]) !== null && _a !== void 0 ? _a : [0, 0]; // new pools might be missing
                 return [poolCrvApy[0], poolCrvApy[1]];
             }
             return yield this.pool._calcTokenApy();
         });
         this.rewardsApy = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+            const curve = this.pool.curve;
             if (this.pool.gauge.address === curve.constants.ZERO_ADDRESS)
                 return [];
             const isDisabledChain = [1313161554].includes(curve.chainId); // Disable Aurora
             if (useApi && !isDisabledChain) {
-                const rewards = yield _getRewardsFromApi();
+                const rewards = yield _getRewardsFromApi.call(curve);
                 if (!rewards[this.pool.gauge.address])
                     return [];
                 return rewards[this.pool.gauge.address].map((r) => ({ gaugeAddress: r.gaugeAddress, tokenAddress: r.tokenAddress, symbol: r.symbol, apy: r.apy }));
@@ -185,7 +196,7 @@ export class StatsPool {
                 const lpTokenContract = curve.contracts[this.pool.lpToken].multicallContract;
                 const rewardContract = curve.contracts[this.pool.sRewardContract || this.pool.gauge.address].multicallContract;
                 const totalLiquidityUSD = yield this.totalLiquidity();
-                const rewardRate = yield _getUsdRate(rewardToken.token);
+                const rewardRate = yield _getUsdRate.call(curve, rewardToken.token);
                 const [rewardData, _stakedSupply, _totalSupply] = yield curve.multicallProvider.all([
                     rewardContract.reward_data(rewardToken.token),
                     gaugeContract.totalSupply(),
@@ -211,6 +222,7 @@ export class StatsPool {
     }
     wrappedBalances() {
         return __awaiter(this, void 0, void 0, function* () {
+            const curve = this.pool.curve;
             const contract = curve.contracts[this.pool.address].multicallContract;
             const calls = [];
             for (let i = 0; i < this.pool.wrappedCoins.length; i++)

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

@@ -8,8 +8,9 @@ export interface IWalletPool {
     allCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
 }
 export declare class WalletPool implements IWalletPool {
+    readonly curve: import("../../curve").Curve;
     private pool;
-    constructor(pool: PoolTemplate);
+    constructor(pool: PoolTemplate, curve?: import("../../curve").Curve);
     private _balances;
     balances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
     lpTokenBalances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;

package/lib/pools/subClasses/walletPool.js

@@ -7,10 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { curve } from "../../curve.js";
 import { _prepareAddresses, _getBalances, } from '../../utils.js';
 export class WalletPool {
-    constructor(pool) {
+    constructor(pool, curve = pool.curve) {
+        this.curve = curve;
         this._balances = (rawCoinNames, rawCoinAddresses, ...addresses) => __awaiter(this, void 0, void 0, function* () {
             const coinNames = [];
             const coinAddresses = [];
@@ -21,8 +21,8 @@ export class WalletPool {
                     coinAddresses.push(rawCoinAddresses[i]);
                 }
             }
-            addresses = _prepareAddresses(addresses);
-            const rawBalances = yield _getBalances(coinAddresses, addresses);
+            addresses = _prepareAddresses.call(this.curve, addresses);
+            const rawBalances = yield _getBalances.call(this.curve, coinAddresses, addresses);
             const balances = {};
             for (const address of addresses) {
                 balances[address] = {};
@@ -36,7 +36,7 @@ export class WalletPool {
     }
     balances(...addresses) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.pool.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.pool.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 return yield this._balances(['lpToken', ...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], [this.pool.lpToken, ...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], ...addresses);
             }
             else {
@@ -46,7 +46,7 @@ export class WalletPool {
     }
     lpTokenBalances(...addresses) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.pool.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.pool.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 return yield this._balances(['lpToken'], [this.pool.lpToken], ...addresses);
             }
             else {

package/lib/pools/utils.d.ts

@@ -1,13 +1,14 @@
 import { IDict } from "../interfaces";
-export declare const getUserPoolListByLiquidity: (address?: string) => Promise<string[]>;
-export declare const getUserLiquidityUSD: (pools: string[], address?: string) => Promise<string[]>;
-export declare const getUserPoolListByClaimable: (address?: string) => Promise<string[]>;
-export declare const getUserClaimable: (pools: string[], address?: string) => Promise<{
+import { type Curve } from "../curve.js";
+export declare function getUserPoolListByLiquidity(this: Curve, address?: string): Promise<string[]>;
+export declare function getUserLiquidityUSD(this: Curve, pools: string[], address?: string): Promise<string[]>;
+export declare function getUserPoolListByClaimable(this: Curve, address?: string): Promise<string[]>;
+export declare function getUserClaimable(this: Curve, pools: string[], address?: string): Promise<{
     token: string;
     symbol: string;
     amount: string;
     price: number;
 }[][]>;
-export declare const getUserPoolList: (address?: string, useApi?: boolean) => Promise<string[]>;
-export declare const _getAmplificationCoefficientsFromApi: () => Promise<IDict<number>>;
+export declare function getUserPoolList(this: Curve, address?: string, useApi?: boolean): Promise<string[]>;
+export declare function _getAmplificationCoefficientsFromApi(this: Curve): Promise<IDict<number>>;
 export declare const checkVyperVulnerability: (chainId: number, poolId: string, implementation: string | null) => boolean;