@morpho-org/blue-sdk 5.1.0 → 5.2.0-next.0

package/lib/market/Market.js

@@ -1,20 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Market = exports.CapacityLimitReason = void 0;
+exports.Market = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../math/index.js");
-const viem_1 = require("viem");
+const utils_js_1 = require("../utils.js");
 const MarketParams_js_1 = require("./MarketParams.js");
 const MarketUtils_js_1 = require("./MarketUtils.js");
-var CapacityLimitReason;
-(function (CapacityLimitReason) {
-    CapacityLimitReason["liquidity"] = "Liquidity";
-    CapacityLimitReason["balance"] = "Balance";
-    CapacityLimitReason["position"] = "Position";
-    CapacityLimitReason["collateral"] = "Collateral";
-    CapacityLimitReason["cap"] = "Cap";
-})(CapacityLimitReason || (exports.CapacityLimitReason = CapacityLimitReason = {}));
 /**
  * Represents a lending market on Morpho Blue.
  */
@@ -95,13 +87,27 @@ class Market {
         return MarketUtils_js_1.MarketUtils.getUtilization(this);
     }
     /**
-     * The market's Annual Percentage Yield (APY) at the IRM's target utilization rate, if applicable.
+     * The market's Annual Percentage Yield (APY) at the IRM's target utilization rate, if applicable (scaled by WAD).
      */
     get apyAtTarget() {
         if (this.rateAtTarget == null)
             return;
         return MarketUtils_js_1.MarketUtils.rateToApy(this.rateAtTarget);
     }
+    /**
+     * Returns the rate at which interest accrued for suppliers of this market,
+     * since the last time the market was updated (scaled by WAD).
+     * @deprecated There's no such thing as a supply rate in Morpho. Only the supply APY is meaningful.
+     */
+    get supplyRate() {
+        return MarketUtils_js_1.MarketUtils.getSupplyRate(this.avgBorrowRate, this);
+    }
+    /**
+     * @deprecated Use `avgBorrowRate` instead.
+     */
+    get borrowRate() {
+        return this.getAccrualBorrowRates().avgBorrowRate;
+    }
     /**
      * Returns the instantaneous rate at which interest accrues for borrowers of this market,
      * if `accrueInterest` was called immediately onchain (scaled by WAD).
@@ -132,19 +138,25 @@ class Market {
         return this.getAccrualBorrowRates().avgBorrowRate;
     }
     /**
-     * The market's current, instantaneous supply-side Annual Percentage Yield (APY).
+     * The market's current, instantaneous supply-side Annual Percentage Yield (APY) (scaled by WAD).
      * If interested in the APY at a specific timestamp, use `getSupplyApy(timestamp)` instead.
      */
     get supplyApy() {
         return this.getSupplyApy();
     }
     /**
-     * The market's current, instantaneous borrow-side Annual Percentage Yield (APY).
+     * The market's current, instantaneous borrow-side Annual Percentage Yield (APY) (scaled by WAD).
      * If interested in the APY at a specific timestamp, use `getBorrowApy(timestamp)` instead.
      */
     get borrowApy() {
         return this.getBorrowApy();
     }
