@usdu-finance/usdu-core 0.0.1

package/contracts/morpho/helpers/IMorpho.sol

@@ -0,0 +1,361 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+type Id is bytes32;
+
+struct MarketParams {
+	address loanToken;
+	address collateralToken;
+	address oracle;
+	address irm;
+	uint256 lltv;
+}
+
+/// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest
+/// accrual.
+struct Position {
+	uint256 supplyShares;
+	uint128 borrowShares;
+	uint128 collateral;
+}
+
+/// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.
+/// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.
+/// @dev Warning: `totalSupplyShares` does not contain the additional shares accrued by `feeRecipient` since the last
+/// interest accrual.
+struct Market {
+	uint128 totalSupplyAssets;
+	uint128 totalSupplyShares;
+	uint128 totalBorrowAssets;
+	uint128 totalBorrowShares;
+	uint128 lastUpdate;
+	uint128 fee;
+}
+
+struct Authorization {
+	address authorizer;
+	address authorized;
+	bool isAuthorized;
+	uint256 nonce;
+	uint256 deadline;
+}
+
+struct Signature {
+	uint8 v;
+	bytes32 r;
+	bytes32 s;
+}
+
+/// @dev This interface is used for factorizing IMorphoStaticTyping and IMorpho.
+/// @dev Consider using the IMorpho interface instead of this one.
+interface IMorphoBase {
+	/// @notice The EIP-712 domain separator.
+	/// @dev Warning: Every EIP-712 signed message based on this domain separator can be reused on chains sharing the
+	/// same chain id and on forks because the domain separator would be the same.
+	function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+	/// @notice The owner of the contract.
+	/// @dev It has the power to change the owner.
+	/// @dev It has the power to set fees on markets and set the fee recipient.
+	/// @dev It has the power to enable but not disable IRMs and LLTVs.
+	function owner() external view returns (address);
+
+	/// @notice The fee recipient of all markets.
+	/// @dev The recipient receives the fees of a given market through a supply position on that market.
+	function feeRecipient() external view returns (address);
+
+	/// @notice Whether the `irm` is enabled.
+	function isIrmEnabled(address irm) external view returns (bool);
+
+	/// @notice Whether the `lltv` is enabled.
+	function isLltvEnabled(uint256 lltv) external view returns (bool);
+
+	/// @notice Whether `authorized` is authorized to modify `authorizer`'s position on all markets.
+	/// @dev Anyone is authorized to modify their own positions, regardless of this variable.
+	function isAuthorized(address authorizer, address authorized) external view returns (bool);
+
+	/// @notice The `authorizer`'s current nonce. Used to prevent replay attacks with EIP-712 signatures.
+	function nonce(address authorizer) external view returns (uint256);
+
+	/// @notice Sets `newOwner` as `owner` of the contract.
+	/// @dev Warning: No two-step transfer ownership.
+	/// @dev Warning: The owner can be set to the zero address.
+	function setOwner(address newOwner) external;
+
+	/// @notice Enables `irm` as a possible IRM for market creation.
+	/// @dev Warning: It is not possible to disable an IRM.
+	function enableIrm(address irm) external;
+
+	/// @notice Enables `lltv` as a possible LLTV for market creation.
+	/// @dev Warning: It is not possible to disable a LLTV.
+	function enableLltv(uint256 lltv) external;
+
+	/// @notice Sets the `newFee` for the given market `marketParams`.
+	/// @param newFee The new fee, scaled by WAD.
+	/// @dev Warning: The recipient can be the zero address.
+	function setFee(MarketParams memory marketParams, uint256 newFee) external;
+
+	/// @notice Sets `newFeeRecipient` as `feeRecipient` of the fee.
+	/// @dev Warning: If the fee recipient is set to the zero address, fees will accrue there and will be lost.
+	/// @dev Modifying the fee recipient will allow the new recipient to claim any pending fees not yet accrued. To
+	/// ensure that the current recipient receives all due fees, accrue interest manually prior to making any changes.
+	function setFeeRecipient(address newFeeRecipient) external;
+
+	/// @notice Creates the market `marketParams`.
+	/// @dev Here is the list of assumptions on the market's dependencies (tokens, IRM and oracle) that guarantees
+	/// Morpho behaves as expected:
+	/// - The token should be ERC-20 compliant, except that it can omit return values on `transfer` and `transferFrom`.
+	/// - The token balance of Morpho should only decrease on `transfer` and `transferFrom`. In particular, tokens with
+	/// burn functions are not supported.
+	/// - The token should not re-enter Morpho on `transfer` nor `transferFrom`.
+	/// - The token balance of the sender (resp. receiver) should decrease (resp. increase) by exactly the given amount
+	/// on `transfer` and `transferFrom`. In particular, tokens with fees on transfer are not supported.
+	/// - The IRM should not re-enter Morpho.
+	/// - The oracle should return a price with the correct scaling.
+	/// @dev Here is a list of assumptions on the market's dependencies which, if broken, could break Morpho's liveness
+	/// properties (funds could get stuck):
+	/// - The token should not revert on `transfer` and `transferFrom` if balances and approvals are right.
+	/// - The amount of assets supplied and borrowed should not go above ~1e35 (otherwise the computation of
+	/// `toSharesUp` and `toSharesDown` can overflow).
+	/// - The IRM should not revert on `borrowRate`.
+	/// - The IRM should not return a very high borrow rate (otherwise the computation of `interest` in
+	/// `_accrueInterest` can overflow).
+	/// - The oracle should not revert `price`.
+	/// - The oracle should not return a very high price (otherwise the computation of `maxBorrow` in `_isHealthy` or of
+	/// `assetsRepaid` in `liquidate` can overflow).
+	/// @dev The borrow share price of a market with less than 1e4 assets borrowed can be decreased by manipulations, to
+	/// the point where `totalBorrowShares` is very large and borrowing overflows.
+	function createMarket(MarketParams memory marketParams) external;
+
+	/// @notice Supplies `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's
+	/// `onMorphoSupply` function with the given `data`.
+	/// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the
+	/// caller is guaranteed to have `assets` tokens pulled from their balance, but the possibility to mint a specific
+	/// amount of shares is given for full compatibility and precision.
+	/// @dev Supplying a large amount can revert for overflow.
+	/// @dev Supplying an amount of shares may lead to supply more or fewer assets than expected due to slippage.
+	/// Consider using the `assets` parameter to avoid this.
+	/// @param marketParams The market to supply assets to.
+	/// @param assets The amount of assets to supply.
+	/// @param shares The amount of shares to mint.
+	/// @param onBehalf The address that will own the increased supply position.
+	/// @param data Arbitrary data to pass to the `onMorphoSupply` callback. Pass empty data if not needed.
+	/// @return assetsSupplied The amount of assets supplied.
+	/// @return sharesSupplied The amount of shares minted.
+	function supply(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		bytes memory data
+	) external returns (uint256 assetsSupplied, uint256 sharesSupplied);
+
+	/// @notice Withdraws `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.
+	/// @dev Either `assets` or `shares` should be zero. To withdraw max, pass the `shares`'s balance of `onBehalf`.
+	/// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.
+	/// @dev Withdrawing an amount corresponding to more shares than supplied will revert for underflow.
+	/// @dev It is advised to use the `shares` input when withdrawing the full position to avoid reverts due to
+	/// conversion roundings between shares and assets.
+	/// @param marketParams The market to withdraw assets from.
+	/// @param assets The amount of assets to withdraw.
+	/// @param shares The amount of shares to burn.
+	/// @param onBehalf The address of the owner of the supply position.
+	/// @param receiver The address that will receive the withdrawn assets.
+	/// @return assetsWithdrawn The amount of assets withdrawn.
+	/// @return sharesWithdrawn The amount of shares burned.
+	function withdraw(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		address receiver
+	) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn);
+
+	/// @notice Borrows `assets` or `shares` on behalf of `onBehalf` and sends the assets to `receiver`.
+	/// @dev Either `assets` or `shares` should be zero. Most use cases should rely on `assets` as an input so the
+	/// caller is guaranteed to borrow `assets` of tokens, but the possibility to mint a specific amount of shares is
+	/// given for full compatibility and precision.
+	/// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.
+	/// @dev Borrowing a large amount can revert for overflow.
+	/// @dev Borrowing an amount of shares may lead to borrow fewer assets than expected due to slippage.
+	/// Consider using the `assets` parameter to avoid this.
+	/// @param marketParams The market to borrow assets from.
+	/// @param assets The amount of assets to borrow.
+	/// @param shares The amount of shares to mint.
+	/// @param onBehalf The address that will own the increased borrow position.
+	/// @param receiver The address that will receive the borrowed assets.
+	/// @return assetsBorrowed The amount of assets borrowed.
+	/// @return sharesBorrowed The amount of shares minted.
+	function borrow(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		address receiver
+	) external returns (uint256 assetsBorrowed, uint256 sharesBorrowed);
+
+	/// @notice Repays `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's
+	/// `onMorphoRepay` function with the given `data`.
+	/// @dev Either `assets` or `shares` should be zero. To repay max, pass the `shares`'s balance of `onBehalf`.
+	/// @dev Repaying an amount corresponding to more shares than borrowed will revert for underflow.
+	/// @dev It is advised to use the `shares` input when repaying the full position to avoid reverts due to conversion
+	/// roundings between shares and assets.
+	/// @dev An attacker can front-run a repay with a small repay making the transaction revert for underflow.
+	/// @param marketParams The market to repay assets to.
+	/// @param assets The amount of assets to repay.
+	/// @param shares The amount of shares to burn.
+	/// @param onBehalf The address of the owner of the debt position.
+	/// @param data Arbitrary data to pass to the `onMorphoRepay` callback. Pass empty data if not needed.
+	/// @return assetsRepaid The amount of assets repaid.
+	/// @return sharesRepaid The amount of shares burned.
+	function repay(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		bytes memory data
+	) external returns (uint256 assetsRepaid, uint256 sharesRepaid);
+
+	/// @notice Supplies `assets` of collateral on behalf of `onBehalf`, optionally calling back the caller's
+	/// `onMorphoSupplyCollateral` function with the given `data`.
+	/// @dev Interest are not accrued since it's not required and it saves gas.
+	/// @dev Supplying a large amount can revert for overflow.
+	/// @param marketParams The market to supply collateral to.
+	/// @param assets The amount of collateral to supply.
+	/// @param onBehalf The address that will own the increased collateral position.
+	/// @param data Arbitrary data to pass to the `onMorphoSupplyCollateral` callback. Pass empty data if not needed.
+	function supplyCollateral(
+		MarketParams memory marketParams,
+		uint256 assets,
+		address onBehalf,
+		bytes memory data
+	) external;
+
+	/// @notice Withdraws `assets` of collateral on behalf of `onBehalf` and sends the assets to `receiver`.
+	/// @dev `msg.sender` must be authorized to manage `onBehalf`'s positions.
+	/// @dev Withdrawing an amount corresponding to more collateral than supplied will revert for underflow.
+	/// @param marketParams The market to withdraw collateral from.
+	/// @param assets The amount of collateral to withdraw.
+	/// @param onBehalf The address of the owner of the collateral position.
+	/// @param receiver The address that will receive the collateral assets.
+	function withdrawCollateral(
+		MarketParams memory marketParams,
+		uint256 assets,
+		address onBehalf,
+		address receiver
+	) external;
+
+	/// @notice Liquidates the given `repaidShares` of debt asset or seize the given `seizedAssets` of collateral on the
+	/// given market `marketParams` of the given `borrower`'s position, optionally calling back the caller's
+	/// `onMorphoLiquidate` function with the given `data`.
+	/// @dev Either `seizedAssets` or `repaidShares` should be zero.
+	/// @dev Seizing more than the collateral balance will underflow and revert without any error message.
+	/// @dev Repaying more than the borrow balance will underflow and revert without any error message.
+	/// @dev An attacker can front-run a liquidation with a small repay making the transaction revert for underflow.
+	/// @param marketParams The market of the position.
+	/// @param borrower The owner of the position.
+	/// @param seizedAssets The amount of collateral to seize.
+	/// @param repaidShares The amount of shares to repay.
+	/// @param data Arbitrary data to pass to the `onMorphoLiquidate` callback. Pass empty data if not needed.
+	/// @return The amount of assets seized.
+	/// @return The amount of assets repaid.
+	function liquidate(
+		MarketParams memory marketParams,
+		address borrower,
+		uint256 seizedAssets,
+		uint256 repaidShares,
+		bytes memory data
+	) external returns (uint256, uint256);
+
+	/// @notice Executes a flash loan.
+	/// @dev Flash loans have access to the whole balance of the contract (the liquidity and deposited collateral of all
+	/// markets combined, plus donations).
+	/// @dev Warning: Not ERC-3156 compliant but compatibility is easily reached:
+	/// - `flashFee` is zero.
+	/// - `maxFlashLoan` is the token's balance of this contract.
+	/// - The receiver of `assets` is the caller.
+	/// @param token The token to flash loan.
+	/// @param assets The amount of assets to flash loan.
+	/// @param data Arbitrary data to pass to the `onMorphoFlashLoan` callback.
+	function flashLoan(address token, uint256 assets, bytes calldata data) external;
+
+	/// @notice Sets the authorization for `authorized` to manage `msg.sender`'s positions.
+	/// @param authorized The authorized address.
+	/// @param newIsAuthorized The new authorization status.
+	function setAuthorization(address authorized, bool newIsAuthorized) external;
+
+	/// @notice Sets the authorization for `authorization.authorized` to manage `authorization.authorizer`'s positions.
+	/// @dev Warning: Reverts if the signature has already been submitted.
+	/// @dev The signature is malleable, but it has no impact on the security here.
+	/// @dev The nonce is passed as argument to be able to revert with a different error message.
+	/// @param authorization The `Authorization` struct.
+	/// @param signature The signature.
+	function setAuthorizationWithSig(Authorization calldata authorization, Signature calldata signature) external;
+
+	/// @notice Accrues interest for the given market `marketParams`.
+	function accrueInterest(MarketParams memory marketParams) external;
+
+	/// @notice Returns the data stored on the different `slots`.
+	function extSloads(bytes32[] memory slots) external view returns (bytes32[] memory);
+}
+
+/// @dev This interface is inherited by Morpho so that function signatures are checked by the compiler.
+/// @dev Consider using the IMorpho interface instead of this one.
+interface IMorphoStaticTyping is IMorphoBase {
+	/// @notice The state of the position of `user` on the market corresponding to `id`.
+	/// @dev Warning: For `feeRecipient`, `supplyShares` does not contain the accrued shares since the last interest
+	/// accrual.
+	function position(
+		Id id,
+		address user
+	) external view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral);
+
+	/// @notice The state of the market corresponding to `id`.
+	/// @dev Warning: `totalSupplyAssets` does not contain the accrued interest since the last interest accrual.
+	/// @dev Warning: `totalBorrowAssets` does not contain the accrued interest since the last interest accrual.
+	/// @dev Warning: `totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last interest
+	/// accrual.
+	function market(
+		Id id
+	)
+		external
+		view
+		returns (
+			uint128 totalSupplyAssets,
+			uint128 totalSupplyShares,
+			uint128 totalBorrowAssets,
+			uint128 totalBorrowShares,
+			uint128 lastUpdate,
+			uint128 fee
+		);
+
+	/// @notice The market params corresponding to `id`.
+	/// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer
+	/// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.
+	function idToMarketParams(
+		Id id
+	) external view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv);
+}
+
+/// @title IMorpho
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @dev Use this interface for Morpho to have access to all the functions with the appropriate function signatures.
+interface IMorpho is IMorphoBase {
+	/// @notice The state of the position of `user` on the market corresponding to `id`.
+	/// @dev Warning: For `feeRecipient`, `p.supplyShares` does not contain the accrued shares since the last interest
+	/// accrual.
+	function position(Id id, address user) external view returns (Position memory p);
+
+	/// @notice The state of the market corresponding to `id`.
+	/// @dev Warning: `m.totalSupplyAssets` does not contain the accrued interest since the last interest accrual.
+	/// @dev Warning: `m.totalBorrowAssets` does not contain the accrued interest since the last interest accrual.
+	/// @dev Warning: `m.totalSupplyShares` does not contain the accrued shares by `feeRecipient` since the last
+	/// interest accrual.
+	function market(Id id) external view returns (Market memory m);
+
+	/// @notice The market params corresponding to `id`.
+	/// @dev This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer
+	/// 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`.
+	function idToMarketParams(Id id) external view returns (MarketParams memory);
+}

