@usdu-core/usdu-core 0.0.1

package/contracts/morpho/MorphoAdapterV1_2.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
+
+import {RewardDistributionV1, Stablecoin} from '../reward/RewardDistributionV1.sol';
+
+import {IMetaMorphoV1_1} from './helpers/IMetaMorphoV1_1.sol';
+
+/**
+ * @title MorphoAdapterV1_2
+ * @author @samclassix <samclassix@proton.me>, @wrytlabs <wrytlabs@proton.me>
+ * @notice This is an adapter for interacting with Morpho to mint liquidity straight into the market.
+ */
+contract MorphoAdapterV1_2 is RewardDistributionV1 {
+	using Math for uint256;
+	using SafeERC20 for Stablecoin;
+	using SafeERC20 for IMetaMorphoV1_1;
+
+	IMetaMorphoV1_1 public immutable core;
+
+	uint256 public totalMinted;
+	uint256 public totalRevenue;
+
+	// ---------------------------------------------------------------------------------------
+
+	event Deposit(uint256 amount, uint256 sharesCore, uint256 totalMinted);
+	event Redeem(uint256 amount, uint256 sharesCore, uint256 totalMinted);
+	event Revenue(uint256 amount, uint256 totalRevenue, uint256 totalMinted);
+
+	// ---------------------------------------------------------------------------------------
+
+	error NothingToReconcile(uint256 assets, uint256 minted);
+
+	// ---------------------------------------------------------------------------------------
+
+	constructor(
+		Stablecoin _stable,
+		IMetaMorphoV1_1 _core,
+		address[5] memory _receivers,
+		uint32[5] memory _weights
+	) RewardDistributionV1(_stable, _receivers, _weights) {
+		core = _core;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function totalAssets() public view returns (uint256) {
+		// this will use `_accruedFeeAndAssets`
+		return core.convertToAssets(core.balanceOf(address(this)));
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function deposit(uint256 amount) external onlyCurator {
+		// mint stables
+		stable.mintModule(address(this), amount);
+		totalMinted += amount;
+
+		// approve stable for deposit into core vault
+		stable.forceApprove(address(core), amount);
+		uint256 sharesCore = core.deposit(amount, address(this));
+
+		emit Deposit(amount, sharesCore, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function redeem(uint256 sharesCore) external onlyCurator {
+		// reconcile, triggers `_accruedFeeAndAssets` in vault
+		_reconcile(totalAssets(), true);
+
+		// redeem core shares from core vault
+		uint256 amount = core.redeem(sharesCore, address(this), address(this));
+
+		// reduce minted amount
+		if (totalMinted >= amount) {
+			stable.burn(amount);
+			totalMinted -= amount;
+		} else {
+			// fallback, burn existing totalMinted if available
+			if (totalMinted > 0) {
+				stable.burn(totalMinted);
+				totalMinted = 0;
+			}
+
+			// fallback, distribute remaining balance
+			_distribute();
+		}
+
+		emit Redeem(amount, sharesCore, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function reconcile() external {
+		_reconcile(totalAssets(), false);
+	}
+
+	function _reconcile(uint256 assets, bool allowPassing) internal returns (uint256) {
+		if (assets > totalMinted) {
+			// calc revenue
+			uint256 mintToReconcile = assets - totalMinted;
+			totalRevenue += mintToReconcile;
+
+			// mint revenue to reconcile
+			stable.mintModule(address(this), mintToReconcile);
+			totalMinted += mintToReconcile;
+			emit Revenue(mintToReconcile, totalRevenue, totalMinted);
+
+			// distribute balance
+			_distribute();
+
+			return mintToReconcile;
+		} else {
+			if (allowPassing) {
+				return 0;
+			} else {
+				revert NothingToReconcile(assets, totalMinted);
+			}
+		}
+	}
+}

package/contracts/morpho/helpers/AggregatorV3Interface.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+/// @dev From
+/// https://github.com/smartcontractkit/chainlink/blob/master/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol
+interface AggregatorV3Interface {
+	function decimals() external view returns (uint8);
+
+	function description() external view returns (string memory);
+
+	function version() external view returns (uint256);
+
+	function getRoundData(
+		uint80 _roundId
+	)
+		external
+		view
+		returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
+
+	function latestRoundData()
+		external
+		view
+		returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
+}

package/contracts/morpho/helpers/ChainlinkDataFeedLib.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {AggregatorV3Interface} from './AggregatorV3Interface.sol';
+
+import {ErrorsLib} from './ErrorsLib.sol';
+
+/// @title ChainlinkDataFeedLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library exposing functions to interact with a Chainlink-compliant feed.
+library ChainlinkDataFeedLib {
+	/// @dev Performs safety checks and returns the latest price of a `feed`.
+	/// @dev When `feed` is the address zero, returns 1.
+	/// @dev Notes on safety checks:
+	/// - L2s are not supported.
+	/// - Staleness is not checked because it's assumed that the Chainlink feed keeps its promises on this.
+	/// - The price is not checked to be in the min/max bounds because it's assumed that the Chainlink feed keeps its
+	/// promises on this.
+	function getPrice(AggregatorV3Interface feed) internal view returns (uint256) {
+		if (address(feed) == address(0)) return 1;
+
+		(, int256 answer, , , ) = feed.latestRoundData();
+		require(answer >= 0, ErrorsLib.NEGATIVE_ANSWER);
+
+		return uint256(answer);
+	}
+
+	/// @dev Returns the number of decimals of a `feed`.
+	/// @dev When `feed` is the address zero, returns 0.
+	function getDecimals(AggregatorV3Interface feed) internal view returns (uint256) {
+		if (address(feed) == address(0)) return 0;
+
+		return feed.decimals();
+	}
+}

package/contracts/morpho/helpers/ConstantsLib.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+/// @title ConstantsLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library exposing constants.
+library ConstantsLib {
+    /// @dev The maximum delay of a timelock.
+    uint256 internal constant MAX_TIMELOCK = 2 weeks;
+
+    /// @dev The minimum delay of a timelock post initialization.
+    uint256 internal constant POST_INITIALIZATION_MIN_TIMELOCK = 1 days;
+
+    /// @dev The maximum number of markets in the supply/withdraw queue.
+    uint256 internal constant MAX_QUEUE_LENGTH = 30;
+
+    /// @dev The maximum fee the vault can have (50%).
+    uint256 internal constant MAX_FEE = 0.5e18;
+}

package/contracts/morpho/helpers/ErrorsLib.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+/// @title ErrorsLib
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Library exposing error messages.
+library ErrorsLib {
+	/// @notice Thrown when the answer returned by a Chainlink feed is negative.
+	string constant NEGATIVE_ANSWER = 'negative answer';
+
+	/// @notice Thrown when the vault conversion sample is 0.
+	string constant VAULT_CONVERSION_SAMPLE_IS_ZERO = 'vault conversion sample is zero';
+
+	/// @notice Thrown when the vault conversion sample is not 1 while vault = address(0).
+	string constant VAULT_CONVERSION_SAMPLE_IS_NOT_ONE = 'vault conversion sample is not one';
+}

package/contracts/morpho/helpers/IERC4626.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+interface IERC4626 {
+	function convertToAssets(uint256) external view returns (uint256);
+}

package/contracts/morpho/helpers/IMetaMorphoV1_1.sol

@@ -0,0 +1,229 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import {IMorpho, Id, MarketParams} from './IMorpho.sol';
+import {IERC4626} from '@openzeppelin/contracts/interfaces/IERC4626.sol';
+import {IERC20Permit} from '@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol';
+
+import {MarketConfig, PendingUint192, PendingAddress} from './PendingLib.sol';
+
+struct MarketAllocation {
+	/// @notice The market to allocate.
+	MarketParams marketParams;
+	/// @notice The amount of assets to allocate.
+	uint256 assets;
+}
+
+interface IMulticall {
+	function multicall(bytes[] calldata) external returns (bytes[] memory);
+}
+
+interface IOwnable {
+	function owner() external view returns (address);
+
+	function transferOwnership(address) external;
+
+	function renounceOwnership() external;
+
+	function acceptOwnership() external;
+
+	function pendingOwner() external view returns (address);
+}
+
+/// @dev This interface is used for factorizing IMetaMorphoV1_1StaticTyping and IMetaMorphoV1_1.
+/// @dev Consider using the IMetaMorphoV1_1 interface instead of this one.
+interface IMetaMorphoV1_1Base {
+	/// @notice The address of the Morpho contract.
+	function MORPHO() external view returns (IMorpho);
+
+	/// @notice OpenZeppelin decimals offset used by the ERC4626 implementation.
+	/// @dev Calculated to be max(0, 18 - underlyingDecimals).
+	/// @dev When equal to zero (<=> token decimals >= 18), the protection against the inflation front-running attack on
+	/// empty vault is low (see https://docs.openzeppelin.com/contracts/5.x/erc4626#inflation-attack). To protect
+	/// against this attack, vault deployers should make an initial deposit of a non-trivial amount in the vault or
+	/// depositors should check that the share price does not exceed a certain limit.
+	function DECIMALS_OFFSET() external view returns (uint8);
+
+	/// @notice The address of the curator.
+	function curator() external view returns (address);
+
+	/// @notice Stores whether an address is an allocator or not.
+	function isAllocator(address target) external view returns (bool);
+
+	/// @notice The current guardian. Can be set even without the timelock set.
+	function guardian() external view returns (address);
+
+	/// @notice The current fee.
+	function fee() external view returns (uint96);
+
+	/// @notice The fee recipient.
+	function feeRecipient() external view returns (address);
+
+	/// @notice The skim recipient.
+	function skimRecipient() external view returns (address);
+
+	/// @notice The current timelock.
+	function timelock() external view returns (uint256);
+
+	/// @dev Stores the order of markets on which liquidity is supplied upon deposit.
+	/// @dev Can contain any market. A market is skipped as soon as its supply cap is reached.
+	function supplyQueue(uint256) external view returns (Id);
+
+	/// @notice Returns the length of the supply queue.
+	function supplyQueueLength() external view returns (uint256);
+
+	/// @dev Stores the order of markets from which liquidity is withdrawn upon withdrawal.
+	/// @dev Always contain all non-zero cap markets as well as all markets on which the vault supplies liquidity,
+	/// without duplicate.
+	function withdrawQueue(uint256) external view returns (Id);
+
+	/// @notice Returns the length of the withdraw queue.
+	function withdrawQueueLength() external view returns (uint256);
+
+	/// @notice Stores the total assets managed by this vault when the fee was last accrued.
+	function lastTotalAssets() external view returns (uint256);
+
+	/// @notice Stores the missing assets due to realized bad debt or forced market removal.
+	/// @dev In order to cover those lost assets, it is advised to supply on behalf of address(1) on the vault
+	/// (canonical method).
+	function lostAssets() external view returns (uint256);
+
+	/// @notice Submits a `newTimelock`.
+	/// @dev Warning: Reverts if a timelock is already pending. Revoke the pending timelock to overwrite it.
+	/// @dev In case the new timelock is higher than the current one, the timelock is set immediately.
+	function submitTimelock(uint256 newTimelock) external;
+
+	/// @notice Accepts the pending timelock.
+	function acceptTimelock() external;
+
+	/// @notice Revokes the pending timelock.
+	/// @dev Does not revert if there is no pending timelock.
+	function revokePendingTimelock() external;
+
+	/// @notice Submits a `newSupplyCap` for the market defined by `marketParams`.
+	/// @dev Warning: Reverts if a cap is already pending. Revoke the pending cap to overwrite it.
+	/// @dev Warning: Reverts if a market removal is pending.
+	/// @dev In case the new cap is lower than the current one, the cap is set immediately.
+	function submitCap(MarketParams memory marketParams, uint256 newSupplyCap) external;
+
+	/// @notice Accepts the pending cap of the market defined by `marketParams`.
+	function acceptCap(MarketParams memory marketParams) external;
+
+	/// @notice Revokes the pending cap of the market defined by `id`.
+	/// @dev Does not revert if there is no pending cap.
+	function revokePendingCap(Id id) external;
+
+	/// @notice Submits a forced market removal from the vault, eventually losing all funds supplied to the market.
+	/// @notice This forced removal is expected to be used as an emergency process in case a market constantly reverts.
+	/// To softly remove a sane market, the curator role is expected to bundle a reallocation that empties the market
+	/// first (using `reallocate`), followed by the removal of the market (using `updateWithdrawQueue`).
+	/// @dev Warning: Reverts for non-zero cap or if there is a pending cap. Successfully submitting a zero cap will
+	/// prevent such reverts.
+	function submitMarketRemoval(MarketParams memory marketParams) external;
+
+	/// @notice Revokes the pending removal of the market defined by `id`.
+	/// @dev Does not revert if there is no pending market removal.
+	function revokePendingMarketRemoval(Id id) external;
+
+	/// @notice Sets the name of the vault.
+	function setName(string memory newName) external;
+
+	/// @notice Sets the symbol of the vault.
+	function setSymbol(string memory newSymbol) external;
+
+	/// @notice Submits a `newGuardian`.
+	/// @notice Warning: a malicious guardian could disrupt the vault's operation, and would have the power to revoke
+	/// any pending guardian.
+	/// @dev In case there is no guardian, the gardian is set immediately.
+	/// @dev Warning: Submitting a gardian will overwrite the current pending gardian.
+	function submitGuardian(address newGuardian) external;
+
+	/// @notice Accepts the pending guardian.
+	function acceptGuardian() external;
+
+	/// @notice Revokes the pending guardian.
+	function revokePendingGuardian() external;
+
+	/// @notice Skims the vault `token` balance to `skimRecipient`.
+	function skim(address) external;
+
+	/// @notice Sets `newAllocator` as an allocator or not (`newIsAllocator`).
+	function setIsAllocator(address newAllocator, bool newIsAllocator) external;
+
+	/// @notice Sets `curator` to `newCurator`.
+	function setCurator(address newCurator) external;
+
+	/// @notice Sets the `fee` to `newFee`.
+	function setFee(uint256 newFee) external;
+
+	/// @notice Sets `feeRecipient` to `newFeeRecipient`.
+	function setFeeRecipient(address newFeeRecipient) external;
+
+	/// @notice Sets `skimRecipient` to `newSkimRecipient`.
+	function setSkimRecipient(address newSkimRecipient) external;
+
+	/// @notice Sets `supplyQueue` to `newSupplyQueue`.
+	/// @param newSupplyQueue is an array of enabled markets, and can contain duplicate markets, but it would only
+	/// increase the cost of depositing to the vault.
+	function setSupplyQueue(Id[] calldata newSupplyQueue) external;
+
+	/// @notice Updates the withdraw queue. Some markets can be removed, but no market can be added.
+	/// @notice Removing a market requires the vault to have 0 supply on it, or to have previously submitted a removal
+	/// for this market (with the function `submitMarketRemoval`).
+	/// @notice Warning: Anyone can supply on behalf of the vault so the call to `updateWithdrawQueue` that expects a
+	/// market to be empty can be griefed by a front-run. To circumvent this, the allocator can simply bundle a
+	/// reallocation that withdraws max from this market with a call to `updateWithdrawQueue`.
+	/// @dev Warning: Removing a market with supply will decrease the fee accrued until one of the functions updating
+	/// `lastTotalAssets` is triggered (deposit/mint/withdraw/redeem/setFee/setFeeRecipient).
+	/// @dev Warning: `updateWithdrawQueue` is not idempotent. Submitting twice the same tx will change the queue twice.
+	/// @param indexes The indexes of each market in the previous withdraw queue, in the new withdraw queue's order.
+	function updateWithdrawQueue(uint256[] calldata indexes) external;
+
+	/// @notice Reallocates the vault's liquidity so as to reach a given allocation of assets on each given market.
+	/// @dev The behavior of the reallocation can be altered by state changes, including:
+	/// - Deposits on the vault that supplies to markets that are expected to be supplied to during reallocation.
+	/// - Withdrawals from the vault that withdraws from markets that are expected to be withdrawn from during
+	/// reallocation.
+	/// - Donations to the vault on markets that are expected to be supplied to during reallocation.
+	/// - Withdrawals from markets that are expected to be withdrawn from during reallocation.
+	/// @dev Sender is expected to pass `assets = type(uint256).max` with the last MarketAllocation of `allocations` to
+	/// supply all the remaining withdrawn liquidity, which would ensure that `totalWithdrawn` = `totalSupplied`.
+	/// @dev A supply in a reallocation step will make the reallocation revert if the amount is greater than the net
+	/// amount from previous steps (i.e. total withdrawn minus total supplied).
+	function reallocate(MarketAllocation[] calldata allocations) external;
+}
+
+/// @dev This interface is inherited by MetaMorphoV1_1 so that function signatures are checked by the compiler.
+/// @dev Consider using the IMetaMorphoV1_1 interface instead of this one.
+interface IMetaMorphoV1_1StaticTyping is IMetaMorphoV1_1Base {
+	/// @notice Returns the current configuration of each market.
+	function config(Id) external view returns (uint184 cap, bool enabled, uint64 removableAt);
+
+	/// @notice Returns the pending guardian.
+	function pendingGuardian() external view returns (address guardian, uint64 validAt);
+
+	/// @notice Returns the pending cap for each market.
+	function pendingCap(Id) external view returns (uint192 value, uint64 validAt);
+
+	/// @notice Returns the pending timelock.
+	function pendingTimelock() external view returns (uint192 value, uint64 validAt);
+}
+
+/// @title IMetaMorphoV1_1
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @dev Use this interface for MetaMorphoV1_1 to have access to all the functions with the appropriate function
+/// signatures.
+interface IMetaMorphoV1_1 is IMetaMorphoV1_1Base, IERC4626, IERC20Permit, IOwnable, IMulticall {
+	/// @notice Returns the current configuration of each market.
+	function config(Id) external view returns (MarketConfig memory);
+
+	/// @notice Returns the pending guardian.
+	function pendingGuardian() external view returns (PendingAddress memory);
+
+	/// @notice Returns the pending cap for each market.
+	function pendingCap(Id) external view returns (PendingUint192 memory);
+
+	/// @notice Returns the pending timelock.
+	function pendingTimelock() external view returns (PendingUint192 memory);
+}

package/contracts/morpho/helpers/IMetaMorphoV1_1Factory.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import {IMetaMorphoV1_1} from './IMetaMorphoV1_1.sol';
+
+/// @title IMetaMorphoV1_1Factory
+/// @author Morpho Labs
+/// @custom:contact security@morpho.org
+/// @notice Interface of MetaMorphoV1_1's factory.
+interface IMetaMorphoV1_1Factory {
+	/// @notice The address of the Morpho contract.
+	function MORPHO() external view returns (address);
+
+	/// @notice Whether a MetaMorphoV1_1 vault was created with the factory.
+	function isMetaMorpho(address target) external view returns (bool);
+
+	/// @notice Creates a new MetaMorphoV1_1 vault.
+	/// @param initialOwner The owner of the vault.
+	/// @param initialTimelock The initial timelock of the vault.
+	/// @param asset The address of the underlying asset.
+	/// @param name The name of the vault.
+	/// @param symbol The symbol of the vault.
+	/// @param salt The salt to use for the MetaMorphoV1_1 vault's CREATE2 address.
+	function createMetaMorpho(
+		address initialOwner,
+		uint256 initialTimelock,
+		address asset,
+		string memory name,
+		string memory symbol,
+		bytes32 salt
+	) external returns (IMetaMorphoV1_1 metaMorpho);
+}