@curvefi/api 2.63.10 → 2.64.0

package/lib/pools/poolConstructor.js

@@ -16,16 +16,23 @@ import { withdrawOneCoinWrappedLendingOrCryptoMixin, withdrawOneCoinWrappedMixin
 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 { StatsPool } from "./subClasses/statsPool.js";
 export const getPool = (poolId) => {
     const poolDummy = new PoolTemplate(poolId);
     class Pool extends PoolTemplate {
-    }
-    // statsBalances
-    if (poolDummy.isMeta) {
-        Object.assign(Pool.prototype, poolBalancesMetaMixin);
-    }
-    else if (poolDummy.useLending.reduce((x, y) => x || y)) {
-        Object.assign(Pool.prototype, poolBalancesLendingMixin);
+        constructor(poolId) {
+            super(poolId);
+            this.stats = new StatsPool(this);
+            this.configureStats(poolDummy);
+        }
+        configureStats(poolDummy) {
+            if (poolDummy.isMeta) {
+                Object.assign(this.stats, poolBalancesMetaMixin);
+            }
+            else if (poolDummy.useLending.reduce((x, y) => x || y)) {
+                Object.assign(this.stats, poolBalancesLendingMixin);
+            }
+        }
     }
     // depositBalancedAmounts
     if (poolDummy.isCrypto) {

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

@@ -0,0 +1,68 @@
+import { IGaugePool } from "./gaugePool.js";
+export interface ICorePool {
+    id: string;
+    name: string;
+    fullName: string;
+    symbol: string;
+    referenceAsset: string;
+    address: string;
+    lpToken: string;
+    gauge: IGaugePool;
+    zap: string | null;
+    sRewardContract: string | null;
+    rewardContract: string | null;
+    implementation: string | null;
+    isPlain: boolean;
+    isLending: boolean;
+    isMeta: boolean;
+    isCrypto: boolean;
+    isFake: boolean;
+    isFactory: boolean;
+    isMetaFactory: boolean;
+    isNg: boolean;
+    isLlamma: boolean;
+    basePool: string;
+    metaCoinIdx: number;
+    underlyingCoins: string[];
+    wrappedCoins: string[];
+    underlyingCoinAddresses: string[];
+    wrappedCoinAddresses: string[];
+    underlyingDecimals: number[];
+    wrappedDecimals: number[];
+    useLending: boolean[];
+    inApi: boolean;
+}
+export declare class CorePool implements ICorePool {
+    id: string;
+    name: string;
+    fullName: string;
+    symbol: string;
+    referenceAsset: string;
+    address: string;
+    lpToken: string;
+    gauge: IGaugePool;
+    zap: string | null;
+    sRewardContract: string | null;
+    rewardContract: string | null;
+    implementation: string | null;
+    isPlain: boolean;
+    isLending: boolean;
+    isMeta: boolean;
+    isCrypto: boolean;
+    isFake: boolean;
+    isFactory: boolean;
+    isMetaFactory: boolean;
+    isNg: boolean;
+    isLlamma: boolean;
+    basePool: string;
+    metaCoinIdx: number;
+    underlyingCoins: string[];
+    wrappedCoins: string[];
+    underlyingCoinAddresses: string[];
+    wrappedCoinAddresses: string[];
+    underlyingDecimals: number[];
+    wrappedDecimals: number[];
+    useLending: boolean[];
+    inApi: boolean;
+    constructor(id: string);
+}

package/lib/pools/subClasses/corePool.js

@@ -0,0 +1,39 @@
+import { curve } from "../../curve.js";
+import { GaugePool } from "./gaugePool.js";
+export class CorePool {
+    constructor(id) {
+        var _a, _b;
+        const poolData = curve.getPoolsData()[id];
+        this.id = id;
+        this.name = poolData.name;
+        this.fullName = poolData.full_name;
+        this.symbol = poolData.symbol;
+        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.zap = poolData.deposit_address || null;
+        this.sRewardContract = poolData.sCurveRewards_address || null;
+        this.rewardContract = poolData.reward_contract || null;
+        this.implementation = poolData.implementation_address || null;
+        this.isPlain = poolData.is_plain || false;
+        this.isLending = poolData.is_lending || false;
+        this.isMeta = poolData.is_meta || false;
+        this.isCrypto = poolData.is_crypto || false;
+        this.isFake = poolData.is_fake || false;
+        this.isFactory = poolData.is_factory || false;
+        this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
+        this.isNg = poolData.is_ng || false;
+        this.isLlamma = poolData.is_llamma || false;
+        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;
+        this.wrappedCoins = poolData.wrapped_coins;
+        this.underlyingCoinAddresses = poolData.underlying_coin_addresses;
+        this.wrappedCoinAddresses = poolData.wrapped_coin_addresses;
+        this.underlyingDecimals = poolData.underlying_decimals;
+        this.wrappedDecimals = poolData.wrapped_decimals;
+        this.useLending = poolData.use_lending || poolData.underlying_coin_addresses.map(() => false);
+        this.inApi = (_b = poolData.in_api) !== null && _b !== void 0 ? _b : false;
+    }
+}

package/lib/pools/{gaugePool.d.ts → subClasses/gaugePool.d.ts}

@@ -1,4 +1,4 @@
-import { IDict } from '../interfaces';
+import { IDict } from '../../interfaces.js';
 export interface IGaugePool {
     address: string;
     poolName: string;

package/lib/pools/{gaugePool.js → subClasses/gaugePool.js}

@@ -7,8 +7,8 @@ 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";
+import { curve } from "../../curve.js";
+import { DIGas, ensureAllowance, ensureAllowanceEstimateGas, getCoinsData, hasAllowance, mulBy1_3, parseUnits, smartNumber, } from "../../utils.js";
 export class GaugePool {
     constructor(address, poolName) {
         this.address = address;

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

@@ -0,0 +1,45 @@
+import { IReward } from '../../interfaces.js';
+import { PoolTemplate } from "../PoolTemplate.js";
+export interface IStatsParameters {
+    lpTokenSupply: string;
+    virtualPrice: string;
+    fee: string;
+    adminFee: string;
+    A: string;
+    future_A?: string;
+    initial_A?: string;
+    future_A_time?: number;
+    initial_A_time?: number;
+    gamma?: string;
+    priceOracle?: string[];
+    priceScale?: string[];
+}
+export interface IStatsPool {
+    pool: PoolTemplate;
+    parameters(): Promise<IStatsParameters>;
+    underlyingBalances(): Promise<string[]>;
+    wrappedBalances(): Promise<string[]>;
+    totalLiquidity(useApi?: boolean): Promise<string>;
+    volume(): Promise<string>;
+    baseApy(): Promise<{
+        day: string;
+        week: string;
+    }>;
+    tokenApy(useApi?: boolean): Promise<[number, number]>;
+    rewardsApy(useApi?: boolean): Promise<IReward[]>;
+}
+export declare class StatsPool implements IStatsPool {
+    pool: PoolTemplate;
+    constructor(pool: PoolTemplate);
+    parameters: () => Promise<IStatsParameters>;
+    wrappedBalances(): Promise<string[]>;
+    underlyingBalances(): Promise<string[]>;
+    totalLiquidity: (useApi?: boolean) => Promise<string>;
+    volume: () => Promise<string>;
+    baseApy: () => Promise<{
+        day: string;
+        week: string;
+    }>;
+    tokenApy: (useApi?: boolean) => Promise<[baseApy: number, boostedApy: number]>;
+    rewardsApy: (useApi?: boolean) => Promise<IReward[]>;
+}

package/lib/pools/subClasses/statsPool.js

@@ -0,0 +1,227 @@
+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 { curve } from "../../curve.js";
+import { _getPoolsFromApi } from '../../external-api.js';
+import { _getUsdRate, BN, toBN, _getCrvApyFromApi, _getRewardsFromApi, getVolumeApiController, } from '../../utils.js';
+export class StatsPool {
+    constructor(pool) {
+        this.parameters = () => __awaiter(this, void 0, void 0, function* () {
+            const multicallContract = curve.contracts[this.pool.address].multicallContract;
+            const lpMulticallContract = curve.contracts[this.pool.lpToken].multicallContract;
+            const calls = [
+                multicallContract.get_virtual_price(),
+                multicallContract.fee(),
+                "admin_fee" in multicallContract ? multicallContract.admin_fee() : multicallContract.ADMIN_FEE(),
+                multicallContract.A(),
+                lpMulticallContract.totalSupply(),
+            ];
+            if (this.pool.isCrypto) {
+                calls.push(multicallContract.gamma());
+                if (this.pool.wrappedCoins.length === 2) {
+                    calls.push(multicallContract.price_oracle());
+                    calls.push(multicallContract.price_scale());
+                }
+                else {
+                    for (let i = 0; i < this.pool.wrappedCoins.length - 1; i++) {
+                        calls.push(multicallContract.price_oracle(i));
+                        calls.push(multicallContract.price_scale(i));
+                    }
+                }
+            }
+            const additionalCalls = this.pool.isCrypto ? [] : [multicallContract.future_A()];
+            if ('initial_A' in multicallContract) {
+                additionalCalls.push(multicallContract.initial_A(), multicallContract.future_A_time(), multicallContract.initial_A_time());
+            }
+            let _virtualPrice = curve.parseUnits("0");
+            let _fee = curve.parseUnits("0");
+            let _prices, _adminFee, _A, _lpTokenSupply, _gamma;
+            try {
+                [_virtualPrice, _fee, _adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = (yield curve.multicallProvider.all(calls));
+            }
+            catch (e) { // Empty pool
+                calls.shift();
+                if (this.pool.isCrypto) {
+                    calls.shift();
+                    [_adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = (yield curve.multicallProvider.all(calls));
+                }
+                else {
+                    [_fee, _adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = (yield curve.multicallProvider.all(calls));
+                }
+            }
+            const [virtualPrice, fee, adminFee, A, lpTokenSupply, gamma] = [
+                curve.formatUnits(_virtualPrice),
+                curve.formatUnits(_fee, 8),
+                curve.formatUnits(_adminFee * _fee),
+                curve.formatUnits(_A, 0),
+                curve.formatUnits(_lpTokenSupply),
+                _gamma ? curve.formatUnits(_gamma) : undefined,
+            ];
+            let priceOracle, priceScale;
+            if (this.pool.isCrypto) {
+                const prices = _prices.map((_p) => curve.formatUnits(_p));
+                priceOracle = [];
+                priceScale = [];
+                for (let i = 0; i < this.pool.wrappedCoins.length - 1; i++) {
+                    priceOracle.push(prices.shift());
+                    priceScale.push(prices.shift());
+                }
+            }
+            const A_PRECISION = curve.chainId === 1 && ['compound', 'usdt', 'y', 'busd', 'susd', 'pax', 'ren', 'sbtc', 'hbtc', '3pool'].includes(this.pool.id) ? 1 : 100;
+            const [_future_A, _initial_A, _future_A_time, _initial_A_time] = yield curve.multicallProvider.all(additionalCalls);
+            const [future_A, initial_A, future_A_time, initial_A_time] = [
+                _future_A ? String(Number(curve.formatUnits(_future_A, 0)) / A_PRECISION) : undefined,
+                _initial_A ? String(Number(curve.formatUnits(_initial_A, 0)) / A_PRECISION) : undefined,
+                _future_A_time ? Number(curve.formatUnits(_future_A_time, 0)) * 1000 : undefined,
+                _initial_A_time ? Number(curve.formatUnits(_initial_A_time, 0)) * 1000 : undefined,
+            ];
+            return { lpTokenSupply, virtualPrice, fee, adminFee, A, future_A, initial_A, future_A_time, initial_A_time, gamma, priceOracle, priceScale };
+        });
+        this.totalLiquidity = (useApi = true) => __awaiter(this, void 0, void 0, function* () {
+            if (curve.chainId === 1 && this.pool.id === "crveth")
+                return "0";
+            if (this.pool.isLlamma) {
+                const stablecoinContract = curve.contracts[this.pool.underlyingCoinAddresses[0]].multicallContract;
+                const collateralContract = curve.contracts[this.pool.underlyingCoinAddresses[1]].multicallContract;
+                const ammContract = curve.contracts[this.pool.address].multicallContract;
+                const [_balance_x, _fee_x, _balance_y, _fee_y] = yield curve.multicallProvider.all([
+                    stablecoinContract.balanceOf(this.pool.address),
+                    ammContract.admin_fees_x(),
+                    collateralContract.balanceOf(this.pool.address),
+                    ammContract.admin_fees_y(),
+                ]);
+                const collateralRate = yield _getUsdRate(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();
+            }
+            if (useApi) {
+                const network = curve.constants.NETWORK_NAME;
+                let poolType = this.pool.isCrypto ? "crypto" : "main";
+                if (this.pool.id.startsWith("factory")) {
+                    poolType = this.pool.id.replace(/-\d+$/, '');
+                    poolType = poolType.replace(/-v2$/, '');
+                }
+                const poolsData = (yield _getPoolsFromApi(network, poolType)).poolData;
+                try {
+                    const totalLiquidity = poolsData.filter((data) => data.address.toLowerCase() === this.pool.address.toLowerCase())[0].usdTotal;
+                    return String(totalLiquidity);
+                }
+                catch (err) {
+                    console.log(this.pool.id, err.message);
+                }
+            }
+            const balances = yield this.underlyingBalances();
+            const promises = [];
+            for (const addr of this.pool.underlyingCoinAddresses) {
+                promises.push(_getUsdRate(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.volume = () => __awaiter(this, void 0, void 0, function* () {
+            if (curve.isLiteChain) {
+                throw Error('This method is not supported for the lite version');
+            }
+            const network = curve.constants.NETWORK_NAME;
+            const { poolsData } = yield getVolumeApiController(network);
+            const poolData = poolsData.find((d) => d.address.toLowerCase() === this.pool.address);
+            if (poolData) {
+                return poolData.volumeUSD.toString();
+            }
+            throw Error(`Can't get Volume for ${this.pool.name} (id: ${this.pool.id})`);
+        });
+        this.baseApy = () => __awaiter(this, void 0, void 0, function* () {
+            if (curve.isLiteChain) {
+                throw Error('baseApy is not supported for the lite version');
+            }
+            const network = curve.constants.NETWORK_NAME;
+            const { poolsData } = yield getVolumeApiController(network);
+            const poolData = poolsData.find((d) => d.address.toLowerCase() === this.pool.address);
+            if (poolData) {
+                return {
+                    day: poolData.day.toString(),
+                    week: poolData.week.toString(),
+                };
+            }
+            throw Error(`Can't get base APY for ${this.pool.name} (id: ${this.pool.id})`);
+        });
+        this.tokenApy = (useApi = true) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (curve.isLiteChain) {
+                throw Error('tokenApy is not supported for the lite version');
+            }
+            if (this.pool.rewardsOnly())
+                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 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 = (useApi = true) => __awaiter(this, void 0, void 0, function* () {
+            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();
+                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 }));
+            }
+            const apy = [];
+            const rewardTokens = yield this.pool.rewardTokens(false);
+            for (const rewardToken of rewardTokens) {
+                const gaugeContract = curve.contracts[this.pool.gauge.address].multicallContract;
+                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 [rewardData, _stakedSupply, _totalSupply] = yield curve.multicallProvider.all([
+                    rewardContract.reward_data(rewardToken.token),
+                    gaugeContract.totalSupply(),
+                    lpTokenContract.totalSupply(),
+                ]);
+                const stakedSupplyBN = toBN(_stakedSupply);
+                const totalSupplyBN = toBN(_totalSupply);
+                const inflationBN = toBN(rewardData.rate, rewardToken.decimals);
+                const periodFinish = Number(curve.formatUnits(rewardData.period_finish, 0)) * 1000;
+                const baseApy = periodFinish > Date.now() ?
+                    inflationBN.times(31536000).times(rewardRate).div(stakedSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)) :
+                    BN(0);
+                apy.push({
+                    gaugeAddress: this.pool.gauge.address,
+                    tokenAddress: rewardToken.token,
+                    symbol: rewardToken.symbol,
+                    apy: baseApy.times(100).toNumber(),
+                });
+            }
+            return apy;
+        });
+        this.pool = pool;
+    }
+    wrappedBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = curve.contracts[this.pool.address].multicallContract;
+            const calls = [];
+            for (let i = 0; i < this.pool.wrappedCoins.length; i++)
+                calls.push(contract.balances(i));
+            const _wrappedBalances = yield curve.multicallProvider.all(calls);
+            return _wrappedBalances.map((_b, i) => curve.formatUnits(_b, this.pool.wrappedDecimals[i]));
+        });
+    }
+    underlyingBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.wrappedBalances();
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+import { IDict } from '../../interfaces';
+import { PoolTemplate } from "../PoolTemplate";
+export interface IWalletPool {
+    balances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+    lpTokenBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+    underlyingCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+    wrappedCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+    allCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+}
+export declare class WalletPool implements IWalletPool {
+    private pool;
+    constructor(pool: PoolTemplate);
+    private _balances;
+    balances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
+    lpTokenBalances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
+    underlyingCoinBalances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
+    wrappedCoinBalances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
+    allCoinBalances(...addresses: string[] | string[][]): Promise<IDict<IDict<string>> | IDict<string>>;
+}

package/lib/pools/subClasses/walletPool.js

@@ -0,0 +1,72 @@
+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 { curve } from "../../curve.js";
+import { _prepareAddresses, _getBalances, } from '../../utils.js';
+export class WalletPool {
+    constructor(pool) {
+        this._balances = (rawCoinNames, rawCoinAddresses, ...addresses) => __awaiter(this, void 0, void 0, function* () {
+            const coinNames = [];
+            const coinAddresses = [];
+            // removing duplicates
+            for (let i = 0; i < rawCoinAddresses.length; i++) {
+                if (!coinAddresses.includes(rawCoinAddresses[i])) {
+                    coinNames.push(rawCoinNames[i]);
+                    coinAddresses.push(rawCoinAddresses[i]);
+                }
+            }
+            addresses = _prepareAddresses(addresses);
+            const rawBalances = yield _getBalances(coinAddresses, addresses);
+            const balances = {};
+            for (const address of addresses) {
+                balances[address] = {};
+                for (const coinName of coinNames) {
+                    balances[address][coinName] = rawBalances[address].shift();
+                }
+            }
+            return addresses.length === 1 ? balances[addresses[0]] : balances;
+        });
+        this.pool = pool;
+    }
+    balances(...addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pool.gauge.address === 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 {
+                return yield this._balances(['lpToken', 'gauge', ...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], [this.pool.lpToken, this.pool.gauge.address, ...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], ...addresses);
+            }
+        });
+    }
+    lpTokenBalances(...addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pool.gauge.address === curve.constants.ZERO_ADDRESS) {
+                return yield this._balances(['lpToken'], [this.pool.lpToken], ...addresses);
+            }
+            else {
+                return yield this._balances(['lpToken', 'gauge'], [this.pool.lpToken, this.pool.gauge.address], ...addresses);
+            }
+        });
+    }
+    underlyingCoinBalances(...addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._balances(this.pool.underlyingCoinAddresses, this.pool.underlyingCoinAddresses, ...addresses);
+        });
+    }
+    wrappedCoinBalances(...addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._balances(this.pool.wrappedCoinAddresses, this.pool.wrappedCoinAddresses, ...addresses);
+        });
+    }
+    allCoinBalances(...addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._balances([...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], [...this.pool.underlyingCoinAddresses, ...this.pool.wrappedCoinAddresses], ...addresses);
+        });
+    }
+}