package/contracts/morpho/helpers/IMorphoCallbacks.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title IMorphoLiquidateCallback
+/// @notice Interface that liquidators willing to use `liquidate`'s callback must implement.
+interface IMorphoLiquidateCallback {
+    /// @notice Callback called when a liquidation occurs.
+    /// @dev The callback is called only if data is not empty.
+    /// @param repaidAssets The amount of repaid assets.
+    /// @param data Arbitrary data passed to the `liquidate` function.
+    function onMorphoLiquidate(uint256 repaidAssets, bytes calldata data) external;
+}
+
+/// @title IMorphoRepayCallback
+/// @notice Interface that users willing to use `repay`'s callback must implement.
+interface IMorphoRepayCallback {
+    /// @notice Callback called when a repayment occurs.
+    /// @dev The callback is called only if data is not empty.
+    /// @param assets The amount of repaid assets.
+    /// @param data Arbitrary data passed to the `repay` function.
+    function onMorphoRepay(uint256 assets, bytes calldata data) external;
+}
+
+/// @title IMorphoSupplyCallback
+/// @notice Interface that users willing to use `supply`'s callback must implement.
+interface IMorphoSupplyCallback {
+    /// @notice Callback called when a supply occurs.
+    /// @dev The callback is called only if data is not empty.
+    /// @param assets The amount of supplied assets.
+    /// @param data Arbitrary data passed to the `supply` function.
+    function onMorphoSupply(uint256 assets, bytes calldata data) external;
+}
+
+/// @title IMorphoSupplyCollateralCallback
+/// @notice Interface that users willing to use `supplyCollateral`'s callback must implement.
+interface IMorphoSupplyCollateralCallback {
+    /// @notice Callback called when a supply of collateral occurs.
+    /// @dev The callback is called only if data is not empty.
+    /// @param assets The amount of supplied collateral.
+    /// @param data Arbitrary data passed to the `supplyCollateral` function.
+    function onMorphoSupplyCollateral(uint256 assets, bytes calldata data) external;
+}
+
+/// @title IMorphoFlashLoanCallback
+/// @notice Interface that users willing to use `flashLoan`'s callback must implement.
+interface IMorphoFlashLoanCallback {
+    /// @notice Callback called when a flash loan occurs.
+    /// @dev The callback is called only if data is not empty.
+    /// @param assets The amount of assets that was flash loaned.
+    /// @param data Arbitrary data passed to the `flashLoan` function.
+    function onMorphoFlashLoan(uint256 assets, bytes calldata data) external;
+}

