@curvefi/api 2.52.4 → 2.53.0

package/lib/external-api.d.ts

@@ -1,5 +1,5 @@
 import memoize from "memoizee";
-import { IExtendedPoolDataFromApi, ISubgraphPoolData, IDict, INetworkName, IPoolType } from "./interfaces";
+import { IExtendedPoolDataFromApi, ISubgraphPoolData, IDict, INetworkName, IPoolType, IGaugesDataFromApi, IDaoProposal, IDaoProposalListItem } from "./interfaces";
 export declare const _getPoolsFromApi: ((network: INetworkName, poolType: IPoolType) => Promise<IExtendedPoolDataFromApi>) & memoize.Memoized<(network: INetworkName, poolType: IPoolType) => Promise<IExtendedPoolDataFromApi>>;
 export declare const _getAllPoolsFromApi: (network: INetworkName) => Promise<IExtendedPoolDataFromApi[]>;
 export declare const _getSubgraphData: ((network: INetworkName) => Promise<{
@@ -35,15 +35,7 @@ export declare const _getFactoryAPYsAndVolumes: ((network: string) => Promise<{
     apy: number;
     volume: number;
 }[]>>;
-export declare const _getAllGauges: (() => Promise<IDict<{
-    gauge: string;
-    is_killed?: boolean;
-    gaugeStatus?: Record<string, boolean> | null;
-}>>) & memoize.Memoized<() => Promise<IDict<{
-    gauge: string;
-    is_killed?: boolean;
-    gaugeStatus?: Record<string, boolean> | null;
-}>>>;
+export declare const _getAllGauges: (() => Promise<IDict<IGaugesDataFromApi>>) & memoize.Memoized<() => Promise<IDict<IGaugesDataFromApi>>>;
 export declare const _getHiddenPools: (() => Promise<IDict<string[]>>) & memoize.Memoized<() => Promise<IDict<string[]>>>;
 export declare const _generateBoostingProof: ((block: number, address: string) => Promise<{
     block_header_rlp: string;
@@ -52,3 +44,5 @@ export declare const _generateBoostingProof: ((block: number, address: string) =
     block_header_rlp: string;
     proof_rlp: string;
 }>>;
+export declare const _getDaoProposalList: (() => Promise<IDaoProposalListItem[]>) & memoize.Memoized<() => Promise<IDaoProposalListItem[]>>;
+export declare const _getDaoProposal: ((type: "PARAMETER" | "OWNERSHIP", id: number) => Promise<IDaoProposal>) & memoize.Memoized<(type: "PARAMETER" | "OWNERSHIP", id: number) => Promise<IDaoProposal>>;

package/lib/external-api.js

@@ -186,3 +186,36 @@ export var _generateBoostingProof = memoize(function (block, address) { return _
     promise: true,
     maxAge: 5 * 60 * 1000, // 5m
 });
+// --- DAO ---
+export var _getDaoProposalList = memoize(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var url, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                url = "https://api-py.llama.airforce/curve/v1/dao/proposals";
+                return [4 /*yield*/, axios.get(url, { validateStatus: function () { return true; } })];
+            case 1:
+                response = _a.sent();
+                return [2 /*return*/, response.data.proposals];
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});
+export var _getDaoProposal = memoize(function (type, id) { return __awaiter(void 0, void 0, void 0, function () {
+    var url, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                url = "https://api-py.llama.airforce/curve/v1/dao/proposals/".concat(type.toLowerCase(), "/").concat(id);
+                return [4 /*yield*/, axios.get(url, { validateStatus: function () { return true; } })];
+            case 1:
+                response = _a.sent();
+                return [2 /*return*/, response.data];
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});

package/lib/index.d.ts

@@ -99,8 +99,14 @@ declare const curve: {
         getPoolList: () => string[];
         deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<ethers.ContractTransactionResponse>;
         deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, offpegFeeMultiplier: string | number, emaTime: number, implementationIdx: 0, assetType: 0 | 1 | 2 | 3, methodName: string, oracleAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
         getDeployedPlainPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedGaugeMirrorAddress: (chainId: number) => Promise<string>;
+        getDeployedGaugeMirrorAddressByTx: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
             deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<number>;
@@ -221,5 +227,52 @@ declare const curve: {
             swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number | number[]>;
         };
     };
+    dao: {
+        crvSupplyStats: () => Promise<{
+            circulating: string;
+            locked: string;
+            total: string;
+            veCrv: string;
+            averageLockTime: string;
+        }>;
+        userCrv: (address?: string) => Promise<string>;
+        userVeCrv: (address?: string) => Promise<{
+            veCrv: string;
+            veCrvPct: string;
+            lockedCrv: string;
+            unlockTime: number;
+        }>;
+        crvLockIsApproved: (amount: string | number) => Promise<boolean>;
+        calcCrvUnlockTime: (days: string | number, start?: string | number) => number;
+        claimableFees: (address?: string) => Promise<string>;
+        crvLockApprove: (amount: string | number) => Promise<string[]>;
+        createCrvLock: (amount: string | number, days: string | number) => Promise<string>;
+        increaseCrvLockedAmount: (amount: string | number) => Promise<string>;
+        increaseCrvUnlockTime: (days: string | number) => Promise<string>;
+        withdrawLockedCrv: () => Promise<string>;
+        claimFees: (address?: string) => Promise<string>;
+        getVotingGaugeList: () => Promise<import("./interfaces.js").IVotingGauge[]>;
+        userGaugeVotes: (address?: string) => Promise<{
+            gauges: import("./interfaces.js").IGaugeUserVote[];
+            powerUsed: string;
+            veCrvUsed: string;
+        }>;
+        voteForGaugeNextTime: (gauge: string) => Promise<number>;
+        voteForGauge: (gauge: string, power: string | number) => Promise<string>;
+        getProposalList: () => Promise<import("./interfaces.js").IDaoProposalListItem[]>;
+        getProposal: (type: "PARAMETER" | "OWNERSHIP", id: number) => Promise<import("./interfaces.js").IDaoProposal>;
+        userProposalVotes: (address?: string) => Promise<import("./interfaces.js").IDaoProposalUserListItem[]>;
+        voteForProposal: (type: "PARAMETER" | "OWNERSHIP", id: number, support: boolean) => Promise<string>;
+        estimateGas: {
+            crvLockApprove: (amount: string | number) => Promise<number | number[]>;
+            createCrvLock: (amount: string | number, days: string | number) => Promise<number | number[]>;
+            increaseCrvLockedAmount: (amount: string | number) => Promise<number | number[]>;
+            increaseCrvUnlockTime: (days: string | number) => Promise<number | number[]>;
+            withdrawLockedCrv: () => Promise<number | number[]>;
+            claimFees: (address?: string) => Promise<number | number[]>;
+            voteForGauge: (gauge: string, power: string | number) => Promise<number | number[]>;
+            voteForProposal: (type: "PARAMETER" | "OWNERSHIP", id: number, support: boolean) => Promise<number | number[]>;
+        };
+    };
 };
 export default curve;

package/lib/index.js

@@ -41,6 +41,7 @@ import { curve as _curve } from "./curve.js";
 import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, lastEthBlock, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, lastBlockSent, blockToSend, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, } from "./boosting.js";
 import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, getUsdRate, getGasPriceFromL1, getGasPriceFromL2, getTVL, getCoinsData, getVolume, hasDepositAndStake, hasRouter, } from "./utils.js";
 import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, deployGaugeSidechain, deployGaugeSidechainEstimateGas, deployGaugeMirror, deployGaugeMirrorEstimateGas, getDeployedGaugeMirrorAddress, getDeployedGaugeMirrorAddressByTx, deployStableNgPlainPool, deployStableNgPlainPoolEstimateGas, deployStableNgMetaPool, deployStableNgMetaPoolEstimateGas, } from './factory/deploy.js';
+import { crvSupplyStats, userCrv, userVeCrv, crvLockIsApproved, crvLockApproveEstimateGas, crvLockApprove, calcCrvUnlockTime, createCrvLockEstimateGas, createCrvLock, increaseCrvLockedAmountEstimateGas, increaseCrvLockedAmount, increaseCrvUnlockTimeEstimateGas, increaseCrvUnlockTime, withdrawLockedCrvEstimateGas as daoWithdrawLockedCrvEstimateGas, withdrawLockedCrv as daoWithdrawLockedCrv, claimableFees as daoClaimableFees, claimFeesEstimateGas as daoClaimFeesEstimateGas, claimFees as daoClaimFees, getVotingGaugeList, userGaugeVotes, voteForGaugeNextTime, voteForGaugeEstimateGas, voteForGauge, getProposalList, getProposal, userProposalVotes, voteForProposalEstimateGas, voteForProposal, } from "./dao.js";
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -139,8 +140,20 @@ var curve = {
         getPoolList: _curve.getStableNgFactoryPoolList,
         deployPlainPool: deployStableNgPlainPool,
         deployMetaPool: deployStableNgMetaPool,
+        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, deployGauge(poolAddress, _curve.constants.ALIASES.stable_ng_factory)];
+        }); }); },
+        deployGaugeSidechain: function (poolAddress, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, deployGaugeSidechain(poolAddress, salt)];
+        }); }); },
+        deployGaugeMirror: function (chainId, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, deployGaugeMirror(chainId, salt)];
+        }); }); },
         getDeployedPlainPoolAddress: getDeployedStablePlainPoolAddress,
         getDeployedMetaPoolAddress: getDeployedStableMetaPoolAddress,