+    /**
+     * @deprecated Use `getEndBorrowRate(timestamp)` instead.
+     */
+    getBorrowRate(timestamp = morpho_ts_1.Time.timestamp()) {
+        return this.getAccrualBorrowRates(timestamp).endBorrowRate;
+    }
     /**
      * Returns the instantaneous rate at which interest accrues for borrowers of this market,
      * at the given timestamp, if the state remains unchanged (not accrued) (scaled by WAD).
@@ -192,7 +204,7 @@ class Market {
     }
     /**
      * The market's instantaneous borrow-side Annual Percentage Yield (APY) at the given timestamp,
-     * if the state remains unchanged (not accrued).
+     * if the state remains unchanged (not accrued) (scaled by WAD).
      * @param timestamp The timestamp at which to calculate the borrow APY.
      * Must be greater than or equal to `lastUpdate`.
      * Defaults to `Time.timestamp()` (returns the current borrow APY).
@@ -203,18 +215,18 @@ class Market {
     }
     /**
      * The market's instantaneous supply-side Annual Percentage Yield (APY) at the given timestamp,
-     * if the state remains unchanged (not accrued).
+     * if the state remains unchanged (not accrued) (scaled by WAD).
      * @param timestamp The timestamp at which to calculate the supply APY.
      * Must be greater than or equal to `lastUpdate`.
      * Defaults to `Time.timestamp()` (returns the current supply APY).
      */
     getSupplyApy(timestamp = morpho_ts_1.Time.timestamp()) {
         const borrowApy = this.getBorrowApy(timestamp);
-        return (borrowApy * +(0, viem_1.formatEther)(this.utilization) * (1 - +(0, viem_1.formatEther)(this.fee)));
+        return index_js_1.MathLib.wMulUp(index_js_1.MathLib.wMulDown(borrowApy, this.utilization), index_js_1.MathLib.WAD - this.fee);
     }
     /**
      * The market's experienced borrow-side Annual Percentage Yield (APY),
-     * if interest was to be accrued at the given timestamp.
+     * if interest was to be accrued at the given timestamp (scaled by WAD).
      * @param timestamp The timestamp at which to calculate the borrow APY.
      * Must be greater than or equal to `lastUpdate`.
      * Defaults to `Time.timestamp()` (returns the current borrow APY).
@@ -225,14 +237,14 @@ class Market {
     }
     /**
      * The market's experienced supply-side Annual Percentage Yield (APY),
-     * if interest was to be accrued at the given timestamp.
+     * if interest was to be accrued at the given timestamp (scaled by WAD).
      * @param timestamp The timestamp at which to calculate the supply APY.
      * Must be greater than or equal to `lastUpdate`.
      * Defaults to `Time.timestamp()` (returns the current supply APY).
      */
     getAvgSupplyApy(timestamp = morpho_ts_1.Time.timestamp()) {
         const borrowApy = this.getAvgBorrowApy(timestamp);
-        return (borrowApy * +(0, viem_1.formatEther)(this.utilization) * (1 - +(0, viem_1.formatEther)(this.fee)));
+        return index_js_1.MathLib.wMulUp(index_js_1.MathLib.wMulDown(borrowApy, this.utilization), index_js_1.MathLib.WAD - this.fee);
     }
     /**
      * Returns a new market derived from this market, whose interest has been accrued up to the given timestamp.
@@ -488,11 +500,11 @@ class Market {
         if (maxBorrowableAssets > liquidity)
             return {
                 value: liquidity,
-                limiter: CapacityLimitReason.liquidity,
+                limiter: utils_js_1.CapacityLimitReason.liquidity,
             };
         return {
             value: maxBorrowableAssets,
-            limiter: CapacityLimitReason.collateral,
+            limiter: utils_js_1.CapacityLimitReason.collateral,
         };
     }
     /**
@@ -505,11 +517,11 @@ class Market {
         if (borrowAssets > loanTokenBalance)
             return {
                 value: loanTokenBalance,
-                limiter: CapacityLimitReason.balance,
+                limiter: utils_js_1.CapacityLimitReason.balance,
             };
         return {
             value: borrowAssets,
-            limiter: CapacityLimitReason.position,
+            limiter: utils_js_1.CapacityLimitReason.position,
         };
     }
     /**
@@ -523,11 +535,11 @@ class Market {
         if (supplyAssets > liquidity)
             return {
                 value: liquidity,
-                limiter: CapacityLimitReason.liquidity,
+                limiter: utils_js_1.CapacityLimitReason.liquidity,
             };
         return {
             value: supplyAssets,
-            limiter: CapacityLimitReason.position,
+            limiter: utils_js_1.CapacityLimitReason.position,
         };
     }
     /**
@@ -543,11 +555,11 @@ class Market {
         if (position.collateral > withdrawableCollateral)
             return {
                 value: withdrawableCollateral,
-                limiter: CapacityLimitReason.collateral,
+                limiter: utils_js_1.CapacityLimitReason.collateral,
             };
         return {
             value: position.collateral,
-            limiter: CapacityLimitReason.position,
+            limiter: utils_js_1.CapacityLimitReason.position,
         };
     }
     /**
@@ -561,14 +573,14 @@ class Market {
         return {
             supply: {
                 value: loanTokenBalance,
-                limiter: CapacityLimitReason.balance,
+                limiter: utils_js_1.CapacityLimitReason.balance,
             },
             withdraw: this.getWithdrawCapacityLimit(position),
             borrow: this.getBorrowCapacityLimit(position, options?.borrow),
             repay: this.getRepayCapacityLimit(position.borrowShares, loanTokenBalance),
             supplyCollateral: {
                 value: collateralTokenBalance,
-                limiter: CapacityLimitReason.balance,
+                limiter: utils_js_1.CapacityLimitReason.balance,
             },
             withdrawCollateral: this.getWithdrawCollateralCapacityLimit(position, options?.withdrawCollateral),
         };

package/lib/market/MarketUtils.d.ts

@@ -26,11 +26,29 @@ export declare namespace MarketUtils {
         totalBorrowAssets: BigIntish;
     }): bigint;
     /**
-     * Returns the per-second rate continuously compounded over a year,
+     * Returns the rate at which interest accrued for suppliers on the corresponding market,
+     * since the last time the market was updated (scaled by WAD).
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     * @deprecated There's no such thing as a supply rate in Morpho. Only the supply APY is meaningful.
+     */
+    function getSupplyRate(borrowRate: BigIntish, { utilization, fee }: {
+        utilization: BigIntish;
+        fee: BigIntish;
+    }): bigint;
+    /**
+     * Returns the per-second rate continuously compounded over the given period, as calculated in Morpho Blue (scaled by WAD).
+     * @param rate The per-second rate to compound (scaled by WAD).
+     * @param period The period to compound the rate over (in seconds). Defaults to 1 year.
+     * @deprecated The compounded rate is inaccurate if rate * period >> 0. If interested in the APY, use `rateToApy` instead.
+     */
+    function compoundRate(rate: BigIntish, period?: BigIntish): bigint;
+    /**
+     * Returns the per-second rate continuously compounded over a year (scaled by WAD),
      * as calculated in Morpho Blue assuming the market is frequently accrued onchain.
-     * @param rate The per-second rate to compound annually.
+     * @param rate The per-second rate to compound annually (scaled by WAD).
      */