package/contracts/morpho/helpers/IMorphoChainlinkOracleV2.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import {IERC4626} from './IERC4626.sol';
+import {IOracle} from './IOracle.sol';
+import {AggregatorV3Interface} from './AggregatorV3Interface.sol';
+
+/// @title IMorphoChainlinkOracleV2
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Interface of MorphoChainlinkOracleV2.
+interface IMorphoChainlinkOracleV2 is IOracle {
+	/// @notice Returns the address of the base ERC4626 vault.
+	function BASE_VAULT() external view returns (IERC4626);
+
+	/// @notice Returns the base vault conversion sample.
+	function BASE_VAULT_CONVERSION_SAMPLE() external view returns (uint256);
+
+	/// @notice Returns the address of the quote ERC4626 vault.
+	function QUOTE_VAULT() external view returns (IERC4626);
+
+	/// @notice Returns the quote vault conversion sample.
+	function QUOTE_VAULT_CONVERSION_SAMPLE() external view returns (uint256);
+
+	/// @notice Returns the address of the first base feed.
+	function BASE_FEED_1() external view returns (AggregatorV3Interface);
+
+	/// @notice Returns the address of the second base feed.
+	function BASE_FEED_2() external view returns (AggregatorV3Interface);
+
+	/// @notice Returns the address of the first quote feed.
+	function QUOTE_FEED_1() external view returns (AggregatorV3Interface);
+
+	/// @notice Returns the address of the second quote feed.
+	function QUOTE_FEED_2() external view returns (AggregatorV3Interface);
+
+	/// @notice Returns the price scale factor, calculated at contract creation.
+	function SCALE_FACTOR() external view returns (uint256);
+}