+        getDeployedGaugeAddress: getDeployedGaugeAddress,
+        getDeployedGaugeMirrorAddress: getDeployedGaugeMirrorAddress,
+        getDeployedGaugeMirrorAddressByTx: getDeployedGaugeMirrorAddressByTx,
         fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedStableNgFactoryPool,
         estimateGas: {
             deployPlainPool: deployStableNgPlainPoolEstimateGas,
@@ -268,5 +281,49 @@ var curve = {
             swap: swapEstimateGas,
         },
     },
+    dao: {
+        // --- CRV lock ---
+        // View methods
+        crvSupplyStats: crvSupplyStats,
+        userCrv: userCrv,
+        userVeCrv: userVeCrv,
+        crvLockIsApproved: crvLockIsApproved,
+        calcCrvUnlockTime: calcCrvUnlockTime,
+        claimableFees: daoClaimableFees,
+        // Transaction methods
+        crvLockApprove: crvLockApprove,
+        createCrvLock: createCrvLock,
+        increaseCrvLockedAmount: increaseCrvLockedAmount,
+        increaseCrvUnlockTime: increaseCrvUnlockTime,
+        withdrawLockedCrv: daoWithdrawLockedCrv,
+        claimFees: daoClaimFees,
+        // --- Gauge voting ---
+        // View methods
+        getVotingGaugeList: getVotingGaugeList,
+        userGaugeVotes: userGaugeVotes,
+        voteForGaugeNextTime: voteForGaugeNextTime,
+        // Transaction methods
+        voteForGauge: voteForGauge,
+        // --- Proposal voting ---
+        // View methods
+        getProposalList: getProposalList,
+        getProposal: getProposal,
+        userProposalVotes: userProposalVotes,
+        // Transaction methods
+        voteForProposal: voteForProposal,
+        estimateGas: {
+            // --- CRV lock ---
+            crvLockApprove: crvLockApproveEstimateGas,
+            createCrvLock: createCrvLockEstimateGas,
+            increaseCrvLockedAmount: increaseCrvLockedAmountEstimateGas,
+            increaseCrvUnlockTime: increaseCrvUnlockTimeEstimateGas,
+            withdrawLockedCrv: daoWithdrawLockedCrvEstimateGas,
+            claimFees: daoClaimFeesEstimateGas,
+            // --- Gauge voting ---
+            voteForGauge: voteForGaugeEstimateGas,
+            // --- Proposal voting ---
+            voteForProposal: voteForProposalEstimateGas,
+        },
+    },
 };
 export default curve;