-    function rateToApy(rate: BigIntish): number;
+    function rateToApy(rate: BigIntish): bigint;
     /**
      * Returns the interest accrued on both sides of the given market
      * as well as the supply shares minted to the fee recipient.

package/lib/market/MarketUtils.js

@@ -6,6 +6,7 @@ const utils_1 = require("@noble/hashes/utils");
 const viem_1 = require("viem");
 const constants_js_1 = require("../constants.js");
 const index_js_1 = require("../math/index.js");
+const utils_js_1 = require("../utils.js");
 /**
  * Namespace of utility functions to ease market-related calculations.
  */
@@ -51,12 +52,35 @@ var MarketUtils;
     }
     MarketUtils.getUtilization = getUtilization;
     /**
-     * Returns the per-second rate continuously compounded over a year,
+     * Returns the rate at which interest accrued for suppliers on the corresponding market,
+     * since the last time the market was updated (scaled by WAD).
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     * @deprecated There's no such thing as a supply rate in Morpho. Only the supply APY is meaningful.
+     */
+    function getSupplyRate(borrowRate, { utilization, fee }) {
+        const borrowRateWithoutFees = index_js_1.MathLib.wMulUp(borrowRate, utilization);
+        return index_js_1.MathLib.wMulUp(borrowRateWithoutFees, index_js_1.MathLib.WAD - BigInt(fee));
+    }
+    MarketUtils.getSupplyRate = getSupplyRate;
+    /**
+     * Returns the per-second rate continuously compounded over the given period, as calculated in Morpho Blue (scaled by WAD).
+     * @param rate The per-second rate to compound (scaled by WAD).
+     * @param period The period to compound the rate over (in seconds). Defaults to 1 year.
+     * @deprecated The compounded rate is inaccurate if rate * period >> 0. If interested in the APY, use `rateToApy` instead.
+     */
+    function compoundRate(rate, period = constants_js_1.SECONDS_PER_YEAR) {
+        return index_js_1.MathLib.wTaylorCompounded(rate, period);
+    }
+    MarketUtils.compoundRate = compoundRate;
+    /**
+     * Returns the per-second rate continuously compounded over a year (scaled by WAD),
      * as calculated in Morpho Blue assuming the market is frequently accrued onchain.
-     * @param rate The per-second rate to compound annually.
+     * @param rate The per-second rate to compound annually (scaled by WAD).
      */