package/contracts/morpho/helpers/IMorphoChainlinkOracleV2Factory.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import {MorphoChainlinkOracleV2} from './MorphoChainlinkOracleV2.sol';
+import {IERC4626} from './VaultLib.sol';
+import {AggregatorV3Interface} from './ChainlinkDataFeedLib.sol';
+
+/// @title IMorphoChainlinkOracleV2Factory
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Interface for MorphoChainlinkOracleV2Factory
+interface IMorphoChainlinkOracleV2Factory {
+	/// @notice Emitted when a new Chainlink oracle is created.
+	/// @param oracle The address of the Chainlink oracle.
+	/// @param caller The caller of the function.
+	event CreateMorphoChainlinkOracleV2(address caller, address oracle);
+
+	/// @notice Whether a Chainlink oracle vault was created with the factory.
+	function isMorphoChainlinkOracleV2(address target) external view returns (bool);
+
+	/// @dev Here is the list of assumptions that guarantees the oracle behaves as expected:
+	/// - The vaults, if set, are ERC4626-compliant.
+	/// - The feeds, if set, are Chainlink-interface-compliant.
+	/// - Decimals passed as argument are correct.
+	/// - The base vaults's sample shares quoted as assets and the base feed prices don't overflow when multiplied.
+	/// - The quote vault's sample shares quoted as assets and the quote feed prices don't overflow when multiplied.
+	/// @param baseVault Base vault. Pass address zero to omit this parameter.
+	/// @param baseVaultConversionSample The sample amount of base vault shares used to convert to underlying.
+	/// Pass 1 if the base asset is not a vault. Should be chosen such that converting `baseVaultConversionSample` to
+	/// assets has enough precision.
+	/// @param baseFeed1 First base feed. Pass address zero if the price = 1.
+	/// @param baseFeed2 Second base feed. Pass address zero if the price = 1.
+	/// @param baseTokenDecimals Base token decimals.
+	/// @param quoteVault Quote vault. Pass address zero to omit this parameter.
+	/// @param quoteVaultConversionSample The sample amount of quote vault shares used to convert to underlying.
+	/// Pass 1 if the quote asset is not a vault. Should be chosen such that converting `quoteVaultConversionSample` to
+	/// assets has enough precision.
+	/// @param quoteFeed1 First quote feed. Pass address zero if the price = 1.
+	/// @param quoteFeed2 Second quote feed. Pass address zero if the price = 1.
+	/// @param quoteTokenDecimals Quote token decimals.
+	/// @param salt The salt to use for the CREATE2.
+	/// @dev The base asset should be the collateral token and the quote asset the loan token.
+	function createMorphoChainlinkOracleV2(
+		IERC4626 baseVault,
+		uint256 baseVaultConversionSample,
+		AggregatorV3Interface baseFeed1,
+		AggregatorV3Interface baseFeed2,
+		uint256 baseTokenDecimals,
+		IERC4626 quoteVault,
+		uint256 quoteVaultConversionSample,
+		AggregatorV3Interface quoteFeed1,
+		AggregatorV3Interface quoteFeed2,
+		uint256 quoteTokenDecimals,
+		bytes32 salt
+	) external returns (MorphoChainlinkOracleV2 oracle);
+}