package/lib/interfaces.d.ts

@@ -180,3 +180,69 @@ export interface IProfit {
     symbol: string;
     price: number;
 }
+export interface IGaugesDataFromApi {
+    gauge: string;
+    swap: string;
+    swap_token: string;
+    shortName: string;
+    gauge_controller: {
+        gauge_relative_weight: string;
+        get_gauge_weight: string;
+    };
+    poolUrls: {
+        swap: string[];
+    };
+    is_killed?: boolean;
+    hasNoCrv?: boolean;
+    gaugeStatus?: Record<string, boolean> | null;
+}
+export interface IVotingGauge {
+    poolUrl: string;
+    network: string;
+    gaugeAddress: string;
+    poolAddress: string;
+    lpTokenAddress: string;
+    poolName: string;
+    totalVeCrv: string;
+    relativeWeight: string;
+    isKilled: boolean;
+}
+export interface IGaugeUserVote {
+    userPower: string;
+    userVeCrv: string;
+    userFutureVeCrv: string;
+    expired: boolean;
+    gaugeData: IVotingGauge;
+}
+export interface IDaoProposalListItem {
+    voteId: number;
+    voteType: "PARAMETER" | "OWNERSHIP";
+    creator: string;
+    startDate: number;
+    snapshotBlock: number;
+    ipfsMetadata: string;
+    metadata: string;
+    votesFor: string;
+    votesAgainst: string;
+    voteCount: number;
+    supportRequired: string;
+    minAcceptQuorum: string;
+    totalSupply: string;
+    executed: boolean;
+}
+export interface IDaoProposalUserListItem extends IDaoProposalListItem {
+    userVote: "yes" | "no" | "even";
+}
+export interface IDaoProposalVote {
+    tx: string;
+    voteId: number;
+    voter: string;
+    supports: boolean;
+    stake: number;
+}
+export interface IDaoProposal extends IDaoProposalListItem {
+    tx: string;
+    creatorVotingPower: number;
+    script: string;
+    votes: IDaoProposalVote[];
+}