+    // TODO: return a Number for APYs.
     function rateToApy(rate) {
-        return Math.expm1(+(0, viem_1.formatEther)(BigInt(rate) * constants_js_1.SECONDS_PER_YEAR));
+        return (0, utils_js_1.safeParseNumber)(Math.expm1(+(0, viem_1.formatEther)(BigInt(rate) * constants_js_1.SECONDS_PER_YEAR)));
     }
     MarketUtils.rateToApy = rateToApy;
     /**

package/lib/position/Position.d.ts

@@ -109,7 +109,7 @@ export declare class AccrualPosition extends Position implements IAccrualPositio
      * Returns the maximum amount of loan assets that can be withdrawn given a certain supply position
      * and a balance of loan assets, and the reason for the limit.
      */
-    get withdrawCapacityLimit(): import("../market/Market.js").CapacityLimit;
+    get withdrawCapacityLimit(): import("../utils.js").CapacityLimit;
     /**
      * Returns a new position derived from this position, whose interest has been accrued up to the given timestamp.
      * @param timestamp The timestamp at which to accrue interest. Must be greater than or equal to the market's `lastUpdate`.
@@ -137,9 +137,9 @@ export declare class AccrualPosition extends Position implements IAccrualPositio
         assets: bigint;
         shares: bigint;
     };
-    getBorrowCapacityLimit(options?: MaxBorrowOptions): import("../market/Market.js").CapacityLimit | undefined;
-    getWithdrawCollateralCapacityLimit(options?: MaxWithdrawCollateralOptions): import("../market/Market.js").CapacityLimit | undefined;
-    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market/Market.js").CapacityLimit;
+    getBorrowCapacityLimit(options?: MaxBorrowOptions): import("../utils.js").CapacityLimit | undefined;
+    getWithdrawCollateralCapacityLimit(options?: MaxWithdrawCollateralOptions): import("../utils.js").CapacityLimit | undefined;
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../utils.js").CapacityLimit;
     getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint, options?: {
         borrow?: MaxBorrowOptions;
         withdrawCollateral?: MaxWithdrawCollateralOptions;

package/lib/position/Position.js

@@ -4,6 +4,7 @@ exports.AccrualPosition = exports.Position = void 0;
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../market/index.js");
 const MathLib_js_1 = require("../math/MathLib.js");
+const utils_js_1 = require("../utils.js");
 class Position {
     /**
      * The user holding this position.
@@ -225,14 +226,14 @@ class AccrualPosition extends Position {
         return {
             supply: {
                 value: loanTokenBalance,
-                limiter: index_js_1.CapacityLimitReason.balance,
+                limiter: utils_js_1.CapacityLimitReason.balance,
             },
             withdraw: this.withdrawCapacityLimit,
             borrow: this.getBorrowCapacityLimit(options?.borrow),
             repay: this.getRepayCapacityLimit(loanTokenBalance),
             supplyCollateral: {
                 value: collateralTokenBalance,
-                limiter: index_js_1.CapacityLimitReason.balance,
+                limiter: utils_js_1.CapacityLimitReason.balance,
             },
             withdrawCollateral: this.getWithdrawCollateralCapacityLimit(options?.withdrawCollateral),
         };

package/lib/token/VaultToken.d.ts

@@ -1,5 +1,5 @@
 import type { RoundingDirection } from "../math/index.js";
-import type { Address } from "../types.js";
+import type { Address, BigIntish } from "../types.js";
 import type { IVaultConfig } from "../vault/VaultConfig.js";
 import { WrappedToken } from "./WrappedToken.js";
 export interface IVaultToken {
@@ -18,6 +18,6 @@ export declare class VaultToken extends WrappedToken implements IVaultToken {
      */
     totalAssets: bigint;
     constructor(config: IVaultConfig, { totalAssets, totalSupply }: IVaultToken);
-    protected _wrap(amount: bigint, rounding: RoundingDirection): bigint;
-    protected _unwrap(amount: bigint, rounding: RoundingDirection): bigint;
+    protected _wrap(amount: BigIntish, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: BigIntish, rounding: RoundingDirection): bigint;
 }

package/lib/types.d.ts

