@morpho-org/blue-sdk 5.4.0 → 5.6.0

package/lib/addresses.d.ts

@@ -450,6 +450,24 @@ declare const _addressesRegistry: {
         readonly preLiquidationFactory: "0x534858821653467c2ae231dc027aa1F2c8D91802";
         readonly wNative: "0x1Cd0690fF9a693f5EF2dD976660a8dAFc81A109c";
     };
+    readonly 59144: {
+        readonly morpho: "0x6B0D716aC0A45536172308e08fC2C40387262c9F";
+        readonly bundler3: {
+            readonly bundler3: "0x1Ee8Ec299E8014760D50A4E3CfC3b44Cc2242625";
+            readonly generalAdapter1: "0x454dAb6ce9891245696b239b4845a1cDC268255d";
+        };
+        readonly adaptiveCurveIrm: "0x85C2Ef4Bd69f42D7Da19Fb9dcdD7Fb8d0F59cDeE";
+        readonly publicAllocator: "0x2d4cf00e18D48fD030d9b1E2FAAE6e0384C7610B";
+        readonly metaMorphoFactory: "0xA148a8223B622A72dC36472DE1492aBb5c089BA7";
+        readonly vaultV2Factory: "0x5DC11CF8BA4C39d1194F91218D35008d9F52A5d0";
+        readonly morphoMarketV1AdapterFactory: "0x3267BbdC94274B4BE081c01ffc6123dA12E8c043";
+        readonly morphoVaultV1AdapterFactory: "0x6FaF26DD640e22457cA4fd5DA702BA3E169eEd87";
+        readonly registryList: "0x122Ea8ff8888C29F8736665d576e3fAEF15D27D5";
+        readonly chainlinkOracleFactory: "0x3FFF726062B03BfD5BC485eeEEcc92CF1d8F0105";
+        readonly preLiquidationFactory: "0x05a0Ff4E564ED1ba6B42247E19edFf83545C3C40";
+        readonly wNative: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f";
+        readonly usdc: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff";
+    };
     readonly 143: {
         readonly morpho: "0xD5D960E8C380B724a48AC59E2DfF1b2CB4a1eAee";
         readonly bundler3: {
@@ -816,6 +834,22 @@ declare const _deployments: {
         readonly chainlinkOracleFactory: 7526768n;
         readonly preLiquidationFactory: 7527649n;
     };
+    readonly 59144: {
+        readonly morpho: 25072608n;
+        readonly bundler3: {
+            readonly bundler3: 25072853n;
+            readonly generalAdapter1: 25072853n;
+        };
+        readonly adaptiveCurveIrm: 25072608n;
+        readonly publicAllocator: 25072608n;
+        readonly metaMorphoFactory: 25072665n;
+        readonly vaultV2Factory: 25072951n;
+        readonly morphoMarketV1AdapterFactory: 25072951n;
+        readonly morphoVaultV1AdapterFactory: 25072951n;
+        readonly registryList: 25073088n;
+        readonly chainlinkOracleFactory: 25072665n;
+        readonly preLiquidationFactory: 25072853n;
+    };
     readonly 143: {
         readonly morpho: 31907457n;
         readonly bundler3: {
@@ -1267,6 +1301,24 @@ export declare let addressesRegistry: {
         readonly preLiquidationFactory: "0x534858821653467c2ae231dc027aa1F2c8D91802";
         readonly wNative: "0x1Cd0690fF9a693f5EF2dD976660a8dAFc81A109c";
     };
+    readonly 59144: {
+        readonly morpho: "0x6B0D716aC0A45536172308e08fC2C40387262c9F";
+        readonly bundler3: {
+            readonly bundler3: "0x1Ee8Ec299E8014760D50A4E3CfC3b44Cc2242625";
+            readonly generalAdapter1: "0x454dAb6ce9891245696b239b4845a1cDC268255d";
+        };
+        readonly adaptiveCurveIrm: "0x85C2Ef4Bd69f42D7Da19Fb9dcdD7Fb8d0F59cDeE";
+        readonly publicAllocator: "0x2d4cf00e18D48fD030d9b1E2FAAE6e0384C7610B";
+        readonly metaMorphoFactory: "0xA148a8223B622A72dC36472DE1492aBb5c089BA7";
+        readonly vaultV2Factory: "0x5DC11CF8BA4C39d1194F91218D35008d9F52A5d0";
+        readonly morphoMarketV1AdapterFactory: "0x3267BbdC94274B4BE081c01ffc6123dA12E8c043";
+        readonly morphoVaultV1AdapterFactory: "0x6FaF26DD640e22457cA4fd5DA702BA3E169eEd87";
+        readonly registryList: "0x122Ea8ff8888C29F8736665d576e3fAEF15D27D5";
+        readonly chainlinkOracleFactory: "0x3FFF726062B03BfD5BC485eeEEcc92CF1d8F0105";
+        readonly preLiquidationFactory: "0x05a0Ff4E564ED1ba6B42247E19edFf83545C3C40";
+        readonly wNative: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f";
+        readonly usdc: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff";
+    };
     readonly 143: {
         readonly morpho: "0xD5D960E8C380B724a48AC59E2DfF1b2CB4a1eAee";
         readonly bundler3: {
@@ -1631,6 +1683,22 @@ export declare let deployments: {
         readonly chainlinkOracleFactory: 7526768n;
         readonly preLiquidationFactory: 7527649n;
     };
+    readonly 59144: {
+        readonly morpho: 25072608n;
+        readonly bundler3: {
+            readonly bundler3: 25072853n;
+            readonly generalAdapter1: 25072853n;
+        };
+        readonly adaptiveCurveIrm: 25072608n;
+        readonly publicAllocator: 25072608n;
+        readonly metaMorphoFactory: 25072665n;
+        readonly vaultV2Factory: 25072951n;
+        readonly morphoMarketV1AdapterFactory: 25072951n;
+        readonly morphoVaultV1AdapterFactory: 25072951n;
+        readonly registryList: 25073088n;
+        readonly chainlinkOracleFactory: 25072665n;
+        readonly preLiquidationFactory: 25072853n;
+    };
     readonly 143: {
         readonly morpho: 31907457n;
         readonly bundler3: {

package/lib/addresses.js

@@ -439,6 +439,24 @@ const _addressesRegistry = {
         preLiquidationFactory: "0x534858821653467c2ae231dc027aa1F2c8D91802",
         wNative: "0x1Cd0690fF9a693f5EF2dD976660a8dAFc81A109c",
     },
+    [chain_js_1.ChainId.LineaMainnet]: {
+        morpho: "0x6B0D716aC0A45536172308e08fC2C40387262c9F",
+        bundler3: {
+            bundler3: "0x1Ee8Ec299E8014760D50A4E3CfC3b44Cc2242625",
+            generalAdapter1: "0x454dAb6ce9891245696b239b4845a1cDC268255d",
+        },
+        adaptiveCurveIrm: "0x85C2Ef4Bd69f42D7Da19Fb9dcdD7Fb8d0F59cDeE",
+        publicAllocator: "0x2d4cf00e18D48fD030d9b1E2FAAE6e0384C7610B",
+        metaMorphoFactory: "0xA148a8223B622A72dC36472DE1492aBb5c089BA7",
+        vaultV2Factory: "0x5DC11CF8BA4C39d1194F91218D35008d9F52A5d0",
+        morphoMarketV1AdapterFactory: "0x3267BbdC94274B4BE081c01ffc6123dA12E8c043",
+        morphoVaultV1AdapterFactory: "0x6FaF26DD640e22457cA4fd5DA702BA3E169eEd87",
+        registryList: "0x122Ea8ff8888C29F8736665d576e3fAEF15D27D5",
+        chainlinkOracleFactory: "0x3FFF726062B03BfD5BC485eeEEcc92CF1d8F0105",
+        preLiquidationFactory: "0x05a0Ff4E564ED1ba6B42247E19edFf83545C3C40",
+        wNative: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f",
+        usdc: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff",
+    },
     [chain_js_1.ChainId.MonadMainnet]: {
         morpho: "0xD5D960E8C380B724a48AC59E2DfF1b2CB4a1eAee",
         bundler3: {
@@ -802,6 +820,22 @@ const _deployments = {
         chainlinkOracleFactory: 7526768n,
         preLiquidationFactory: 7527649n,
     },
+    [chain_js_1.ChainId.LineaMainnet]: {
+        morpho: 25072608n,
+        bundler3: {
+            bundler3: 25072853n,
+            generalAdapter1: 25072853n,
+        },
+        adaptiveCurveIrm: 25072608n,
+        publicAllocator: 25072608n,
+        metaMorphoFactory: 25072665n,
+        vaultV2Factory: 25072951n,
+        morphoMarketV1AdapterFactory: 25072951n,
+        morphoVaultV1AdapterFactory: 25072951n,
+        registryList: 25073088n,
+        chainlinkOracleFactory: 25072665n,
+        preLiquidationFactory: 25072853n,
+    },
     [chain_js_1.ChainId.MonadMainnet]: {
         morpho: 31907457n,
         bundler3: {
@@ -910,6 +944,9 @@ const _unwrappedTokensMapping = {
     [chain_js_1.ChainId.ZeroGMainnet]: {
         [_addressesRegistry[chain_js_1.ChainId.ZeroGMainnet].wNative]: exports.NATIVE_ADDRESS,
     },
+    [chain_js_1.ChainId.LineaMainnet]: {
+        [_addressesRegistry[chain_js_1.ChainId.LineaMainnet].wNative]: exports.NATIVE_ADDRESS,
+    },
     [chain_js_1.ChainId.MonadMainnet]: {
         [_addressesRegistry[chain_js_1.ChainId.MonadMainnet].wNative]: exports.NATIVE_ADDRESS,
     },

package/lib/chain.d.ts

@@ -22,6 +22,7 @@ export declare enum ChainId {
     HyperliquidMainnet = 999,
     SeiMainnet = 1329,
     ZeroGMainnet = 16661,
+    LineaMainnet = 59144,
     MonadMainnet = 143
 }
 export interface ChainMetadata {
@@ -294,6 +295,17 @@ export declare namespace ChainUtils {
             explorerUrl: string;
             identifier: string;
         };
+        59144: {
+            name: string;
+            id: ChainId.LineaMainnet;
+            nativeCurrency: {
+                name: string;
+                symbol: string;
+                decimals: number;
+            };
+            explorerUrl: string;
+            identifier: string;
+        };
         143: {
             name: string;
             id: ChainId.MonadMainnet;

package/lib/chain.js

@@ -26,6 +26,7 @@ var ChainId;
     ChainId[ChainId["HyperliquidMainnet"] = 999] = "HyperliquidMainnet";
     ChainId[ChainId["SeiMainnet"] = 1329] = "SeiMainnet";
     ChainId[ChainId["ZeroGMainnet"] = 16661] = "ZeroGMainnet";
+    ChainId[ChainId["LineaMainnet"] = 59144] = "LineaMainnet";
     ChainId[ChainId["MonadMainnet"] = 143] = "MonadMainnet";
 })(ChainId || (exports.ChainId = ChainId = {}));
 var ChainUtils;
@@ -204,6 +205,13 @@ var ChainUtils;
             explorerUrl: "https://chainscan.0g.ai",
             identifier: "0G",
         },
+        [ChainId.LineaMainnet]: {
+            name: "Linea",
+            id: ChainId.LineaMainnet,
+            nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+            explorerUrl: "https://lineascan.build",
+            identifier: "linea",
+        },
         [ChainId.MonadMainnet]: {
             name: "Monad",
             id: ChainId.MonadMainnet,

package/lib/errors.d.ts

@@ -1,4 +1,9 @@
+import { type Hex } from "viem";
 import type { Address, MarketId } from "./types.js";
+export declare class InvalidMarketParamsError extends Error {
+    readonly data: Hex;
+    constructor(data: Hex);
+}
 export declare class UnknownDataError extends Error {
 }
 export declare class UnknownTokenError extends UnknownDataError {
@@ -25,6 +30,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 +74,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,8 +1,16 @@
 "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 = exports.InvalidMarketParamsError = void 0;
 exports._try = _try;
 const viem_1 = require("viem");
+class InvalidMarketParamsError extends Error {
+    data;
+    constructor(data) {
+        super(`cannot decode valid MarketParams from "${data}"`);
+        this.data = data;
+    }
+}
+exports.InvalidMarketParamsError = InvalidMarketParamsError;
 class UnknownDataError extends Error {
 }
 exports.UnknownDataError = UnknownDataError;
@@ -54,6 +62,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 +149,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.
  */
@@ -498,11 +491,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,
         };
     }
     /**
@@ -515,11 +508,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,
         };
     }
     /**
@@ -533,11 +526,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,
         };
     }
     /**
@@ -553,11 +546,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,
         };
     }
     /**
@@ -571,14 +564,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/MarketParams.d.ts

@@ -1,4 +1,5 @@
 import type { Address, BigIntish, MarketId } from "../types.js";
+import { type Hex } from "viem";
 export interface IMarketParams {
     loanToken: Address;
     collateralToken: Address;
@@ -7,6 +8,25 @@ export interface IMarketParams {
     lltv: BigIntish;
 }
 export type InputMarketParams = Pick<MarketParams, "loanToken" | "collateralToken" | "oracle" | "irm" | "lltv">;
+export declare const marketParamsAbi: {
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly type: "address";
+        readonly name: "loanToken";
+    }, {
+        readonly type: "address";
+        readonly name: "collateralToken";
+    }, {
+        readonly type: "address";
+        readonly name: "oracle";
+    }, {
+        readonly type: "address";
+        readonly name: "irm";
+    }, {
+        readonly type: "uint256";
+        readonly name: "lltv";
+    }];
+};
 /**
  * Represents a market's configuration (also called market params).
  */
@@ -21,6 +41,7 @@ export declare class MarketParams implements IMarketParams {
      * Returns the canonical idle market configuration for the given loan token.
      */
     static idle(token: Address): MarketParams;
+    static fromHex(data: Hex): MarketParams;
     /**
      * The market's collateral token address.
      */

package/lib/market/MarketParams.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarketParams = void 0;
+exports.MarketParams = exports.marketParamsAbi = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const errors_js_1 = require("../errors.js");
+const viem_1 = require("viem");
 const MarketUtils_js_1 = require("./MarketUtils.js");
+exports.marketParamsAbi = {
+    type: "tuple",
+    components: [
+        { type: "address", name: "loanToken" },
+        { type: "address", name: "collateralToken" },
+        { type: "address", name: "oracle" },
+        { type: "address", name: "irm" },
+        { type: "uint256", name: "lltv" },
+    ],
+};
 /**
  * Represents a market's configuration (also called market params).
  */
@@ -31,6 +42,15 @@ class MarketParams {
             lltv: 0n,
         });
     }
+    static fromHex(data) {
+        try {
+            const [marketParams] = (0, viem_1.decodeAbiParameters)([exports.marketParamsAbi], data);
+            return new MarketParams(marketParams);
+        }
+        catch {
+            throw new errors_js_1.InvalidMarketParamsError(data);
+        }
+    }
     /**
      * The market's collateral token address.
      */

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;
@@ -184,11 +184,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,59 @@
+"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");
+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" }, market_1.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 marketId = market_1.MarketParams.fromHex(data).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.4.0",
+  "version": "5.6.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -25,14 +25,14 @@
     "lodash.mergewith": "^4.6.2"
   },
   "peerDependencies": {
-    "@morpho-org/morpho-ts": "^2.4.4"
+    "@morpho-org/morpho-ts": "^2.4.5"
   },
   "devDependencies": {
     "typescript": "^5.7.2",
-    "viem": "^2.23.0",
+    "viem": "^2.33.3",
     "vitest": "^3.0.5",
-    "@morpho-org/morpho-ts": "^2.4.4",
-    "@morpho-org/test": "^2.6.0"
+    "@morpho-org/morpho-ts": "^2.4.5",
+    "@morpho-org/test": "^2.6.1"
   },
   "scripts": {
     "prepublish": "$npm_execpath build",