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

package/lib/vault/Vault.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccrualVault = exports.Vault = void 0;
 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 index_js_1 = require("../math/index.js");
+const index_js_2 = 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 {
+class Vault extends index_js_2.VaultToken {
     /**
      * The MetaMorpho vault's owner address.
      */
@@ -93,7 +93,7 @@ class Vault extends index_js_3.VaultToken {
      * The amount of interest in assets accrued since the last interaction with the vault.
      */
     get totalInterest() {
-        return index_js_2.MathLib.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
+        return index_js_1.MathLib.zeroFloorSub(this.totalAssets, this.lastTotalAssets);
     }
     toAssets(shares, rounding = "Down") {
         return this._unwrap(shares, rounding);
@@ -155,7 +155,7 @@ class AccrualVault extends Vault {
     }
     /**
      * 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() {
@@ -163,42 +163,32 @@ class AccrualVault extends Vault {
     }
     /**
      * The MetaMorpho vault's current instantaneous Annual Percentage Yield (APY)
-     * weighted-averaged over its market deposits, after deducting the performance fee.
-     * If interested in the APY at a specific timestamp, use `getNetApy(timestamp)` instead.
+     * 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() {
         return this.getNetApy();
     }
     /**
-     * The MetaMorpho vault's per-second rate at which interest _would_ accrue,
+     * 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).
      */
-    _getAvgRate(timestamp = morpho_ts_1.Time.timestamp()) {
+    getApy(timestamp = morpho_ts_1.Time.timestamp()) {
         if (this.totalAssets === 0n)
             return 0n;
         return (this.allocations
             .values()
             .reduce((total, { position }) => total +
-            position.market.getAvgSupplyRate(timestamp) * position.supplyAssets, 0n) / this.totalAssets);
-    }
-    /**
-     * 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.
-     */
-    getApy(timestamp = morpho_ts_1.Time.timestamp()) {
-        if (this.totalAssets === 0n)
-            return 0;
-        return index_js_1.MarketUtils.rateToApy(this._getAvgRate(timestamp));
+            position.market.getAvgSupplyApy(timestamp) * position.supplyAssets, 0n) / this.totalAssets);
     }
     /**
      * 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 = morpho_ts_1.Time.timestamp()) {
-        return index_js_1.MarketUtils.rateToApy(index_js_2.MathLib.wMulDown(this._getAvgRate(timestamp), index_js_2.MathLib.WAD - this.fee));
+        return index_js_1.MathLib.wMulDown(this.getApy(timestamp), index_js_1.MathLib.WAD - this.fee);
     }
     getAllocationProportion(marketId) {
         if (this.totalAssets === 0n)
@@ -206,36 +196,61 @@ class AccrualVault extends Vault {
         const allocation = this.allocations.get(marketId);
         if (!allocation)
             return 0n;
-        return index_js_2.MathLib.wDivDown(allocation.position.supplyAssets, this.totalAssets);
+        return index_js_1.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 +
+            .reduce((total, { config: { cap }, position: { marketId, supplyAssets } }) => index_js_1.MathLib.min(total +
             (this.supplyQueue.includes(marketId)
-                ? index_js_2.MathLib.zeroFloorSub(cap, supplyAssets)
-                : 0n), index_js_2.MathLib.MAX_UINT_256), 0n);
+                ? index_js_1.MathLib.zeroFloorSub(cap, supplyAssets)
+                : 0n), index_js_1.MathLib.MAX_UINT_256), 0n);
         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,
         };
     }
     /**
@@ -253,10 +268,10 @@ class AccrualVault extends Vault {
             };
         }));
         if (vault.lostAssets != null) {
-            vault.lostAssets += index_js_2.MathLib.max(vault.lastTotalAssets - vault.lostAssets - vault.totalAssets, 0n);
+            vault.lostAssets += index_js_1.MathLib.max(vault.lastTotalAssets - vault.lostAssets - vault.totalAssets, 0n);
             vault.totalAssets += vault.lostAssets;
         }
-        const feeAssets = index_js_2.MathLib.wMulDown(vault.totalInterest, vault.fee);
+        const feeAssets = index_js_1.MathLib.wMulDown(vault.totalInterest, vault.fee);
         vault.totalAssets -= feeAssets;
         const feeShares = vault.toShares(feeAssets, "Down");
         vault.totalAssets += feeAssets;

package/lib/vault/VaultMarketAllocation.d.ts

@@ -1,7 +1,7 @@
 import type { AccrualPosition } from "../position/index.js";
-import { type IVaultMarketConfig, VaultMarketConfig } from "./VaultMarketConfig.js";
+import type { VaultMarketConfig } from "./VaultMarketConfig.js";
 export interface IVaultMarketAllocation {
-    config: IVaultMarketConfig;
+    config: VaultMarketConfig;
     position: AccrualPosition;
 }
 export declare class VaultMarketAllocation implements IVaultMarketAllocation {

package/lib/vault/VaultMarketAllocation.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultMarketAllocation = void 0;
 const index_js_1 = require("../math/index.js");
-const VaultMarketConfig_js_1 = require("./VaultMarketConfig.js");
 class VaultMarketAllocation {
     /**
      * The vault's configuration on the corresponding market.
@@ -13,7 +12,7 @@ class VaultMarketAllocation {
      */
     position;
     constructor({ config, position }) {
-        this.config = new VaultMarketConfig_js_1.VaultMarketConfig(config);
+        this.config = config;
         this.position = position;
     }
     get vault() {

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,160 @@
+"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");
+const VaultV2MorphoVaultV1Adapter_1 = require("./VaultV2MorphoVaultV1Adapter");
+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 instanceof VaultV2MorphoVaultV1Adapter_1.AccrualVaultV2MorphoVaultV1Adapter) {
+            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,
+                };
+            // `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 &&
+                relativeCap !== math_1.MathLib.WAD)
+                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 instanceof VaultV2MorphoVaultV1Adapter_1.AccrualVaultV2MorphoVaultV1Adapter)
+            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/VaultV2MorphoVaultV1Adapter.d.ts

@@ -0,0 +1,24 @@
+import { type Address, type Hex } from "viem";
+import { VaultV2Adapter } from "./VaultV2Adapter";
+export interface IVaultV2MorphoVaultV1Adapter extends IVaultV2Adapter {
+    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,3 @@
+export * from "./VaultV2.js";
+export * from "./VaultV2Adapter.js";
+export * from "./VaultV2MorphoVaultV1Adapter.js";

package/lib/vault/v2/index.js

@@ -0,0 +1,19 @@
+"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("./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.1.1",
+  "version": "5.2.0-next.0",
   "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/test": "^2.6.0",
-    "@morpho-org/morpho-ts": "^2.4.3"
+    "@morpho-org/morpho-ts": "^2.4.3",
+    "@morpho-org/test": "^2.6.0"
   },
   "scripts": {
     "prepublish": "$npm_execpath build",