@@ -23,4 +23,5 @@ export declare enum TransactionType {
 export type Loadable<T> = T | undefined;
 export type Failable<T> = T | null;
 export type Fetchable<T> = Failable<Loadable<T>>;
+export declare function isFetched<T>(v: Fetchable<T>): v is T;
 export declare const isMarketId: (value: unknown) => value is MarketId;

package/lib/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMarketId = exports.TransactionType = void 0;
+exports.isFetched = isFetched;
 /**
  * The possible transaction type on the Blue contract
  */
@@ -13,5 +14,9 @@ var TransactionType;
     TransactionType["Borrow"] = "Borrow";
     TransactionType["Repay"] = "Repay";
 })(TransactionType || (exports.TransactionType = TransactionType = {}));
+// TODO: replace with isDefined
+function isFetched(v) {
+    return v !== undefined && v !== null;
+}
 const isMarketId = (value) => typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);
 exports.isMarketId = isMarketId;

package/lib/utils.d.ts

@@ -0,0 +1,15 @@
+export declare enum CapacityLimitReason {
+    liquidity = "Liquidity",
+    balance = "Balance",
+    position = "Position",
+    collateral = "Collateral",
+    cap = "Cap",
+    vaultV2_absoluteCap = "VaultV2_AbsoluteCap",
+    vaultV2_relativeCap = "VaultV2_RelativeCap"
+}
+export interface CapacityLimit {
+    value: bigint;
+    limiter: CapacityLimitReason;
+}
+export declare const safeParseNumber: (value: number, decimals?: number) => bigint;
+export declare const safeParseUnits: (strValue: string, decimals?: number) => bigint;

package/lib/utils.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeParseUnits = exports.safeParseNumber = exports.CapacityLimitReason = void 0;
+var CapacityLimitReason;
+(function (CapacityLimitReason) {
+    CapacityLimitReason["liquidity"] = "Liquidity";
+    CapacityLimitReason["balance"] = "Balance";
+    CapacityLimitReason["position"] = "Position";
+    CapacityLimitReason["collateral"] = "Collateral";
+    CapacityLimitReason["cap"] = "Cap";
+    CapacityLimitReason["vaultV2_absoluteCap"] = "VaultV2_AbsoluteCap";
+    CapacityLimitReason["vaultV2_relativeCap"] = "VaultV2_RelativeCap";
+})(CapacityLimitReason || (exports.CapacityLimitReason = CapacityLimitReason = {}));
+// Alternative to Number.toFixed that doesn't use scientific notation for excessively small or large numbers.
+const toFixed = (x, decimals) => new Intl.NumberFormat("en-US", {
+    style: "decimal",
+    useGrouping: false,
+    maximumFractionDigits: decimals,
+    minimumFractionDigits: decimals,
+}).format(x);
+const safeParseNumber = (value, decimals = 18) => (0, exports.safeParseUnits)(toFixed(value, decimals), decimals);
+exports.safeParseNumber = safeParseNumber;
+const safeParseUnits = (strValue, decimals = 18) => {
+    if (!/[-+]?[0-9]*\.?[0-9]+/.test(strValue))
+        throw Error(`invalid number: ${strValue}`);
+    let [whole, dec = ""] = strValue.split(".");
+    dec = dec.slice(0, decimals);
+    return parseUnits([whole || "0", dec].filter((v) => v.length > 0).join("."), decimals);
+};
+exports.safeParseUnits = safeParseUnits;
+/**
+ * Multiplies a string representation of a number by a given exponent of base 10 (10exponent).
+ *
+ * - Docs: https://viem.sh/docs/utilities/parseUnits
+ *
+ * @example
+ * import { parseUnits } from 'viem'
+ *
+ * parseUnits('420', 9)
+ * // 420000000000n
+ */
+// TODO: get rid of this copy.
+function parseUnits(value, decimals) {
+    let [integer, fraction = "0"] = value.split(".");
+    const negative = integer.startsWith("-");
+    if (negative)
+        integer = integer.slice(1);
+    // trim trailing zeros.
+    fraction = fraction.replace(/(0+)$/, "");
+    // round off if the fraction is larger than the number of decimals.
+    if (decimals === 0) {
+        if (Math.round(Number(`.${fraction}`)) === 1)
+            integer = `${BigInt(integer) + 1n}`;
+        fraction = "";
+    }
+    else if (fraction.length > decimals) {
+        const [left, unit, right] = [
+            fraction.slice(0, decimals - 1),
+            fraction.slice(decimals - 1, decimals),
+            fraction.slice(decimals),
+        ];
+        const rounded = Math.round(Number(`${unit}.${right}`));
+        if (rounded > 9)
+            fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
+        else
+            fraction = `${left}${rounded}`;
+        if (fraction.length > decimals) {
+            fraction = fraction.slice(1);
+            integer = `${BigInt(integer) + 1n}`;
+        }
+        fraction = fraction.slice(0, decimals);
+    }
+    else {
+        fraction = fraction.padEnd(decimals, "0");
+    }
+    return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}

