@usdu-core/usdu-core 0.0.1

package/contracts/morpho/helpers/Morpho.sol.bak

@@ -0,0 +1,517 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import {Id, IMorphoStaticTyping, IMorphoBase, MarketParams, Position, Market, Authorization, Signature} from './interfaces/IMorpho.sol';
+import {IMorphoLiquidateCallback, IMorphoRepayCallback, IMorphoSupplyCallback, IMorphoSupplyCollateralCallback, IMorphoFlashLoanCallback} from './interfaces/IMorphoCallbacks.sol';
+import {IIrm} from './interfaces/IIrm.sol';
+import {IERC20} from './interfaces/IERC20.sol';
+import {IOracle} from './interfaces/IOracle.sol';
+
+import './libraries/ConstantsLib.sol';
+import {UtilsLib} from './libraries/UtilsLib.sol';
+import {EventsLib} from './libraries/EventsLib.sol';
+import {ErrorsLib} from './libraries/ErrorsLib.sol';
+import {MathLib, WAD} from './libraries/MathLib.sol';
+import {SharesMathLib} from './libraries/SharesMathLib.sol';
+import {MarketParamsLib} from './libraries/MarketParamsLib.sol';
+import {SafeTransferLib} from './libraries/SafeTransferLib.sol';
+
+/// @title Morpho
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice The Morpho contract.
+contract Morpho is IMorphoStaticTyping {
+	using MathLib for uint128;
+	using MathLib for uint256;
+	using UtilsLib for uint256;
+	using SharesMathLib for uint256;
+	using SafeTransferLib for IERC20;
+	using MarketParamsLib for MarketParams;
+
+	/* IMMUTABLES */
+
+	/// @inheritdoc IMorphoBase
+	bytes32 public immutable DOMAIN_SEPARATOR;
+
+	/* STORAGE */
+
+	/// @inheritdoc IMorphoBase
+	address public owner;
+	/// @inheritdoc IMorphoBase
+	address public feeRecipient;
+	/// @inheritdoc IMorphoStaticTyping
+	mapping(Id => mapping(address => Position)) public position;
+	/// @inheritdoc IMorphoStaticTyping
+	mapping(Id => Market) public market;
+	/// @inheritdoc IMorphoBase
+	mapping(address => bool) public isIrmEnabled;
+	/// @inheritdoc IMorphoBase
+	mapping(uint256 => bool) public isLltvEnabled;
+	/// @inheritdoc IMorphoBase
+	mapping(address => mapping(address => bool)) public isAuthorized;
+	/// @inheritdoc IMorphoBase
+	mapping(address => uint256) public nonce;
+	/// @inheritdoc IMorphoStaticTyping
+	mapping(Id => MarketParams) public idToMarketParams;
+
+	/* CONSTRUCTOR */
+
+	/// @param newOwner The new owner of the contract.
+	constructor(address newOwner) {
+		require(newOwner != address(0), ErrorsLib.ZERO_ADDRESS);
+
+		DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH, block.chainid, address(this)));
+		owner = newOwner;
+
+		emit EventsLib.SetOwner(newOwner);
+	}
+
+	/* MODIFIERS */
+
+	/// @dev Reverts if the caller is not the owner.
+	modifier onlyOwner() {
+		require(msg.sender == owner, ErrorsLib.NOT_OWNER);
+		_;
+	}
+
+	/* ONLY OWNER FUNCTIONS */
+
+	/// @inheritdoc IMorphoBase
+	function setOwner(address newOwner) external onlyOwner {
+		require(newOwner != owner, ErrorsLib.ALREADY_SET);
+
+		owner = newOwner;
+
+		emit EventsLib.SetOwner(newOwner);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function enableIrm(address irm) external onlyOwner {
+		require(!isIrmEnabled[irm], ErrorsLib.ALREADY_SET);
+
+		isIrmEnabled[irm] = true;
+
+		emit EventsLib.EnableIrm(irm);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function enableLltv(uint256 lltv) external onlyOwner {
+		require(!isLltvEnabled[lltv], ErrorsLib.ALREADY_SET);
+		require(lltv < WAD, ErrorsLib.MAX_LLTV_EXCEEDED);
+
+		isLltvEnabled[lltv] = true;
+
+		emit EventsLib.EnableLltv(lltv);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function setFee(MarketParams memory marketParams, uint256 newFee) external onlyOwner {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(newFee != market[id].fee, ErrorsLib.ALREADY_SET);
+		require(newFee <= MAX_FEE, ErrorsLib.MAX_FEE_EXCEEDED);
+
+		// Accrue interest using the previous fee set before changing it.
+		_accrueInterest(marketParams, id);
+
+		// Safe "unchecked" cast.
+		market[id].fee = uint128(newFee);
+
+		emit EventsLib.SetFee(id, newFee);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function setFeeRecipient(address newFeeRecipient) external onlyOwner {
+		require(newFeeRecipient != feeRecipient, ErrorsLib.ALREADY_SET);
+
+		feeRecipient = newFeeRecipient;
+
+		emit EventsLib.SetFeeRecipient(newFeeRecipient);
+	}
+
+	/* MARKET CREATION */
+
+	/// @inheritdoc IMorphoBase
+	function createMarket(MarketParams memory marketParams) external {
+		Id id = marketParams.id();
+		require(isIrmEnabled[marketParams.irm], ErrorsLib.IRM_NOT_ENABLED);
+		require(isLltvEnabled[marketParams.lltv], ErrorsLib.LLTV_NOT_ENABLED);
+		require(market[id].lastUpdate == 0, ErrorsLib.MARKET_ALREADY_CREATED);
+
+		// Safe "unchecked" cast.
+		market[id].lastUpdate = uint128(block.timestamp);
+		idToMarketParams[id] = marketParams;
+
+		emit EventsLib.CreateMarket(id, marketParams);
+
+		// Call to initialize the IRM in case it is stateful.
+		if (marketParams.irm != address(0)) IIrm(marketParams.irm).borrowRate(marketParams, market[id]);
+	}
+
+	/* SUPPLY MANAGEMENT */
+
+	/// @inheritdoc IMorphoBase
+	function supply(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		bytes calldata data
+	) external returns (uint256, uint256) {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(UtilsLib.exactlyOneZero(assets, shares), ErrorsLib.INCONSISTENT_INPUT);
+		require(onBehalf != address(0), ErrorsLib.ZERO_ADDRESS);
+
+		_accrueInterest(marketParams, id);
+
+		if (assets > 0) shares = assets.toSharesDown(market[id].totalSupplyAssets, market[id].totalSupplyShares);
+		else assets = shares.toAssetsUp(market[id].totalSupplyAssets, market[id].totalSupplyShares);
+
+		position[id][onBehalf].supplyShares += shares;
+		market[id].totalSupplyShares += shares.toUint128();
+		market[id].totalSupplyAssets += assets.toUint128();
+
+		emit EventsLib.Supply(id, msg.sender, onBehalf, assets, shares);
+
+		if (data.length > 0) IMorphoSupplyCallback(msg.sender).onMorphoSupply(assets, data);
+
+		IERC20(marketParams.loanToken).safeTransferFrom(msg.sender, address(this), assets);
+
+		return (assets, shares);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function withdraw(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		address receiver
+	) external returns (uint256, uint256) {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(UtilsLib.exactlyOneZero(assets, shares), ErrorsLib.INCONSISTENT_INPUT);
+		require(receiver != address(0), ErrorsLib.ZERO_ADDRESS);
+		// No need to verify that onBehalf != address(0) thanks to the following authorization check.
+		require(_isSenderAuthorized(onBehalf), ErrorsLib.UNAUTHORIZED);
+
+		_accrueInterest(marketParams, id);
+
+		if (assets > 0) shares = assets.toSharesUp(market[id].totalSupplyAssets, market[id].totalSupplyShares);
+		else assets = shares.toAssetsDown(market[id].totalSupplyAssets, market[id].totalSupplyShares);
+
+		position[id][onBehalf].supplyShares -= shares;
+		market[id].totalSupplyShares -= shares.toUint128();
+		market[id].totalSupplyAssets -= assets.toUint128();
+
+		require(market[id].totalBorrowAssets <= market[id].totalSupplyAssets, ErrorsLib.INSUFFICIENT_LIQUIDITY);
+
+		emit EventsLib.Withdraw(id, msg.sender, onBehalf, receiver, assets, shares);
+
+		IERC20(marketParams.loanToken).safeTransfer(receiver, assets);
+
+		return (assets, shares);
+	}
+
+	/* BORROW MANAGEMENT */
+
+	/// @inheritdoc IMorphoBase
+	function borrow(MarketParams memory marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) external returns (uint256, uint256) {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(UtilsLib.exactlyOneZero(assets, shares), ErrorsLib.INCONSISTENT_INPUT);
+		require(receiver != address(0), ErrorsLib.ZERO_ADDRESS);
+		// No need to verify that onBehalf != address(0) thanks to the following authorization check.
+		require(_isSenderAuthorized(onBehalf), ErrorsLib.UNAUTHORIZED);
+
+		_accrueInterest(marketParams, id);
+
+		if (assets > 0) shares = assets.toSharesUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+		else assets = shares.toAssetsDown(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+
+		position[id][onBehalf].borrowShares += shares.toUint128();
+		market[id].totalBorrowShares += shares.toUint128();
+		market[id].totalBorrowAssets += assets.toUint128();
+
+		require(_isHealthy(marketParams, id, onBehalf), ErrorsLib.INSUFFICIENT_COLLATERAL);
+		require(market[id].totalBorrowAssets <= market[id].totalSupplyAssets, ErrorsLib.INSUFFICIENT_LIQUIDITY);
+
+		emit EventsLib.Borrow(id, msg.sender, onBehalf, receiver, assets, shares);
+
+		IERC20(marketParams.loanToken).safeTransfer(receiver, assets);
+
+		return (assets, shares);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function repay(
+		MarketParams memory marketParams,
+		uint256 assets,
+		uint256 shares,
+		address onBehalf,
+		bytes calldata data
+	) external returns (uint256, uint256) {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(UtilsLib.exactlyOneZero(assets, shares), ErrorsLib.INCONSISTENT_INPUT);
+		require(onBehalf != address(0), ErrorsLib.ZERO_ADDRESS);
+
+		_accrueInterest(marketParams, id);
+
+		if (assets > 0) shares = assets.toSharesDown(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+		else assets = shares.toAssetsUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+
+		position[id][onBehalf].borrowShares -= shares.toUint128();
+		market[id].totalBorrowShares -= shares.toUint128();
+		market[id].totalBorrowAssets = UtilsLib.zeroFloorSub(market[id].totalBorrowAssets, assets).toUint128();
+
+		// `assets` may be greater than `totalBorrowAssets` by 1.
+		emit EventsLib.Repay(id, msg.sender, onBehalf, assets, shares);
+
+		if (data.length > 0) IMorphoRepayCallback(msg.sender).onMorphoRepay(assets, data);
+
+		IERC20(marketParams.loanToken).safeTransferFrom(msg.sender, address(this), assets);
+
+		return (assets, shares);
+	}
+
+	/* COLLATERAL MANAGEMENT */
+
+	/// @inheritdoc IMorphoBase
+	function supplyCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, bytes calldata data) external {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(assets != 0, ErrorsLib.ZERO_ASSETS);
+		require(onBehalf != address(0), ErrorsLib.ZERO_ADDRESS);
+
+		// Don't accrue interest because it's not required and it saves gas.
+
+		position[id][onBehalf].collateral += assets.toUint128();
+
+		emit EventsLib.SupplyCollateral(id, msg.sender, onBehalf, assets);
+
+		if (data.length > 0) IMorphoSupplyCollateralCallback(msg.sender).onMorphoSupplyCollateral(assets, data);
+
+		IERC20(marketParams.collateralToken).safeTransferFrom(msg.sender, address(this), assets);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function withdrawCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, address receiver) external {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(assets != 0, ErrorsLib.ZERO_ASSETS);
+		require(receiver != address(0), ErrorsLib.ZERO_ADDRESS);
+		// No need to verify that onBehalf != address(0) thanks to the following authorization check.
+		require(_isSenderAuthorized(onBehalf), ErrorsLib.UNAUTHORIZED);
+
+		_accrueInterest(marketParams, id);
+
+		position[id][onBehalf].collateral -= assets.toUint128();
+
+		require(_isHealthy(marketParams, id, onBehalf), ErrorsLib.INSUFFICIENT_COLLATERAL);
+
+		emit EventsLib.WithdrawCollateral(id, msg.sender, onBehalf, receiver, assets);
+
+		IERC20(marketParams.collateralToken).safeTransfer(receiver, assets);
+	}
+
+	/* LIQUIDATION */
+
+	/// @inheritdoc IMorphoBase
+	function liquidate(
+		MarketParams memory marketParams,
+		address borrower,
+		uint256 seizedAssets,
+		uint256 repaidShares,
+		bytes calldata data
+	) external returns (uint256, uint256) {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+		require(UtilsLib.exactlyOneZero(seizedAssets, repaidShares), ErrorsLib.INCONSISTENT_INPUT);
+
+		_accrueInterest(marketParams, id);
+
+		{
+			uint256 collateralPrice = IOracle(marketParams.oracle).price();
+
+			require(!_isHealthy(marketParams, id, borrower, collateralPrice), ErrorsLib.HEALTHY_POSITION);
+
+			// The liquidation incentive factor is min(maxLiquidationIncentiveFactor, 1/(1 - cursor*(1 - lltv))).
+			uint256 liquidationIncentiveFactor = UtilsLib.min(
+				MAX_LIQUIDATION_INCENTIVE_FACTOR,
+				WAD.wDivDown(WAD - LIQUIDATION_CURSOR.wMulDown(WAD - marketParams.lltv))
+			);
+
+			if (seizedAssets > 0) {
+				uint256 seizedAssetsQuoted = seizedAssets.mulDivUp(collateralPrice, ORACLE_PRICE_SCALE);
+
+				repaidShares = seizedAssetsQuoted.wDivUp(liquidationIncentiveFactor).toSharesUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+			} else {
+				seizedAssets = repaidShares
+					.toAssetsDown(market[id].totalBorrowAssets, market[id].totalBorrowShares)
+					.wMulDown(liquidationIncentiveFactor)
+					.mulDivDown(ORACLE_PRICE_SCALE, collateralPrice);
+			}
+		}
+		uint256 repaidAssets = repaidShares.toAssetsUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+
+		position[id][borrower].borrowShares -= repaidShares.toUint128();
+		market[id].totalBorrowShares -= repaidShares.toUint128();
+		market[id].totalBorrowAssets = UtilsLib.zeroFloorSub(market[id].totalBorrowAssets, repaidAssets).toUint128();
+
+		position[id][borrower].collateral -= seizedAssets.toUint128();
+
+		uint256 badDebtShares;
+		uint256 badDebtAssets;
+		if (position[id][borrower].collateral == 0) {
+			badDebtShares = position[id][borrower].borrowShares;
+			badDebtAssets = UtilsLib.min(market[id].totalBorrowAssets, badDebtShares.toAssetsUp(market[id].totalBorrowAssets, market[id].totalBorrowShares));
+
+			market[id].totalBorrowAssets -= badDebtAssets.toUint128();
+			market[id].totalSupplyAssets -= badDebtAssets.toUint128();
+			market[id].totalBorrowShares -= badDebtShares.toUint128();
+			position[id][borrower].borrowShares = 0;
+		}
+
+		// `repaidAssets` may be greater than `totalBorrowAssets` by 1.
+		emit EventsLib.Liquidate(id, msg.sender, borrower, repaidAssets, repaidShares, seizedAssets, badDebtAssets, badDebtShares);
+
+		IERC20(marketParams.collateralToken).safeTransfer(msg.sender, seizedAssets);
+
+		if (data.length > 0) IMorphoLiquidateCallback(msg.sender).onMorphoLiquidate(repaidAssets, data);
+
+		IERC20(marketParams.loanToken).safeTransferFrom(msg.sender, address(this), repaidAssets);
+
+		return (seizedAssets, repaidAssets);
+	}
+
+	/* FLASH LOANS */
+
+	/// @inheritdoc IMorphoBase
+	function flashLoan(address token, uint256 assets, bytes calldata data) external {
+		require(assets != 0, ErrorsLib.ZERO_ASSETS);
+
+		emit EventsLib.FlashLoan(msg.sender, token, assets);
+
+		IERC20(token).safeTransfer(msg.sender, assets);
+
+		IMorphoFlashLoanCallback(msg.sender).onMorphoFlashLoan(assets, data);
+
+		IERC20(token).safeTransferFrom(msg.sender, address(this), assets);
+	}
+
+	/* AUTHORIZATION */
+
+	/// @inheritdoc IMorphoBase
+	function setAuthorization(address authorized, bool newIsAuthorized) external {
+		require(newIsAuthorized != isAuthorized[msg.sender][authorized], ErrorsLib.ALREADY_SET);
+
+		isAuthorized[msg.sender][authorized] = newIsAuthorized;
+
+		emit EventsLib.SetAuthorization(msg.sender, msg.sender, authorized, newIsAuthorized);
+	}
+
+	/// @inheritdoc IMorphoBase
+	function setAuthorizationWithSig(Authorization memory authorization, Signature calldata signature) external {
+		/// Do not check whether authorization is already set because the nonce increment is a desired side effect.
+		require(block.timestamp <= authorization.deadline, ErrorsLib.SIGNATURE_EXPIRED);
+		require(authorization.nonce == nonce[authorization.authorizer]++, ErrorsLib.INVALID_NONCE);
+
+		bytes32 hashStruct = keccak256(abi.encode(AUTHORIZATION_TYPEHASH, authorization));
+		bytes32 digest = keccak256(bytes.concat('\x19\x01', DOMAIN_SEPARATOR, hashStruct));
+		address signatory = ecrecover(digest, signature.v, signature.r, signature.s);
+
+		require(signatory != address(0) && authorization.authorizer == signatory, ErrorsLib.INVALID_SIGNATURE);
+
+		emit EventsLib.IncrementNonce(msg.sender, authorization.authorizer, authorization.nonce);
+
+		isAuthorized[authorization.authorizer][authorization.authorized] = authorization.isAuthorized;
+
+		emit EventsLib.SetAuthorization(msg.sender, authorization.authorizer, authorization.authorized, authorization.isAuthorized);
+	}
+
+	/// @dev Returns whether the sender is authorized to manage `onBehalf`'s positions.
+	function _isSenderAuthorized(address onBehalf) internal view returns (bool) {
+		return msg.sender == onBehalf || isAuthorized[onBehalf][msg.sender];
+	}
+
+	/* INTEREST MANAGEMENT */
+
+	/// @inheritdoc IMorphoBase
+	function accrueInterest(MarketParams memory marketParams) external {
+		Id id = marketParams.id();
+		require(market[id].lastUpdate != 0, ErrorsLib.MARKET_NOT_CREATED);
+
+		_accrueInterest(marketParams, id);
+	}
+
+	/// @dev Accrues interest for the given market `marketParams`.
+	/// @dev Assumes that the inputs `marketParams` and `id` match.
+	function _accrueInterest(MarketParams memory marketParams, Id id) internal {
+		uint256 elapsed = block.timestamp - market[id].lastUpdate;
+		if (elapsed == 0) return;
+
+		if (marketParams.irm != address(0)) {
+			uint256 borrowRate = IIrm(marketParams.irm).borrowRate(marketParams, market[id]);
+			uint256 interest = market[id].totalBorrowAssets.wMulDown(borrowRate.wTaylorCompounded(elapsed));
+			market[id].totalBorrowAssets += interest.toUint128();
+			market[id].totalSupplyAssets += interest.toUint128();
+
+			uint256 feeShares;
+			if (market[id].fee != 0) {
+				uint256 feeAmount = interest.wMulDown(market[id].fee);
+				// The fee amount is subtracted from the total supply in this calculation to compensate for the fact
+				// that total supply is already increased by the full interest (including the fee amount).
+				feeShares = feeAmount.toSharesDown(market[id].totalSupplyAssets - feeAmount, market[id].totalSupplyShares);
+				position[id][feeRecipient].supplyShares += feeShares;
+				market[id].totalSupplyShares += feeShares.toUint128();
+			}
+
+			emit EventsLib.AccrueInterest(id, borrowRate, interest, feeShares);
+		}
+
+		// Safe "unchecked" cast.
+		market[id].lastUpdate = uint128(block.timestamp);
+	}
+
+	/* HEALTH CHECK */
+
+	/// @dev Returns whether the position of `borrower` in the given market `marketParams` is healthy.
+	/// @dev Assumes that the inputs `marketParams` and `id` match.
+	function _isHealthy(MarketParams memory marketParams, Id id, address borrower) internal view returns (bool) {
+		if (position[id][borrower].borrowShares == 0) return true;
+
+		uint256 collateralPrice = IOracle(marketParams.oracle).price();
+
+		return _isHealthy(marketParams, id, borrower, collateralPrice);
+	}
+
+	/// @dev Returns whether the position of `borrower` in the given market `marketParams` with the given
+	/// `collateralPrice` is healthy.
+	/// @dev Assumes that the inputs `marketParams` and `id` match.
+	/// @dev Rounds in favor of the protocol, so one might not be able to borrow exactly `maxBorrow` but one unit less.
+	function _isHealthy(MarketParams memory marketParams, Id id, address borrower, uint256 collateralPrice) internal view returns (bool) {
+		uint256 borrowed = uint256(position[id][borrower].borrowShares).toAssetsUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
+		uint256 maxBorrow = uint256(position[id][borrower].collateral).mulDivDown(collateralPrice, ORACLE_PRICE_SCALE).wMulDown(marketParams.lltv);
+
+		return maxBorrow >= borrowed;
+	}
+
+	/* STORAGE VIEW */
+
+	/// @inheritdoc IMorphoBase
+	function extSloads(bytes32[] calldata slots) external view returns (bytes32[] memory res) {
+		uint256 nSlots = slots.length;
+
+		res = new bytes32[](nSlots);
+
+		for (uint256 i; i < nSlots; ) {
+			bytes32 slot = slots[i++];
+
+			assembly ('memory-safe') {
+				mstore(add(res, mul(i, 32)), sload(slot))
+			}
+		}
+	}
+}

package/contracts/morpho/helpers/MorphoChainlinkOracleV2.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.8.20;
+
+import {IOracle} from './IOracle.sol';
+import {IMorphoChainlinkOracleV2} from './IMorphoChainlinkOracleV2.sol';
+
+import {ErrorsLib} from './ErrorsLib.sol';
+import {IERC4626, VaultLib} from './VaultLib.sol';
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+import {AggregatorV3Interface, ChainlinkDataFeedLib} from './ChainlinkDataFeedLib.sol';
+
+/// @title MorphoChainlinkOracleV2
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Morpho Blue oracle using Chainlink-compliant feeds.
+contract MorphoChainlinkOracleV2 is IMorphoChainlinkOracleV2 {
+	using Math for uint256;
+	using VaultLib for IERC4626;
+	using ChainlinkDataFeedLib for AggregatorV3Interface;
+
+	/* IMMUTABLES */
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	IERC4626 public immutable BASE_VAULT;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	uint256 public immutable BASE_VAULT_CONVERSION_SAMPLE;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	IERC4626 public immutable QUOTE_VAULT;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	uint256 public immutable QUOTE_VAULT_CONVERSION_SAMPLE;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	AggregatorV3Interface public immutable BASE_FEED_1;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	AggregatorV3Interface public immutable BASE_FEED_2;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	AggregatorV3Interface public immutable QUOTE_FEED_1;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	AggregatorV3Interface public immutable QUOTE_FEED_2;
+
+	/// @inheritdoc IMorphoChainlinkOracleV2
+	uint256 public immutable SCALE_FACTOR;
+
+	/* CONSTRUCTOR */
+
+	/// @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.
+	/// @dev The base asset should be the collateral token and the quote asset the loan token.
+	constructor(
+		IERC4626 baseVault,
+		uint256 baseVaultConversionSample,
+		AggregatorV3Interface baseFeed1,
+		AggregatorV3Interface baseFeed2,
+		uint256 baseTokenDecimals,
+		IERC4626 quoteVault,
+		uint256 quoteVaultConversionSample,
+		AggregatorV3Interface quoteFeed1,
+		AggregatorV3Interface quoteFeed2,
+		uint256 quoteTokenDecimals
+	) {
+		// The ERC4626 vault parameters are used to price their respective conversion samples of their respective
+		// shares, so it requires multiplying by `QUOTE_VAULT_CONVERSION_SAMPLE` and dividing
+		// by `BASE_VAULT_CONVERSION_SAMPLE` in the `SCALE_FACTOR` definition.
+		// Verify that vault = address(0) => vaultConversionSample = 1 for each vault.
+		require(
+			address(baseVault) != address(0) || baseVaultConversionSample == 1,
+			ErrorsLib.VAULT_CONVERSION_SAMPLE_IS_NOT_ONE
+		);
+		require(
+			address(quoteVault) != address(0) || quoteVaultConversionSample == 1,
+			ErrorsLib.VAULT_CONVERSION_SAMPLE_IS_NOT_ONE
+		);
+		require(baseVaultConversionSample != 0, ErrorsLib.VAULT_CONVERSION_SAMPLE_IS_ZERO);
+		require(quoteVaultConversionSample != 0, ErrorsLib.VAULT_CONVERSION_SAMPLE_IS_ZERO);
+
+		BASE_VAULT = baseVault;
+		BASE_VAULT_CONVERSION_SAMPLE = baseVaultConversionSample;
+		QUOTE_VAULT = quoteVault;
+		QUOTE_VAULT_CONVERSION_SAMPLE = quoteVaultConversionSample;
+		BASE_FEED_1 = baseFeed1;
+		BASE_FEED_2 = baseFeed2;
+		QUOTE_FEED_1 = quoteFeed1;
+		QUOTE_FEED_2 = quoteFeed2;
+
+		// In the following comment, we explain the general case (where we assume that no feed is the address zero)
+		// how to scale the output price as Morpho Blue expects, given the input feed prices.
+		// Similar explanations would hold in the case where some of the feeds are the address zero.
+
+		// Let B1, B2, Q1, Q2, C be 5 assets, each respectively having dB1, dB2, dQ1, dQ2, dC decimals.
+		// Let pB1 and pB2 be the base prices, and pQ1 and pQ2 the quote prices, so that:
+		// - pB1 is the quantity of 1e(dB2) assets B2 that can be exchanged for 1e(dB1) assets B1.
+		// - pB2 is the quantity of 1e(dC) assets C that can be exchanged for 1e(dB2) assets B2.
+		// - pQ1 is the quantity of 1e(dQ2) assets Q2 that can be exchanged for 1e(dQ1) assets Q1.
+		// - pQ2 is the quantity of 1e(dC) assets C that can be exchanged for 1e(dQ2) assets B2.
+
+		// Morpho Blue expects `price()` to be the quantity of 1 asset Q1 that can be exchanged for 1 asset B1,
+		// scaled by 1e36:
+		// 1e36 * (pB1 * 1e(dB2 - dB1)) * (pB2 * 1e(dC - dB2)) / ((pQ1 * 1e(dQ2 - dQ1)) * (pQ2 * 1e(dC - dQ2)))
+		// = 1e36 * (pB1 * 1e(-dB1) * pB2) / (pQ1 * 1e(-dQ1) * pQ2)
+
+		// Let fpB1, fpB2, fpQ1, fpQ2 be the feed precision of the respective prices pB1, pB2, pQ1, pQ2.
+		// Feeds return pB1 * 1e(fpB1), pB2 * 1e(fpB2), pQ1 * 1e(fpQ1) and pQ2 * 1e(fpQ2).
+
+		// Based on the implementation of `price()` below, the value of `SCALE_FACTOR` should thus satisfy:
+		// (pB1 * 1e(fpB1)) * (pB2 * 1e(fpB2)) * SCALE_FACTOR / ((pQ1 * 1e(fpQ1)) * (pQ2 * 1e(fpQ2)))
+		// = 1e36 * (pB1 * 1e(-dB1) * pB2) / (pQ1 * 1e(-dQ1) * pQ2)
+
+		// So SCALE_FACTOR = 1e36 * 1e(-dB1) * 1e(dQ1) * 1e(-fpB1) * 1e(-fpB2) * 1e(fpQ1) * 1e(fpQ2)
+		//                 = 1e(36 + dQ1 + fpQ1 + fpQ2 - dB1 - fpB1 - fpB2)
+		SCALE_FACTOR =
+			(10 **
+				(36 +
+					quoteTokenDecimals +
+					quoteFeed1.getDecimals() +
+					quoteFeed2.getDecimals() -
+					baseTokenDecimals -
+					baseFeed1.getDecimals() -
+					baseFeed2.getDecimals()) *
+				quoteVaultConversionSample) /
+			baseVaultConversionSample;
+	}
+
+	/* PRICE */
+
+	/// @inheritdoc IOracle
+	function price() external view returns (uint256) {
+		return
+			SCALE_FACTOR.mulDiv(
+				BASE_VAULT.getAssets(BASE_VAULT_CONVERSION_SAMPLE) * BASE_FEED_1.getPrice() * BASE_FEED_2.getPrice(),
+				QUOTE_VAULT.getAssets(QUOTE_VAULT_CONVERSION_SAMPLE) * QUOTE_FEED_1.getPrice() * QUOTE_FEED_2.getPrice()
+			);
+	}
+}