[Draft] Vaults UX suggestions

contracts/0.8.25/interfaces/ILido.sol

@@ -4,15 +4,16 @@
 // See contracts/COMPILERS.md
 pragma solidity 0.8.25;
 
-interface ILido {
+import {IERC20} from "@openzeppelin/contracts-v5.0.2/token/ERC20/IERC20.sol";
+import {IERC20Permit} from "@openzeppelin/contracts-v5.0.2/token/ERC20/extensions/IERC20Permit.sol";
+
+interface ILido is IERC20, IERC20Permit {
     function getSharesByPooledEth(uint256) external view returns (uint256);
 
     function getPooledEthByShares(uint256) external view returns (uint256);
 
     function getPooledEthBySharesRoundUp(uint256) external view returns (uint256);
 
-    function transferFrom(address, address, uint256) external;
-
     function transferSharesFrom(address, address, uint256) external returns (uint256);
 
     function rebalanceExternalEtherToInternal() external payable;

contracts/0.8.25/vaults/Dashboard.sol

@@ -4,11 +4,29 @@
 // See contracts/COMPILERS.md
 pragma solidity 0.8.25;
 
-import {IStakingVault} from "./interfaces/IStakingVault.sol";
 import {AccessControlEnumerable} from "@openzeppelin/contracts-v5.0.2/access/extensions/AccessControlEnumerable.sol";
 import {OwnableUpgradeable} from "contracts/openzeppelin/5.0.2/upgradeable/access/OwnableUpgradeable.sol";
+import {IERC20} from "@openzeppelin/contracts-v5.0.2/token/ERC20/IERC20.sol";
+import {IERC20Permit} from "@openzeppelin/contracts-v5.0.2/token/ERC20/extensions/IERC20Permit.sol";
+
+import {Math256} from "contracts/common/lib/Math256.sol";
+
 import {VaultHub} from "./VaultHub.sol";
-import {ILido as StETH} from "../interfaces/ILido.sol";
+
+import {IStakingVault} from "./interfaces/IStakingVault.sol";
+import {ILido as IStETH} from "../interfaces/ILido.sol";
+
+interface IWeth is IERC20 {
+    function withdraw(uint) external;
+
+    function deposit() external payable;
+}
+
+interface IWstETH is IERC20, IERC20Permit {
+    function wrap(uint256) external returns (uint256);
+
+    function unwrap(uint256) external returns (uint256);
+}
 
 /**
  * @title Dashboard
@@ -23,28 +41,50 @@
     /// @notice Address of the implementation contract
     /// @dev Used to prevent initialization in the implementation
     address private immutable _SELF;
+    /// @dev basis points base
+    uint256 private constant TOTAL_BASIS_POINTS = 100_00;
 
     /// @notice Indicates whether the contract has been initialized
     bool public isInitialized;
 
     /// @notice The stETH token contract
-    StETH public immutable STETH;
+    IStETH public immutable STETH;
+
+    /// @notice The wrapped staked ether token contract
+    IWstETH public immutable WSTETH;
+
+    /// @notice The wrapped ether token contract
+    IWeth public immutable WETH;
 
     /// @notice The underlying `StakingVault` contract
     IStakingVault public stakingVault;
 
     /// @notice The `VaultHub` contract
     VaultHub public vaultHub;
 
+    struct PermitInput {
+        uint256 value;
+        uint256 deadline;
+        uint8 v;
+        bytes32 r;
+        bytes32 s;
+    }
+
     /**
      * @notice Constructor sets the stETH token address and the implementation contract address.
      * @param _stETH Address of the stETH token contract.
+     * @param _weth Address of the weth token contract.
+     * @param _wstETH Address of the wstETH token contract.
      */
-    constructor(address _stETH) {
+    constructor(address _stETH, address _weth, address _wstETH) {
         if (_stETH == address(0)) revert ZeroArgument("_stETH");
+        if (_weth == address(0)) revert ZeroArgument("_WETH");
+        if (_wstETH == address(0)) revert ZeroArgument("_wstETH");
 
         _SELF = address(this);
-        STETH = StETH(_stETH);
+        STETH = IStETH(_stETH);
+        WETH = IWeth(_weth);
+        WSTETH = IWstETH(_wstETH);
     }
 
     /**
@@ -102,7 +142,7 @@
      * @notice Returns the reserve ratio of the vault
      * @return The reserve ratio as a uint16
      */
-    function reserveRatio() external view returns (uint16) {
+    function reserveRatio() public view returns (uint16) {
         return vaultSocket().reserveRatioBP;
     }
 
@@ -122,8 +162,55 @@
         return vaultSocket().treasuryFeeBP;
     }
 
+    /**
+     * @notice Returns the valuation of the vault in ether.
+     * @return The valuation as a uint256.
+     */
+    function valuation() external view returns (uint256) {
+        return stakingVault.valuation();
+    }
+
+    /**
+     * @notice Returns the total of shares that can be minted on the vault bound by valuation and vault share limit.
+     * @return The maximum number of stETH shares as a uint256.
+     */
+    function totalMintableShares() public view returns (uint256) {
+        return _totalMintableShares(stakingVault.valuation());
+    }
+
+    /**
+     * @notice Returns the maximum number of shares that can be minted with deposited ether.
+     * @param _ether the amount of ether to be funded, can be zero
+     * @return the maximum number of shares that can be minted by ether
+     */
+    function getMintableShares(uint256 _ether) external view returns (uint256) {
+        uint256 _totalShares = _totalMintableShares(stakingVault.valuation() + _ether);
+        uint256 _sharesMinted = vaultSocket().sharesMinted;
+
+        if (_totalShares < _sharesMinted) return 0;
+        return _totalShares - _sharesMinted;
+    }
+
+    /**
+     * @notice Returns the amount of ether that can be withdrawn from the staking vault.
+     * @return The amount of ether that can be withdrawn.
+     */
+    function getWithdrawableEther() external view returns (uint256) {
+        return Math256.min(address(stakingVault).balance, stakingVault.unlocked());
+    }
+
+    // TODO: add preview view methods for minting and burning
+
     // ==================== Vault Management Functions ====================
 
+    /**
+     * @dev Receive function to accept ether
+     */
+    // TODO: Consider the amount of ether on balance of the contract
+    receive() external payable {
+        if (msg.value == 0) revert ZeroArgument("msg.value");
+    }
+
     /**
      * @notice Transfers ownership of the staking vault to a new owner.
      * @param _newOwner Address of the new owner.
@@ -146,6 +233,20 @@
         _fund();
     }
 
+    /**
+     * @notice Funds the staking vault with wrapped ether. Approvals for the passed amounts should be done before.
+     * @param _wethAmount Amount of wrapped ether to fund the staking vault with
+     */
+    function fundByWeth(uint256 _wethAmount) external virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+        if (WETH.allowance(msg.sender, address(this)) < _wethAmount) revert("ERC20: transfer amount exceeds allowance");
+
+        WETH.transferFrom(msg.sender, address(this), _wethAmount);
+        WETH.withdraw(_wethAmount);
+
+        // TODO: find way to use _fund() instead of stakingVault directly
+        stakingVault.fund{value: _wethAmount}();
+    }
+
     /**
      * @notice Withdraws ether from the staking vault to a recipient
      * @param _recipient Address of the recipient
@@ -155,6 +256,17 @@
         _withdraw(_recipient, _ether);
     }
 
+    /**
+     * @notice Withdraws stETH tokens from the staking vault to wrapped ether.
+     * @param _recipient Address of the recipient
+     * @param _ether Amount of ether to withdraw
+     */
+    function withdrawToWeth(address _recipient, uint256 _ether) external virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+        _withdraw(address(this), _ether);
+        WETH.deposit{value: _ether}();
+        WETH.transfer(_recipient, _ether);
+    }
+
     /**
      * @notice Requests the exit of a validator from the staking vault
      * @param _validatorPublicKey Public key of the validator to exit
@@ -175,6 +287,22 @@
         _mint(_recipient, _amountOfShares);
     }
 
+    /**
+     * @notice Mints wstETH tokens backed by the vault to a recipient. Approvals for the passed amounts should be done before.
+     * @param _recipient Address of the recipient
+     * @param _tokens Amount of tokens to mint
+     */
+    function mintWstETH(
+        address _recipient,
+        uint256 _tokens
+    ) external payable virtual onlyRole(DEFAULT_ADMIN_ROLE) fundAndProceed {
+        _mint(address(this), _tokens);
+
+        STETH.approve(address(WSTETH), _tokens);
+        uint256 wstETHAmount = WSTETH.wrap(_tokens);
+        WSTETH.transfer(_recipient, wstETHAmount);
+    }
+
     /**
      * @notice Burns stETH shares from the sender backed by the vault
      * @param _amountOfShares Amount of shares to burn
@@ -183,6 +311,96 @@
         _burn(_amountOfShares);
     }
 
+    /**
+     * @notice Burns wstETH tokens from the sender backed by the vault. Approvals for the passed amounts should be done before.
+     * @param _tokens Amount of wstETH tokens to burn
+     */
+    function burnWstETH(uint256 _tokens) external virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+        WSTETH.transferFrom(msg.sender, address(this), _tokens);
+
+        uint256 stETHAmount = WSTETH.unwrap(_tokens);
+
+        STETH.transfer(address(vaultHub), stETHAmount);
+
+        uint256 sharesAmount = STETH.getSharesByPooledEth(stETHAmount);
+
+        vaultHub.burnSharesBackedByVault(address(stakingVault), sharesAmount);
+    }
+
+    /**
+     * @dev Modifier to check if the permit is successful, and if not, check if the allowance is sufficient
+     */
+    modifier trustlessPermit(
+        address token,
+        address owner,
+        address spender,
+        PermitInput calldata permitInput
+    ) {
+        // Try permit() before allowance check to advance nonce if possible
+        try
+            IERC20Permit(token).permit(
+                owner,
+                spender,
+                permitInput.value,
+                permitInput.deadline,
+                permitInput.v,
+                permitInput.r,
+                permitInput.s
+            )
+        {
+            _;
+            return;
+        } catch {
+            // Permit potentially got frontran. Continue anyways if allowance is sufficient.
+            if (IERC20(token).allowance(owner, spender) >= permitInput.value) {
+                _;
+                return;
+            }
+        }
+        revert("Permit failure");
+    }
+
+    /**
+     * @notice Burns stETH tokens from the sender backed by the vault using EIP-2612 Permit.
+     * @param _tokens Amount of stETH tokens to burn
+     * @param _permit data required for the stETH.permit() method to set the allowance
+     */
+    function burnWithPermit(
+        uint256 _tokens,
+        PermitInput calldata _permit
+    )
+        external
+        virtual
+        onlyRole(DEFAULT_ADMIN_ROLE)
+        trustlessPermit(address(STETH), msg.sender, address(this), _permit)
+    {
+        _burn(_tokens);
+    }
+
+    /**
+     * @notice Burns wstETH tokens from the sender backed by the vault using EIP-2612 Permit.
+     * @param _tokens Amount of wstETH tokens to burn
+     * @param _permit data required for the wstETH.permit() method to set the allowance
+     */
+    function burnWstETHWithPermit(
+        uint256 _tokens,
+        PermitInput calldata _permit
+    )
+        external
+        virtual
+        onlyRole(DEFAULT_ADMIN_ROLE)
+        trustlessPermit(address(WSTETH), msg.sender, address(this), _permit)
+    {
+        WSTETH.transferFrom(msg.sender, address(this), _tokens);
+        uint256 stETHAmount = WSTETH.unwrap(_tokens);
+
+        STETH.transfer(address(vaultHub), stETHAmount);
+
+        uint256 sharesAmount = STETH.getSharesByPooledEth(stETHAmount);
+
+        vaultHub.burnSharesBackedByVault(address(stakingVault), sharesAmount);
+    }
+
     /**
      * @notice Rebalances the vault by transferring ether
      * @param _ether Amount of ether to rebalance
@@ -279,6 +497,15 @@
         vaultHub.burnSharesBackedByVault(address(stakingVault), _amountOfShares);
     }
 
+    /**
+     * @dev calculates total shares vault can mint
+     * @param _valuation custom vault valuation
+     */
+    function _totalMintableShares(uint256 _valuation) internal view returns (uint256) {
+        uint256 maxMintableStETH = (_valuation * (TOTAL_BASIS_POINTS - vaultSocket().reserveRatioBP)) / TOTAL_BASIS_POINTS;
+        return Math256.min(STETH.getSharesByPooledEth(maxMintableStETH), vaultSocket().shareLimit);
+    }
+
     /**
      * @dev Rebalances the vault by transferring ether
      * @param _ether Amount of ether to rebalance

contracts/0.8.25/vaults/Delegation.sol

@@ -97,8 +97,10 @@ contract Delegation is Dashboard {
     /**
      * @notice Constructor sets the stETH token address.
      * @param _stETH Address of the stETH token contract.
+     * @param _weth Address of the weth token contract.
+     * @param _wstETH Address of the wstETH token contract.
      */
-    constructor(address _stETH) Dashboard(_stETH) {}
+    constructor(address _stETH, address _weth, address _wstETH) Dashboard(_stETH, _weth, _wstETH) {}
 
     /**
      * @notice Initializes the contract with the default admin and `StakingVault` address.

contracts/0.8.25/vaults/StakingVault.sol

@@ -118,6 +118,7 @@ contract StakingVault is IStakingVault, IBeaconProxy, BeaconChainDepositLogistic
      * @notice Initializes `StakingVault` with an owner, operator, and optional parameters
      * @param _owner Address that will own the vault
      * @param _operator Address of the node operator
+     * @param - Additional initialization parameters
      */
     function initialize(address _owner, address _operator, bytes calldata /* _params */ ) external onlyBeacon initializer {
         __Ownable_init(_owner);