package/lib/vault/Vault.d.ts

@@ -1,7 +1,7 @@
-import { type CapacityLimit } from "../market/index.js";
 import { type RoundingDirection } from "../math/index.js";
 import { VaultToken } from "../token/index.js";
 import type { Address, BigIntish, MarketId } from "../types.js";
+import { type CapacityLimit } from "../utils.js";
 import type { IVaultConfig } from "./VaultConfig.js";
 import { type IVaultMarketAllocation, VaultMarketAllocation } from "./VaultMarketAllocation.js";
 export interface Pending<T> {
@@ -116,8 +116,8 @@ export declare class Vault extends VaultToken implements IVault {
      * The amount of interest in assets accrued since the last interaction with the vault.
      */
     get totalInterest(): bigint;
-    toAssets(shares: bigint, rounding?: RoundingDirection): bigint;
-    toShares(assets: bigint, rounding?: RoundingDirection): bigint;
+    toAssets(shares: BigIntish, rounding?: RoundingDirection): bigint;
+    toShares(assets: BigIntish, rounding?: RoundingDirection): bigint;
 }
 export interface CollateralAllocation {
     address: Address;
@@ -149,31 +149,51 @@ export declare class AccrualVault extends Vault implements IAccrualVault {
     get liquidity(): bigint;
     /**
      * The MetaMorpho vault's current instantaneous Annual Percentage Yield (APY)
-     * weighted-averaged over its market deposits, before deducting the performance fee.
+     * weighted-averaged over its market deposits, before deducting the performance fee (scaled by WAD).
      * If interested in the APY at a specific timestamp, use `getApy(timestamp)` instead.
      */
-    get apy(): number;
+    get apy(): bigint;
     /**
      * The MetaMorpho vault's current instantaneous Annual Percentage Yield (APY)
-     * weighted-averaged over its market deposits, after deducting the performance fee.
+     * weighted-averaged over its market deposits, after deducting the performance fee (scaled by WAD).
      * If interested in the APY at a specific timestamp, use `getApy(timestamp)` instead.
      */
-    get netApy(): number;
+    get netApy(): bigint;
     /**
      * The MetaMorpho vault's experienced Annual Percentage Yield (APY)
      * weighted-averaged over its market deposits, before deducting the performance fee,
-     * if interest was to be accrued on each market at the given timestamp.
+     * if interest was to be accrued on each market at the given timestamp (scaled by WAD).
      */
-    getApy(timestamp?: BigIntish): number;
+    getApy(timestamp?: BigIntish): bigint;
     /**
      * The MetaMorpho vault's experienced Annual Percentage Yield (APY)
      * weighted-averaged over its market deposits, after deducting the performance fee,
-     * if interest was to be accrued on each market at the given timestamp.
+     * if interest was to be accrued on each market at the given timestamp (scaled by WAD).
      */
-    getNetApy(timestamp?: BigIntish): number;
+    getNetApy(timestamp?: BigIntish): bigint;
     getAllocationProportion(marketId: MarketId): bigint;
+    /**
+     * Returns the deposit capacity limit of a given amount of assets on the vault.
+     * @param assets The maximum amount of assets to deposit.
+     * @deprecated Use `maxDeposit` instead.
+     */
     getDepositCapacityLimit(assets: bigint): CapacityLimit;
+    /**
+     * Returns the withdraw capacity limit corresponding to a given amount of shares of the vault.
+     * @param shares The maximum amount of shares to redeem.
+     * @deprecated Use `maxWithdraw` instead.
+     */
     getWithdrawCapacityLimit(shares: bigint): CapacityLimit;
+    /**
+     * Returns the maximum amount of assets that can be deposited to the vault.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(assets: BigIntish): CapacityLimit;
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from the vault.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(shares: BigIntish): CapacityLimit;
     /**
      * Returns a new vault derived from this vault, whose interest has been accrued up to the given timestamp.
      * @param timestamp The timestamp at which to accrue interest. Must be greater than or equal to each of the vault's market's `lastUpdate`.