package/lib/pools/PoolTemplate.d.ts

@@ -103,6 +103,7 @@ export declare class PoolTemplate {
     private statsTotalLiquidity;
     private statsVolume;
     private statsBaseApy;
+    private _calcTokenApy;
     private statsTokenApy;
     private statsRewardsApy;
     private _pureCalcLpTokenAmount;
@@ -139,8 +140,11 @@ export declare class PoolTemplate {
     claimableCrv(address?: string): Promise<string>;
     claimCrvEstimateGas(): Promise<number | number[]>;
     claimCrv(): Promise<string>;
-    boost: (address?: string) => Promise<string>;
+    userBoost: (address?: string) => Promise<string>;
+    private _userFutureBoostAndWorkingSupply;
+    userFutureBoost: (address?: string) => Promise<string>;
     userCrvApy: (address?: string) => Promise<number>;
+    userFutureCrvApy: (address?: string) => Promise<number>;
     maxBoostedStake: (...addresses: string[]) => Promise<IDict<string> | string>;
     rewardTokens: ((useApi?: any) => Promise<{
         token: string;

package/lib/pools/PoolTemplate.js

@@ -56,8 +56,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import memoize from "memoizee";
 import { _getPoolsFromApi, _getSubgraphData, _getFactoryAPYsAndVolumes, _getLegacyAPYsAndVolumes } from '../external-api.js';
-import { _getCoinAddresses, _getBalances, _prepareAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getCrvApyFromApi, _getRewardsFromApi, mulBy1_3, smartNumber, DIGas, } from '../utils.js';
-import { curve as _curve, curve } from "../curve.js";
+import { _getCoinAddresses, _getBalances, _prepareAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getCrvApyFromApi, _getRewardsFromApi, mulBy1_3, smartNumber, DIGas, _getAddress, } from '../utils.js';
+import { curve } from "../curve.js";
 import ERC20Abi from '../constants/abis/ERC20.json' assert { type: 'json' };
 var DAY = 86400;
 var WEEK = 7 * DAY;
@@ -293,30 +293,19 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
-        this.statsTokenApy = function (useApi) {
-            if (useApi === void 0) { useApi = true; }
+        this._calcTokenApy = function (futureWorkingSupplyBN) {
+            if (futureWorkingSupplyBN === void 0) { futureWorkingSupplyBN = null; }
             return __awaiter(_this, void 0, void 0, function () {
-                var isDisabledChain, crvAPYs, poolCrvApy, totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _c, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
+                var totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _c, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
                 var _d, _e;
-                var _f;
-                return __generator(this, function (_g) {
-                    switch (_g.label) {
-                        case 0:
-                            if (this.rewardsOnly())
-                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
-                            isDisabledChain = [1313161554].includes(curve.chainId);
-                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, _getCrvApyFromApi()];
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0: return [4 /*yield*/, this.statsTotalLiquidity()];
                         case 1:
-                            crvAPYs = _g.sent();
-                            poolCrvApy = (_f = crvAPYs[this.gauge]) !== null && _f !== void 0 ? _f : [0, 0];
-                            return [2 /*return*/, [poolCrvApy[0], poolCrvApy[1]]];
-                        case 2: return [4 /*yield*/, this.statsTotalLiquidity()];
-                        case 3:
-                            totalLiquidityUSD = _g.sent();
+                            totalLiquidityUSD = _f.sent();
                             if (Number(totalLiquidityUSD) === 0)
                                 return [2 /*return*/, [0, 0]];
-                            if (!(curve.chainId !== 1)) return [3 /*break*/, 7];
+                            if (!(curve.chainId !== 1)) return [3 /*break*/, 5];
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             lpTokenContract = curve.contracts[this.lpToken].multicallContract;
                             crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
@@ -326,16 +315,16 @@ var PoolTemplate = /** @class */ (function () {
                                     gaugeContract.working_supply(),
                                     lpTokenContract.totalSupply(),
                                 ])];
-                        case 4:
-                            _d = (_g.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
-                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 6];
+                        case 2:
+                            _d = (_f.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 4];
                             _c = toBN;
                             return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve.constantOptions)];
+                        case 3:
+                            inflationRateBN = _c.apply(void 0, [_f.sent()]).div(WEEK);
+                            _f.label = 4;
+                        case 4: return [3 /*break*/, 7];
                         case 5:
-                            inflationRateBN = _c.apply(void 0, [_g.sent()]).div(WEEK);
-                            _g.label = 6;
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             lpTokenContract = curve.contracts[this.lpToken].multicallContract;
                             gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
@@ -346,17 +335,19 @@ var PoolTemplate = /** @class */ (function () {
                                     gaugeContract.working_supply(),
                                     lpTokenContract.totalSupply(),
                                 ])];
-                        case 8:
-                            _e = (_g.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingSupplyBN = _e[2], totalSupplyBN = _e[3];
+                        case 6:
+                            _e = (_f.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingSupplyBN = _e[2], totalSupplyBN = _e[3];
                             inflationRateBN = inflationRateBN.times(weightBN);
-                            _g.label = 9;
-                        case 9:
+                            _f.label = 7;
+                        case 7:
                             if (inflationRateBN.eq(0))
                                 return [2 /*return*/, [0, 0]];
-                            rateBN = inflationRateBN.times(31536000).times(0.4).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD));
+                            if (futureWorkingSupplyBN !== null)
+                                workingSupplyBN = futureWorkingSupplyBN;
+                            rateBN = inflationRateBN.times(31536000).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)).times(0.4);
                             return [4 /*yield*/, _getUsdRate(curve.constants.ALIASES.crv)];
-                        case 10:
-                            crvPrice = _g.sent();
+                        case 8:
+                            crvPrice = _f.sent();
                             baseApyBN = rateBN.times(crvPrice);
                             boostedApyBN = baseApyBN.times(2.5);
                             return [2 /*return*/, [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()]];
@@ -364,6 +355,29 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        this.statsTokenApy = function (useApi) {
+            if (useApi === void 0) { useApi = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var isDisabledChain, crvAPYs, poolCrvApy;
+                var _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            isDisabledChain = [1313161554].includes(curve.chainId);
+                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getCrvApyFromApi()];
+                        case 1:
+                            crvAPYs = _d.sent();
+                            poolCrvApy = (_c = crvAPYs[this.gauge]) !== null && _c !== void 0 ? _c : [0, 0];
+                            return [2 /*return*/, [poolCrvApy[0], poolCrvApy[1]]];
+                        case 2: return [4 /*yield*/, this._calcTokenApy()];
+                        case 3: return [2 /*return*/, _d.sent()];
+                    }
+                });
+            });
+        };
         this.statsRewardsApy = function (useApi) {
             if (useApi === void 0) { useApi = true; }
             return __awaiter(_this, void 0, void 0, function () {
@@ -592,7 +606,7 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
-        this.boost = function (address) {
+        this.userBoost = function (address) {
             if (address === void 0) { address = ""; }
             return __awaiter(_this, void 0, void 0, function () {
                 var gaugeContract, _c, workingBalanceBN, balanceBN, boostBN;
@@ -601,9 +615,9 @@ var PoolTemplate = /** @class */ (function () {
                         case 0:
                             if (this.gauge === curve.constants.ZERO_ADDRESS)
                                 throw Error("".concat(this.name, " doesn't have gauge"));
-                            address = address || curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             return [4 /*yield*/, curve.multicallProvider.all([
                                     gaugeContract.working_balances(address),
@@ -621,27 +635,106 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        this._userFutureBoostAndWorkingSupply = function (address) { return __awaiter(_this, void 0, void 0, function () {
+            var veContractMulticall, gaugeContractMulticall, calls, _c, _votingBalance, _votingTotal, _gaugeBalance, _gaugeTotal, _workingBalance, _workingSupply, _futureWorkingBalance, _futureWorkingSupply, futureWorkingBalanceBN, balanceBN, boostBN;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        veContractMulticall = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+                        gaugeContractMulticall = curve.contracts[this.gauge].multicallContract;
+                        calls = [
+                            veContractMulticall.balanceOf(address),
+                            veContractMulticall.totalSupply(),
+                            gaugeContractMulticall.balanceOf(address),
+                            gaugeContractMulticall.totalSupply(),
+                            gaugeContractMulticall.working_balances(address),
+                            gaugeContractMulticall.working_supply(),
+                        ];
+                        return [4 /*yield*/, curve.multicallProvider.all(calls)];
+                    case 1:
+                        _c = _d.sent(), _votingBalance = _c[0], _votingTotal = _c[1], _gaugeBalance = _c[2], _gaugeTotal = _c[3], _workingBalance = _c[4], _workingSupply = _c[5];
+                        _futureWorkingBalance = _gaugeBalance * BigInt(40) / BigInt(100);
+                        if (_votingTotal > BigInt(0)) {
+                            _futureWorkingBalance += _gaugeTotal * _votingBalance / _votingTotal * BigInt(60) / BigInt(100);
+                        }
+                        if (_futureWorkingBalance > _gaugeBalance)
+                            _futureWorkingBalance = _gaugeBalance;
+                        _futureWorkingSupply = _workingSupply - _workingBalance + _futureWorkingBalance;
+                        futureWorkingBalanceBN = toBN(_futureWorkingBalance);
+                        balanceBN = toBN(_gaugeBalance);
+                        boostBN = futureWorkingBalanceBN.div(0.4).div(balanceBN);
+                        return [2 /*return*/, [boostBN, toBN(_futureWorkingSupply)]];
+                }
+            });
+        }); };
+        this.userFutureBoost = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var boostBN;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
+                            return [4 /*yield*/, this._userFutureBoostAndWorkingSupply(address)];
+                        case 1:
+                            boostBN = (_c.sent())[0];
+                            if (boostBN.lt(1))
+                                return [2 /*return*/, '1.0'];
+                            if (boostBN.gt(2.5))
+                                return [2 /*return*/, '2.5'];
+                            return [2 /*return*/, boostBN.toFixed(4).replace(/([0-9])0+$/, '$1')];
+                    }
+                });
+            });
+        };
         this.userCrvApy = function (address) {
             if (address === void 0) { address = ""; }
             return __awaiter(_this, void 0, void 0, function () {
-                var _c, baseApy, maxApy, boost;
+                var _c, minApy, maxApy, boost;
                 return __generator(this, function (_d) {
                     switch (_d.label) {
                         case 0:
-                            address = address || curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
                             return [4 /*yield*/, this.statsTokenApy()];
                         case 1:
-                            _c = _d.sent(), baseApy = _c[0], maxApy = _c[1];
-                            return [4 /*yield*/, this.boost(address)];
+                            _c = _d.sent(), minApy = _c[0], maxApy = _c[1];
+                            return [4 /*yield*/, this.userBoost(address)];
                         case 2:
                             boost = _d.sent();
                             if (boost == "2.5")
                                 return [2 /*return*/, maxApy];
                             if (boost === "NaN")
                                 return [2 /*return*/, NaN];
-                            return [2 /*return*/, BN(baseApy).times(BN(boost)).toNumber()];
+                            return [2 /*return*/, BN(minApy).times(BN(boost)).toNumber()];
+                    }
+                });
+            });
+        };
+        this.userFutureCrvApy = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _c, boostBN, futureWorkingSupplyBN, _d, minApy, maxApy;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
+                            return [4 /*yield*/, this._userFutureBoostAndWorkingSupply(address)];
+                        case 1:
+                            _c = _e.sent(), boostBN = _c[0], futureWorkingSupplyBN = _c[1];
+                            return [4 /*yield*/, this._calcTokenApy(futureWorkingSupplyBN)];
+                        case 2:
+                            _d = _e.sent(), minApy = _d[0], maxApy = _d[1];
+                            if (boostBN.lt(1))
+                                return [2 /*return*/, minApy];
+                            if (boostBN.gt(2.5))
+                                return [2 /*return*/, maxApy];
+                            return [2 /*return*/, BN(minApy).times(boostBN).toNumber()];
                     }
                 });
             });