package/contracts/morpho/helpers/IOracle.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title IOracle
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Interface that oracles used by Morpho must implement.
+/// @dev It is the user's responsibility to select markets with safe oracles.
+interface IOracle {
+	/// @notice Returns the price of 1 asset of collateral token quoted in 1 asset of loan token, scaled by 1e36.
+	/// @dev It corresponds to the price of 10**(collateral token decimals) assets of collateral token quoted in
+	/// 10**(loan token decimals) assets of loan token with `36 + loan token decimals - collateral token decimals`
+	/// decimals of precision.
+	function price() external view returns (uint256);
+}

package/contracts/morpho/helpers/MarketParamsLib.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {Id, MarketParams} from './IMorpho.sol';
+
+/// @title MarketParamsLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library to convert a market to its id.
+library MarketParamsLib {
+	/// @notice The length of the data used to compute the id of a market.
+	/// @dev The length is 5 * 32 because `MarketParams` has 5 variables of 32 bytes each.
+	uint256 internal constant MARKET_PARAMS_BYTES_LENGTH = 5 * 32;
+
+	/// @notice Returns the id of the market `marketParams`.
+	function id(MarketParams memory marketParams) internal pure returns (Id marketParamsId) {
+		assembly ('memory-safe') {
+			marketParamsId := keccak256(marketParams, MARKET_PARAMS_BYTES_LENGTH)
+		}
+	}
+}