package/lib/pools/utils.d.ts

@@ -10,3 +10,4 @@ export declare const getUserClaimable: (pools: string[], address?: string) => Pr
 }[][]>;
 export declare const getUserPoolList: (address?: string, useApi?: boolean) => Promise<string[]>;
 export declare const _getAmplificationCoefficientsFromApi: () => Promise<IDict<number>>;
+export declare const checkVyperVulnerability: (chainId: number, poolId: string, implementation: string | null) => boolean;

package/lib/pools/utils.js

@@ -328,3 +328,39 @@ export const _getAmplificationCoefficientsFromApi = () => __awaiter(void 0, void
     }
     return amplificationCoefficientDict;
 });
+export const checkVyperVulnerability = (chainId, poolId, implementation) => {
+    var _a, _b;
+    if (chainId === 1 && poolId === "crveth")
+        return true;
+    if (chainId === 42161 && poolId === "tricrypto")
+        return true;
+    const vulnerableImplementations = {
+        1: [
+            "0x6326DEbBAa15bCFE603d831e7D75f4fc10d9B43E",
+            "0x8c1aB78601c259E1B43F19816923609dC7d7de9B",
+            "0x88855cdF2b0A8413D470B86952E726684de915be",
+        ].map((a) => a.toLowerCase()),
+        137: [
+            "0xAe00f57663F4C85FC948B13963cd4627dAF01061",
+            "0xA9134FaE98F92217f457918505375Ae91fdc5e3c",
+            "0xf31bcdf0B9a5eCD7AB463eB905551fBc32e51856",
+        ].map((a) => a.toLowerCase()),
+        250: [
+            "0xE6358f6a45B502477e83CC1CDa759f540E4459ee",
+            "0x5d58Eb45e97B43e471AF05cD2b11CeB4106E1b1a",
+            "0xb11Dc44A9f981fAF1669dca6DD40c3cc2554A2ce",
+        ].map((a) => a.toLowerCase()),
+        42161: [
+            "0x7DA64233Fefb352f8F501B357c018158ED8aA455",
+            "0xAAe75FAebCae43b9d541Fd875622BE48D9B4f5D0",
+            "0x89287c32c2CAC1C76227F6d300B2DBbab6b75C08",
+        ].map((a) => a.toLowerCase()),
+        43114: [
+            "0x64448B78561690B70E17CBE8029a3e5c1bB7136e",
+            "0xF1f85a74AD6c64315F85af52d3d46bF715236ADc",
+            "0x0eb0F1FaF5F509Ac53fA224477509EAD167cf410",
+        ].map((a) => a.toLowerCase()),
+    };
+    const implementations = (_a = vulnerableImplementations[chainId]) !== null && _a !== void 0 ? _a : [];
+    return implementations.includes((_b = implementation === null || implementation === void 0 ? void 0 : implementation.toLowerCase()) !== null && _b !== void 0 ? _b : "");
+};

