@morpho-org/blue-sdk 5.2.0 → 5.3.0-next.1

package/lib/errors.d.ts

@@ -25,6 +25,10 @@ export declare class UnsupportedPreLiquidationParamsError extends Error {
     readonly lltv: bigint;
     constructor(lltv: bigint);
 }
+export declare class UnsupportedVaultV2AdapterError extends Error {
+    readonly address: Address;
+    constructor(address: Address);
+}
 export declare namespace BlueErrors {
     class AlreadySet extends Error {
         readonly name: string;
@@ -65,6 +69,18 @@ export declare namespace BlueErrors {
         constructor(deadline: bigint);
     }
 }
+export declare namespace VaultV2Errors {
+    class InvalidInterestAccrual extends Error {
+        readonly vault: Address;
+        readonly timestamp: bigint;
+        readonly lastUpdate: bigint;
+        constructor(vault: Address, timestamp: bigint, lastUpdate: bigint);
+    }
+    class UnsupportedLiquidityAdapter extends Error {
+        readonly address: Address;
+        constructor(address: Address);
+    }
+}
 export interface ErrorClass<E extends Error> {
     new (...args: any[]): E;
 }

package/lib/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlueErrors = exports.UnsupportedPreLiquidationParamsError = exports.UnsupportedChainIdError = exports.UnknownVaultConfigError = exports.UnknownMarketParamsError = exports.UnknownTokenPriceError = exports.UnknownTokenError = exports.UnknownDataError = void 0;
+exports.VaultV2Errors = exports.BlueErrors = exports.UnsupportedVaultV2AdapterError = exports.UnsupportedPreLiquidationParamsError = exports.UnsupportedChainIdError = exports.UnknownVaultConfigError = exports.UnknownMarketParamsError = exports.UnknownTokenPriceError = exports.UnknownTokenError = exports.UnknownDataError = void 0;
 exports._try = _try;
 const viem_1 = require("viem");
 class UnknownDataError extends Error {
@@ -54,6 +54,14 @@ class UnsupportedPreLiquidationParamsError extends Error {
     }
 }
 exports.UnsupportedPreLiquidationParamsError = UnsupportedPreLiquidationParamsError;
+class UnsupportedVaultV2AdapterError extends Error {
+    address;
+    constructor(address) {
+        super(`vault v2 adapter "${address}" is not supported`);
+        this.address = address;
+    }
+}
+exports.UnsupportedVaultV2AdapterError = UnsupportedVaultV2AdapterError;
 var BlueErrors;
 (function (BlueErrors) {
     class AlreadySet extends Error {
@@ -133,6 +141,29 @@ var BlueErrors;
     }
     BlueErrors.ExpiredSignature = ExpiredSignature;
 })(BlueErrors || (exports.BlueErrors = BlueErrors = {}));
+var VaultV2Errors;
+(function (VaultV2Errors) {
+    class InvalidInterestAccrual extends Error {
+        vault;
+        timestamp;
+        lastUpdate;
+        constructor(vault, timestamp, lastUpdate) {
+            super(`invalid interest accrual on vault ${vault}: accrual timestamp ${timestamp} can't be prior to last update ${lastUpdate}`);
+            this.vault = vault;
+            this.timestamp = timestamp;
+            this.lastUpdate = lastUpdate;
+        }
+    }
+    VaultV2Errors.InvalidInterestAccrual = InvalidInterestAccrual;
+    class UnsupportedLiquidityAdapter extends Error {
+        address;
+        constructor(address) {
+            super(`unsupported liquidity adapter "${address}"`);
+            this.address = address;
+        }
+    }
+    VaultV2Errors.UnsupportedLiquidityAdapter = UnsupportedLiquidityAdapter;
+})(VaultV2Errors || (exports.VaultV2Errors = VaultV2Errors = {}));
 function _try(accessor, ...errorClasses) {
     const maybeCatchError = (error) => {
         if (errorClasses.length === 0 ||

package/lib/index.d.ts

@@ -11,3 +11,4 @@ export * from "./holding/index.js";
 export * from "./position/index.js";
 export * from "./vault/index.js";
 export * from "./preLiquidation.js";
+export * from "./utils.js";

package/lib/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./holding/index.js"), exports);
 __exportStar(require("./position/index.js"), exports);
 __exportStar(require("./vault/index.js"), exports);
 __exportStar(require("./preLiquidation.js"), exports);
+__exportStar(require("./utils.js"), exports);

package/lib/market/Market.d.ts

@@ -1,17 +1,7 @@
 import { type RoundingDirection } from "../math/index.js";
 import type { BigIntish } from "../types.js";
+import { type CapacityLimit } from "../utils.js";
 import { type IMarketParams, MarketParams } from "./MarketParams.js";
-export declare enum CapacityLimitReason {
-    liquidity = "Liquidity",
-    balance = "Balance",
-    position = "Position",
-    collateral = "Collateral",
-    cap = "Cap"
-}
-export interface CapacityLimit {
-    value: bigint;
-    limiter: CapacityLimitReason;
-}
 export interface MaxBorrowOptions {
     maxLtv?: bigint;
 }

package/lib/market/Market.js

@@ -1,19 +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 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.
  */
@@ -497,11 +490,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,
         };
     }
     /**
@@ -514,11 +507,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,
         };
     }
     /**
@@ -532,11 +525,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,
         };
     }
     /**
@@ -552,11 +545,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,
         };
     }
     /**
@@ -570,14 +563,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/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/utils.d.ts

@@ -0,0 +1,13 @@
+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;
+}

package/lib/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = {}));

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;
@@ -178,11 +178,31 @@ export declare class AccrualVault extends Vault implements IAccrualVault {
      */
     getNetApy(timestamp?: BigIntish): number;
     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`.
      */
-    accrueInterest(timestamp: BigIntish): AccrualVault;
+    accrueInterest(timestamp?: BigIntish): AccrualVault;
 }

package/lib/vault/Vault.js

@@ -5,6 +5,7 @@ const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const index_js_1 = require("../market/index.js");
 const index_js_2 = require("../math/index.js");
 const index_js_3 = require("../token/index.js");
+const utils_js_1 = require("../utils.js");
 const VaultMarketAllocation_js_1 = require("./VaultMarketAllocation.js");
 class Vault extends index_js_3.VaultToken {
     /**
@@ -208,7 +209,28 @@ class AccrualVault extends Vault {
             return 0n;
         return index_js_2.MathLib.wDivDown(allocation.position.supplyAssets, this.totalAssets);
     }
+    /**
+     * 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) {
+        return this.maxDeposit(assets);
+    }
+    /**
+     * 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) {
+        return this.maxWithdraw(shares);
+    }
+    /**
+     * Returns the maximum amount of assets that can be deposited to the vault.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(assets) {
+        assets = BigInt(assets);
         const suppliable = this.allocations
             .values()
             .reduce((total, { config: { cap }, position: { marketId, supplyAssets } }) => index_js_2.MathLib.min(total +
@@ -218,24 +240,28 @@ class AccrualVault extends Vault {
         if (assets > suppliable)
             return {
                 value: suppliable,
-                limiter: index_js_1.CapacityLimitReason.cap,
+                limiter: utils_js_1.CapacityLimitReason.cap,
             };
         return {
             value: assets,
-            limiter: index_js_1.CapacityLimitReason.balance,
+            limiter: utils_js_1.CapacityLimitReason.balance,
         };
     }
-    getWithdrawCapacityLimit(shares) {
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from the vault.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(shares) {
         const assets = this.toAssets(shares);
         const { liquidity } = this;
         if (assets > liquidity)
             return {
                 value: liquidity,
-                limiter: index_js_1.CapacityLimitReason.liquidity,
+                limiter: utils_js_1.CapacityLimitReason.liquidity,
             };
         return {
             value: assets,
-            limiter: index_js_1.CapacityLimitReason.balance,
+            limiter: utils_js_1.CapacityLimitReason.balance,
         };
     }
     /**

package/lib/vault/index.d.ts

@@ -5,3 +5,4 @@ export * from "./VaultMarketConfig.js";
 export * from "./VaultMarketPublicAllocatorConfig.js";
 export * from "./VaultUser.js";
 export * from "./Vault.js";
+export * from "./v2";

package/lib/vault/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./VaultMarketConfig.js"), exports);
 __exportStar(require("./VaultMarketPublicAllocatorConfig.js"), exports);
 __exportStar(require("./VaultUser.js"), exports);
 __exportStar(require("./Vault.js"), exports);
+__exportStar(require("./v2"), exports);

package/lib/vault/v2/VaultV2.d.ts

@@ -0,0 +1,87 @@
+import { type Address, type Hash, type Hex } from "viem";
+import { type RoundingDirection } from "../../math";
+import { type IToken, WrappedToken } from "../../token";
+import type { BigIntish } from "../../types";
+import { type CapacityLimit } from "../../utils";
+import type { IAccrualVaultV2Adapter } from "./VaultV2Adapter";
+export interface IVaultV2Allocation {
+    id: Hash;
+    absoluteCap: bigint;
+    relativeCap: bigint;
+    allocation: bigint;
+}
+export interface IVaultV2 extends IToken {
+    asset: Address;
+    /**
+     * The total assets, *including* virtually accrued interest.
+     */
+    totalAssets: bigint;
+    /**
+     * The total assets, *excluding* virtually accrued interest.
+     */
+    _totalAssets: bigint;
+    /**
+     * The total supply of shares.
+     */
+    totalSupply: bigint;
+    virtualShares: bigint;
+    maxRate: bigint;
+    lastUpdate: bigint;
+    adapters: Address[];
+    liquidityAdapter: Address;
+    liquidityData: Hex;
+    liquidityAllocations: IVaultV2Allocation[] | undefined;
+    performanceFee: bigint;
+    managementFee: bigint;
+    performanceFeeRecipient: Address;
+    managementFeeRecipient: Address;
+}
+export declare class VaultV2 extends WrappedToken implements IVaultV2 {
+    readonly asset: Address;
+    totalAssets: bigint;
+    _totalAssets: bigint;
+    totalSupply: bigint;
+    virtualShares: bigint;
+    maxRate: bigint;
+    lastUpdate: bigint;
+    adapters: `0x${string}`[];
+    liquidityAdapter: `0x${string}`;
+    liquidityData: `0x${string}`;
+    liquidityAllocations: IVaultV2Allocation[] | undefined;
+    performanceFee: bigint;
+    managementFee: bigint;
+    performanceFeeRecipient: `0x${string}`;
+    managementFeeRecipient: `0x${string}`;
+    constructor({ asset, totalAssets, _totalAssets, totalSupply, virtualShares, maxRate, lastUpdate, adapters, liquidityAdapter, liquidityData, liquidityAllocations, performanceFee, managementFee, performanceFeeRecipient, managementFeeRecipient, ...config }: IVaultV2);
+    toAssets(shares: BigIntish): bigint;
+    toShares(assets: BigIntish): bigint;
+    protected _wrap(amount: BigIntish, rounding: RoundingDirection): bigint;
+    protected _unwrap(amount: BigIntish, rounding: RoundingDirection): bigint;
+}
+export interface IAccrualVaultV2 extends Omit<IVaultV2, "adapters"> {
+}
+export declare class AccrualVaultV2 extends VaultV2 implements IAccrualVaultV2 {
+    accrualLiquidityAdapter: IAccrualVaultV2Adapter | undefined;
+    accrualAdapters: IAccrualVaultV2Adapter[];
+    assetBalance: bigint;
+    constructor(vault: IAccrualVaultV2, accrualLiquidityAdapter: IAccrualVaultV2Adapter | undefined, accrualAdapters: IAccrualVaultV2Adapter[], assetBalance: bigint);
+    /**
+     * 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 the vault's `lastUpdate`.
+     */
+    accrueInterest(timestamp: BigIntish): {
+        vault: AccrualVaultV2;
+        performanceFeeShares: bigint;
+        managementFeeShares: bigint;
+    };
+}

package/lib/vault/v2/VaultV2.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualVaultV2 = exports.VaultV2 = void 0;
+const viem_1 = require("viem");
+const errors_1 = require("../../errors");
+const math_1 = require("../../math");
+const token_1 = require("../../token");
+const utils_1 = require("../../utils");
+class VaultV2 extends token_1.WrappedToken {
+    asset;
+    totalAssets;
+    _totalAssets;
+    totalSupply;
+    virtualShares;
+    maxRate;
+    lastUpdate;
+    adapters;
+    liquidityAdapter;
+    liquidityData;
+    liquidityAllocations;
+    performanceFee;
+    managementFee;
+    performanceFeeRecipient;
+    managementFeeRecipient;
+    constructor({ asset, totalAssets, _totalAssets, totalSupply, virtualShares, maxRate, lastUpdate, adapters, liquidityAdapter, liquidityData, liquidityAllocations, performanceFee, managementFee, performanceFeeRecipient, managementFeeRecipient, ...config }) {
+        super(config, asset);
+        this.asset = asset;
+        this.totalAssets = totalAssets;
+        this._totalAssets = _totalAssets;
+        this.totalSupply = totalSupply;
+        this.virtualShares = virtualShares;
+        this.maxRate = maxRate;
+        this.lastUpdate = lastUpdate;
+        this.adapters = adapters;
+        this.liquidityAdapter = liquidityAdapter;
+        this.liquidityData = liquidityData;
+        this.liquidityAllocations = liquidityAllocations;
+        this.performanceFee = performanceFee;
+        this.managementFee = managementFee;
+        this.performanceFeeRecipient = performanceFeeRecipient;
+        this.managementFeeRecipient = managementFeeRecipient;
+    }
+    toAssets(shares) {
+        return this._unwrap(shares, "Down");
+    }
+    toShares(assets) {
+        return this._wrap(assets, "Down");
+    }
+    _wrap(amount, rounding) {
+        return math_1.MathLib.mulDiv(amount, this.totalSupply + this.virtualShares, this.totalAssets + 1n, rounding);
+    }
+    _unwrap(amount, rounding) {
+        return math_1.MathLib.mulDiv(amount, this.totalAssets + 1n, this.totalSupply + this.virtualShares, rounding);
+    }
+}
+exports.VaultV2 = VaultV2;
+class AccrualVaultV2 extends VaultV2 {
+    accrualLiquidityAdapter;
+    accrualAdapters;
+    assetBalance;
+    constructor(vault, accrualLiquidityAdapter, accrualAdapters, assetBalance) {
+        super({ ...vault, adapters: accrualAdapters.map((a) => a.address) });
+        this.accrualLiquidityAdapter = accrualLiquidityAdapter;
+        this.accrualAdapters = accrualAdapters;
+        this.assetBalance = assetBalance;
+    }
+    /**
+     * Returns the maximum amount of assets that can be deposited to the vault.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(assets) {
+        if (this.liquidityAdapter === viem_1.zeroAddress)
+            return { value: BigInt(assets), limiter: utils_1.CapacityLimitReason.balance };
+        let liquidityAdapterLimit;
+        if (this.accrualLiquidityAdapter != null)
+            liquidityAdapterLimit = this.accrualLiquidityAdapter.maxDeposit(this.liquidityData, assets);
+        if (this.liquidityAllocations == null || liquidityAdapterLimit == null)
+            throw new errors_1.VaultV2Errors.UnsupportedLiquidityAdapter(this.liquidityAdapter);
+        // At this stage: `liquidityAdapterLimit.value <= assets`
+        for (const { absoluteCap, relativeCap, allocation } of this
+            .liquidityAllocations) {
+            // `absoluteCap` can be set lower than `allocation`.
+            const absoluteMaxDeposit = math_1.MathLib.zeroFloorSub(absoluteCap, allocation);
+            if (liquidityAdapterLimit.value > absoluteMaxDeposit)
+                return {
+                    value: absoluteMaxDeposit,
+                    limiter: utils_1.CapacityLimitReason.vaultV2_absoluteCap,
+                };
+            if (relativeCap !== math_1.MathLib.WAD) {
+                // `relativeCap` can be set lower than `allocation / totalAssets`.
+                const relativeMaxDeposit = math_1.MathLib.zeroFloorSub(math_1.MathLib.wMulDown(this.totalAssets, relativeCap), allocation);
+                if (liquidityAdapterLimit.value > relativeMaxDeposit)
+                    return {
+                        value: relativeMaxDeposit,
+                        limiter: utils_1.CapacityLimitReason.vaultV2_relativeCap,
+                    };
+            }
+        }
+        return liquidityAdapterLimit;
+    }
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from the vault.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(shares) {
+        const assets = this.toAssets(shares);
+        if (this.liquidityAdapter === viem_1.zeroAddress)
+            return { value: BigInt(assets), limiter: utils_1.CapacityLimitReason.balance };
+        let liquidity = this.assetBalance;
+        if (this.accrualLiquidityAdapter != null)
+            liquidity += this.accrualLiquidityAdapter.maxWithdraw(this.liquidityData).value;
+        if (assets > liquidity)
+            return {
+                value: liquidity,
+                limiter: utils_1.CapacityLimitReason.liquidity,
+            };
+        return {
+            value: assets,
+            limiter: utils_1.CapacityLimitReason.balance,
+        };
+    }
+    /**
+     * 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 the vault's `lastUpdate`.
+     */
+    accrueInterest(timestamp) {
+        const vault = new AccrualVaultV2(this, this.accrualLiquidityAdapter, this.accrualAdapters, this.assetBalance);
+        timestamp = BigInt(timestamp);
+        const elapsed = timestamp - this.lastUpdate;
+        if (elapsed < 0n)
+            throw new errors_1.VaultV2Errors.InvalidInterestAccrual(this.address, timestamp, this.lastUpdate);
+        // Corresponds to the `firstTotalAssets == 0` onchain check.
+        if (elapsed === 0n)
+            return { vault, performanceFeeShares: 0n, managementFeeShares: 0n };
+        const realAssets = vault.accrualAdapters.reduce((curr, adapter) => curr + adapter.realAssets(timestamp), vault.assetBalance);
+        const maxTotalAssets = vault._totalAssets +
+            math_1.MathLib.wMulDown(vault._totalAssets * elapsed, vault.maxRate);
+        const newTotalAssets = math_1.MathLib.min(realAssets, maxTotalAssets);
+        const interest = math_1.MathLib.zeroFloorSub(newTotalAssets, vault._totalAssets);
+        const performanceFeeAssets = interest > 0n && vault.performanceFee > 0n
+            ? math_1.MathLib.wMulDown(interest, vault.performanceFee)
+            : 0n;
+        const managementFeeAssets = elapsed > 0n && vault.managementFee > 0n
+            ? math_1.MathLib.wMulDown(newTotalAssets * elapsed, vault.managementFee)
+            : 0n;
+        const newTotalAssetsWithoutFees = newTotalAssets - performanceFeeAssets - managementFeeAssets;
+        const performanceFeeShares = math_1.MathLib.mulDivDown(performanceFeeAssets, vault.totalSupply + vault.virtualShares, newTotalAssetsWithoutFees + 1n);
+        const managementFeeShares = math_1.MathLib.mulDivDown(managementFeeAssets, vault.totalSupply + vault.virtualShares, newTotalAssetsWithoutFees + 1n);
+        vault.totalAssets = newTotalAssets;
+        vault._totalAssets = newTotalAssets;
+        if (performanceFeeShares)
+            vault.totalSupply += performanceFeeShares;
+        if (managementFeeShares)
+            vault.totalSupply += managementFeeShares;
+        vault.lastUpdate = BigInt(timestamp);
+        return { vault, performanceFeeShares, managementFeeShares };
+    }
+}
+exports.AccrualVaultV2 = AccrualVaultV2;

package/lib/vault/v2/VaultV2Adapter.d.ts

@@ -0,0 +1,29 @@
+import type { Address, Hash, Hex } from "viem";
+import type { BigIntish } from "../../types";
+import type { CapacityLimit } from "../../utils";
+export interface IVaultV2Adapter {
+    address: Address;
+    parentVault: Address;
+    adapterId: Hash;
+    skimRecipient: Address;
+}
+export declare abstract class VaultV2Adapter implements IVaultV2Adapter {
+    readonly address: Address;
+    readonly parentVault: Address;
+    readonly adapterId: Hash;
+    skimRecipient: Address;
+    constructor({ address, parentVault, adapterId, skimRecipient, }: IVaultV2Adapter);
+}
+export interface IAccrualVaultV2Adapter extends IVaultV2Adapter {
+    realAssets(timestamp: BigIntish): bigint;
+    /**
+     * Returns the maximum amount of assets that can be deposited to this adapter.
+     * @param assets The maximum amount of assets to deposit.
+     */
+    maxDeposit(data: Hex, assets: BigIntish): CapacityLimit;
+    /**
+     * Returns the maximum amount of assets that can be withdrawn from this adapter.
+     * @param shares The maximum amount of shares to redeem.
+     */
+    maxWithdraw(data: Hex): CapacityLimit;
+}

package/lib/vault/v2/VaultV2Adapter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultV2Adapter = void 0;
+class VaultV2Adapter {
+    address;
+    parentVault;
+    adapterId;
+    skimRecipient;
+    constructor({ address, parentVault, adapterId, skimRecipient, }) {
+        this.address = address;
+        this.parentVault = parentVault;
+        this.adapterId = adapterId;
+        this.skimRecipient = skimRecipient;
+    }
+}
+exports.VaultV2Adapter = VaultV2Adapter;

package/lib/vault/v2/VaultV2MorphoMarketV1Adapter.d.ts

@@ -0,0 +1,30 @@
+import { type Address, type Hex } from "viem";
+import { type IMarketParams, MarketParams } from "../../market";
+import type { AccrualPosition } from "../../position";
+import type { BigIntish } from "../../types";
+import { CapacityLimitReason } from "../../utils";
+import { VaultV2Adapter } from "./VaultV2Adapter";
+import type { IAccrualVaultV2Adapter, IVaultV2Adapter } from "./VaultV2Adapter";
+export interface IVaultV2MorphoMarketV1Adapter extends Omit<IVaultV2Adapter, "adapterId"> {
+    marketParamsList: IMarketParams[];
+}
+export declare class VaultV2MorphoMarketV1Adapter extends VaultV2Adapter implements IVaultV2MorphoMarketV1Adapter {
+    static adapterId(address: Address): `0x${string}`;
+    static collateralId(address: Address): `0x${string}`;
+    static marketParamsId(address: Address, params: MarketParams): `0x${string}`;
+    marketParamsList: MarketParams[];
+    constructor({ marketParamsList, ...vaultV2Adapter }: IVaultV2MorphoMarketV1Adapter);
+    ids(params: MarketParams): `0x${string}`[];
+}
+export interface IAccrualVaultV2MorphoMarketV1Adapter extends IVaultV2MorphoMarketV1Adapter {
+}
+export declare class AccrualVaultV2MorphoMarketV1Adapter extends VaultV2MorphoMarketV1Adapter implements IAccrualVaultV2MorphoMarketV1Adapter, IAccrualVaultV2Adapter {
+    positions: AccrualPosition[];
+    constructor(adapter: IAccrualVaultV2MorphoMarketV1Adapter, positions: AccrualPosition[]);
+    realAssets(timestamp?: BigIntish): bigint;
+    maxDeposit(_data: Hex, assets: BigIntish): {
+        value: bigint;
+        limiter: CapacityLimitReason;
+    };
+    maxWithdraw(_data: Hex): import("../../utils").CapacityLimit;
+}

package/lib/vault/v2/VaultV2MorphoMarketV1Adapter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualVaultV2MorphoMarketV1Adapter = exports.VaultV2MorphoMarketV1Adapter = void 0;
+const viem_1 = require("viem");
+const market_1 = require("../../market");
+const utils_1 = require("../../utils");
+const VaultV2Adapter_1 = require("./VaultV2Adapter");
+const marketParamsAbi = {
+    type: "tuple",
+    components: [
+        { type: "address", name: "loanToken" },
+        { type: "address", name: "collateralToken" },
+        { type: "address", name: "oracle" },
+        { type: "address", name: "irm" },
+        { type: "uint256", name: "lltv" },
+    ],
+};
+class VaultV2MorphoMarketV1Adapter extends VaultV2Adapter_1.VaultV2Adapter {
+    static adapterId(address) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: "string" }, { type: "address" }], ["this", address]));
+    }
+    static collateralId(address) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: "string" }, { type: "address" }], ["collateralToken", address]));
+    }
+    static marketParamsId(address, params) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: "string" }, { type: "address" }, marketParamsAbi], ["this/marketParams", address, params]));
+    }
+    marketParamsList;
+    constructor({ marketParamsList, ...vaultV2Adapter }) {
+        super({
+            ...vaultV2Adapter,
+            adapterId: VaultV2MorphoMarketV1Adapter.adapterId(vaultV2Adapter.address),
+        });
+        this.marketParamsList = marketParamsList.map((params) => new market_1.MarketParams(params));
+    }
+    ids(params) {
+        return [
+            this.adapterId,
+            VaultV2MorphoMarketV1Adapter.collateralId(params.collateralToken),
+            VaultV2MorphoMarketV1Adapter.marketParamsId(this.address, params),
+        ];
+    }
+}
+exports.VaultV2MorphoMarketV1Adapter = VaultV2MorphoMarketV1Adapter;
+class AccrualVaultV2MorphoMarketV1Adapter extends VaultV2MorphoMarketV1Adapter {
+    positions;
+    constructor(adapter, positions) {
+        super(adapter);
+        this.positions = positions;
+    }
+    realAssets(timestamp) {
+        return this.positions.reduce((total, position) => total + position.accrueInterest(timestamp).supplyAssets, 0n);
+    }
+    maxDeposit(_data, assets) {
+        return {
+            value: BigInt(assets),
+            limiter: utils_1.CapacityLimitReason.balance,
+        };
+    }
+    maxWithdraw(_data) {
+        const [marketParams] = (0, viem_1.decodeAbiParameters)([marketParamsAbi], _data);
+        const marketId = new market_1.MarketParams(marketParams).id;
+        const position = this.positions.find((position) => position.marketId === marketId);
+        return (position?.market?.getWithdrawCapacityLimit(position) ?? {
+            value: 0n,
+            limiter: utils_1.CapacityLimitReason.position,
+        });
+    }
+}
+exports.AccrualVaultV2MorphoMarketV1Adapter = AccrualVaultV2MorphoMarketV1Adapter;

package/lib/vault/v2/VaultV2MorphoVaultV1Adapter.d.ts

@@ -0,0 +1,24 @@
+import { type Address, type Hex } from "viem";
+import { VaultV2Adapter } from "./VaultV2Adapter";
+export interface IVaultV2MorphoVaultV1Adapter extends Omit<IVaultV2Adapter, "adapterId"> {
+    morphoVaultV1: Address;
+}
+import type { BigIntish } from "../../types";
+import type { AccrualVault } from "../Vault";
+import type { IAccrualVaultV2Adapter, IVaultV2Adapter } from "./VaultV2Adapter";
+export declare class VaultV2MorphoVaultV1Adapter extends VaultV2Adapter implements IVaultV2MorphoVaultV1Adapter {
+    static adapterId(address: Address): `0x${string}`;
+    readonly morphoVaultV1: Address;
+    constructor({ morphoVaultV1, ...vaultV2Adapter }: IVaultV2MorphoVaultV1Adapter);
+    ids(): `0x${string}`[];
+}
+export interface IAccrualVaultV2MorphoVaultV1Adapter extends IVaultV2MorphoVaultV1Adapter {
+}
+export declare class AccrualVaultV2MorphoVaultV1Adapter extends VaultV2MorphoVaultV1Adapter implements IAccrualVaultV2MorphoVaultV1Adapter, IAccrualVaultV2Adapter {
+    accrualVaultV1: AccrualVault;
+    shares: bigint;
+    constructor(adapter: IAccrualVaultV2MorphoVaultV1Adapter, accrualVaultV1: AccrualVault, shares: bigint);
+    realAssets(timestamp?: BigIntish): bigint;
+    maxDeposit(_data: Hex, assets: BigIntish): import("../..").CapacityLimit;
+    maxWithdraw(_data: Hex): import("../..").CapacityLimit;
+}

package/lib/vault/v2/VaultV2MorphoVaultV1Adapter.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualVaultV2MorphoVaultV1Adapter = exports.VaultV2MorphoVaultV1Adapter = void 0;
+const viem_1 = require("viem");
+const VaultV2Adapter_1 = require("./VaultV2Adapter");
+class VaultV2MorphoVaultV1Adapter extends VaultV2Adapter_1.VaultV2Adapter {
+    static adapterId(address) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: "string" }, { type: "address" }], ["this", address]));
+    }
+    morphoVaultV1;
+    constructor({ morphoVaultV1, ...vaultV2Adapter }) {
+        super({
+            ...vaultV2Adapter,
+            adapterId: VaultV2MorphoVaultV1Adapter.adapterId(vaultV2Adapter.address),
+        });
+        this.morphoVaultV1 = morphoVaultV1;
+    }
+    ids() {
+        return [this.adapterId];
+    }
+}
+exports.VaultV2MorphoVaultV1Adapter = VaultV2MorphoVaultV1Adapter;
+class AccrualVaultV2MorphoVaultV1Adapter extends VaultV2MorphoVaultV1Adapter {
+    accrualVaultV1;
+    shares;
+    constructor(adapter, accrualVaultV1, shares) {
+        super(adapter);
+        this.accrualVaultV1 = accrualVaultV1;
+        this.shares = shares;
+    }
+    realAssets(timestamp) {
+        return this.accrualVaultV1.accrueInterest(timestamp).toAssets(this.shares);
+    }
+    maxDeposit(_data, assets) {
+        return this.accrualVaultV1.maxDeposit(assets);
+    }
+    maxWithdraw(_data) {
+        return this.accrualVaultV1.maxWithdraw(this.shares);
+    }
+}
+exports.AccrualVaultV2MorphoVaultV1Adapter = AccrualVaultV2MorphoVaultV1Adapter;

package/lib/vault/v2/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./VaultV2.js";
+export * from "./VaultV2Adapter.js";
+export * from "./VaultV2MorphoMarketV1Adapter.js";
+export * from "./VaultV2MorphoVaultV1Adapter.js";

package/lib/vault/v2/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./VaultV2.js"), exports);
+__exportStar(require("./VaultV2Adapter.js"), exports);
+__exportStar(require("./VaultV2MorphoMarketV1Adapter.js"), exports);
+__exportStar(require("./VaultV2MorphoVaultV1Adapter.js"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/blue-sdk",
   "description": "Framework-agnostic package that defines Morpho-related entity classes (such as `Market`, `Token`, `Vault`).",
-  "version": "5.2.0",
+  "version": "5.3.0-next.1",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -29,10 +29,10 @@
   },
   "devDependencies": {
     "typescript": "^5.7.2",
-    "viem": "^2.23.0",
+    "viem": "^2.33.3",
     "vitest": "^3.0.5",
-    "@morpho-org/morpho-ts": "^2.4.3",
-    "@morpho-org/test": "^2.6.0"
+    "@morpho-org/test": "^2.6.0",
+    "@morpho-org/morpho-ts": "^2.4.3"
   },
   "scripts": {
     "prepublish": "$npm_execpath build",