package/contracts/morpho/helpers/MathLib.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+uint256 constant WAD = 1e18;
+
+/// @title MathLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library to manage fixed-point arithmetic.
+library MathLib {
+	/// @dev Returns (`x` * `y`) / `WAD` rounded down.
+	function wMulDown(uint256 x, uint256 y) internal pure returns (uint256) {
+		return mulDivDown(x, y, WAD);
+	}
+
+	/// @dev Returns (`x` * `WAD`) / `y` rounded down.
+	function wDivDown(uint256 x, uint256 y) internal pure returns (uint256) {
+		return mulDivDown(x, WAD, y);
+	}
+
+	/// @dev Returns (`x` * `WAD`) / `y` rounded up.
+	function wDivUp(uint256 x, uint256 y) internal pure returns (uint256) {
+		return mulDivUp(x, WAD, y);
+	}
+
+	/// @dev Returns (`x` * `y`) / `d` rounded down.
+	function mulDivDown(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {
+		return (x * y) / d;
+	}
+
+	/// @dev Returns (`x` * `y`) / `d` rounded up.
+	function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256) {
+		return (x * y + (d - 1)) / d;
+	}
+
+	/// @dev Returns the sum of the first three non-zero terms of a Taylor expansion of e^(nx) - 1, to approximate a
+	/// continuous compound interest rate.
+	function wTaylorCompounded(uint256 x, uint256 n) internal pure returns (uint256) {
+		uint256 firstTerm = x * n;
+		uint256 secondTerm = mulDivDown(firstTerm, firstTerm, 2 * WAD);
+		uint256 thirdTerm = mulDivDown(secondTerm, firstTerm, 3 * WAD);
+
+		return firstTerm + secondTerm + thirdTerm;
+	}
+}