@@ -825,7 +918,7 @@ var PoolTemplate = /** @class */ (function () {
                             return [3 /*break*/, 3];
                         case 6: return [3 /*break*/, 14];
                         case 7:
-                            if (!(this.sRewardContract && "rewardRate()" in _curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
+                            if (!(this.sRewardContract && "rewardRate()" in curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
                             rewardToken = rewardTokens[0];
                             sRewardContract = curve.contracts[this.sRewardContract].multicallContract;
                             return [4 /*yield*/, curve.multicallProvider.all([
@@ -1403,27 +1496,34 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.depositBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, prices, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var amountsBN, prices, _c, pricesBN, balancesBN, balancedAmounts, expectedBN, _d, balancedExpectedBN, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         amountsBN = amounts.map(BN);
+                        if (!(this.isCrypto || this.id === 'wsteth' || this.id === 'factory-crvusd-24')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _e.sent();
+                        _c = _f.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _c = this.underlyingCoins.map(function () { return 1; });
+                        _f.label = 3;
+                    case 3:
+                        prices = _c;
                         pricesBN = prices.map(BN);
                         return [4 /*yield*/, this.stats.underlyingBalances()];
-                    case 2:
-                        balancesBN = (_e.sent()).map(BN);
+                    case 4:
+                        balancesBN = (_f.sent()).map(BN);
                         balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
-                        _c = BN;
-                        return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 3:
-                        expectedBN = _c.apply(void 0, [_e.sent()]);
                         _d = BN;
+                        return [4 /*yield*/, this.depositExpected(amounts)];
+                    case 5:
+                        expectedBN = _d.apply(void 0, [_f.sent()]);
+                        _e = BN;
                         return [4 /*yield*/, this.depositExpected(balancedAmounts)];
-                    case 4:
-                        balancedExpectedBN = _d.apply(void 0, [_e.sent()]);
+                    case 6:
+                        balancedExpectedBN = _e.apply(void 0, [_f.sent()]);
                         return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
                 }
             });

package/lib/utils.d.ts

@@ -23,6 +23,7 @@ export declare const _getCoinAddresses: (...coins: string[] | string[][]) => str
 export declare const _getCoinDecimals: (...coinAddresses: string[] | string[][]) => number[];
 export declare const _getBalances: (coins: string[], addresses: string[]) => Promise<IDict<string[]>>;
 export declare const _prepareAddresses: (addresses: string[] | string[][]) => string[];
+export declare const _getAddress: (address: string) => string;
 export declare const getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<IDict<string[]> | string[]>;
 export declare const _getAllowance: (coins: string[], address: string, spender: string) => Promise<bigint[]>;
 export declare const getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;