package/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { Abi, AbiFunction, IBasePoolShortItem, IChainId, IDict, INetworkName, IRewardFromApi, IVolumeAndAPYs, REFERENCE_ASSET } from './interfaces';
+import { Abi, AbiFunction, IBasePoolShortItem, IChainId, ICurveLiteNetwork, IDict, INetworkName, IRewardFromApi, IVolumeAndAPYs, REFERENCE_ASSET } from './interfaces';
 export declare const ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 export declare const MAX_ALLOWANCE: bigint;
 export declare const _cutZeros: (strn: string) => string;
@@ -70,3 +70,12 @@ export declare function log(fnName: string, ...args: unknown[]): void;
 export declare function runWorker<In extends {
     type: string;
 }, Out>(code: string, syncFn: () => ((val: In) => Out) | undefined, inputData: In, timeout?: number): Promise<Out>;
+export declare const getCurveLiteNetworks: () => Promise<ICurveLiteNetwork[]>;
+export declare const getNetworkNameByChainId: (chainId: number, networks: ICurveLiteNetwork[]) => string;
+export declare const getNetworkConstants: (chainId: IChainId | number, isLiteChain: boolean) => Promise<any>;
+export declare const PERIODS: {
+    DAY: number;
+    WEEK: number;
+    MONTH: number;
+    YEAR: number;
+};