OETH withdrawal queue

contracts/contracts/interfaces/IDripper.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IDripper {
+    /// @notice How much funds have dripped out already and are currently
+    //   available to be sent to the vault.
+    /// @return The amount that would be sent if a collect was called
+    function availableFunds() external view returns (uint256);
+
+    /// @notice Collect all dripped funds and send to vault.
+    ///  Recalculate new drip rate.
+    function collect() external;
+
+    /// @notice Collect all dripped funds, send to vault, recalculate new drip
+    ///  rate, and rebase mToken.
+    function collectAndRebase() external;
+
+    /// @notice Change the drip duration. Governor only.
+    /// @param _durationSeconds the number of seconds to drip out the entire
+    ///  balance over if no collects were called during that time.
+    function setDripDuration(uint256 _durationSeconds) external;
+
+    /// @dev Transfer out ERC20 tokens held by the contract. Governor only.
+    /// @param _asset ERC20 token address
+    /// @param _amount amount to transfer
+    function transferToken(address _asset, uint256 _amount) external;
+}

contracts/contracts/interfaces/IVault.sol

@@ -36,6 +36,19 @@ interface IVault {
     );
     event StrategyAddedToMintWhitelist(address indexed strategy);
     event StrategyRemovedFromMintWhitelist(address indexed strategy);
+    event DripperChanged(address indexed _dripper);
+    event WithdrawalRequested(
+        address indexed _withdrawer,
+        uint256 indexed _requestId,
+        uint256 _amount,
+        uint256 _queued
+    );
+    event WithdrawalClaimed(
+        address indexed _withdrawer,
+        uint256 indexed _requestId,
+        uint256 _amount
+    );
+    event WithdrawalClaimable(uint256 _claimable, uint256 _newClaimable);
 
     // Governable.sol
     function transferGovernance(address _newGovernor) external;
@@ -205,6 +218,8 @@ interface IVault {
 
     function netOusdMintedForStrategy() external view returns (int256);
 
+    function setDripper(address _dripper) external;
+
     function weth() external view returns (address);
 
     function cacheWETHAssetIndex() external;
@@ -225,4 +240,29 @@ interface IVault {
         external
         view
         returns (bool);
+
+    // These are OETH specific functions
+    function addWithdrawalQueueLiquidity() external;
+
+    function requestWithdrawal(uint256 _amount)
+        external
+        returns (uint256 requestId, uint256 queued);
+
+    function claimWithdrawal(uint256 requestId)
+        external
+        returns (uint256 amount);
+
+    function claimWithdrawals(uint256[] memory requestIds)
+        external
+        returns (uint256[] memory amounts, uint256 totalAmount);
+
+    function withdrawalQueueMetadata()
+        external
+        view
+        returns (VaultStorage.WithdrawalQueueMetadata memory);
+
+    function withdrawalRequests(uint256 requestId)
+        external
+        view
+        returns (VaultStorage.WithdrawalRequest memory);
 }

contracts/contracts/mocks/MockStrategy.sol

@@ -6,6 +6,9 @@ import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 contract MockStrategy {
     address[] public assets;
 
+    address public withdrawAllAsset;
+    address public withdrawAllRecipient;
+
     constructor() {}
 
     function deposit(address asset, uint256 amount) external {}
@@ -21,7 +24,10 @@ contract MockStrategy {
     }
 
     function withdrawAll() external {
-        require(false, "Not implemented");
+        IERC20(withdrawAllAsset).transfer(
+            withdrawAllRecipient,
+            IERC20(withdrawAllAsset).balanceOf(address(this))
+        );
     }
 
     function checkBalance(address asset)
@@ -45,4 +51,9 @@ contract MockStrategy {
     {
         return new address[](0);
     }
+
+    function setWithdrawAll(address asset, address recipient) external {
+        withdrawAllAsset = asset;
+        withdrawAllRecipient = recipient;
+    }
 }

contracts/contracts/vault/OETHVaultAdmin.sol

@@ -1,12 +1,105 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { IStrategy } from "../interfaces/IStrategy.sol";
+import { IVault } from "../interfaces/IVault.sol";
 import { VaultAdmin } from "./VaultAdmin.sol";
 
 /**
  * @title OETH VaultAdmin Contract
  * @author Origin Protocol Inc
  */
 contract OETHVaultAdmin is VaultAdmin {
+    using SafeERC20 for IERC20;
+
+    address public immutable weth;
+
+    constructor(address _weth) {
+        weth = _weth;
+    }
+
+    /// @dev Simplified version of the deposit function as WETH is the only supported asset.
+    function _depositToStrategy(
+        address _strategyToAddress,
+        address[] calldata _assets,
+        uint256[] calldata _amounts
+    ) internal override {
+        require(
+            strategies[_strategyToAddress].isSupported,
+            "Invalid to Strategy"
+        );
+        require(
+            _assets.length == 1 && _amounts.length == 1 && _assets[0] == weth,
+            "Only WETH is supported"
+        );
+
+        // Check the there is enough WETH to transfer once the WETH reserved for the withdrawal queue is accounted for
+        require(_amounts[0] <= _wethAvailable(), "Not enough WETH available");
+
+        // Send required amount of funds to the strategy
+        IERC20(weth).safeTransfer(_strategyToAddress, _amounts[0]);
+
+        // Deposit all the funds that have been sent to the strategy
+        IStrategy(_strategyToAddress).depositAll();
+    }
+
+    function _withdrawFromStrategy(
+        address _recipient,
+        address _strategyFromAddress,
+        address[] calldata _assets,
+        uint256[] calldata _amounts
+    ) internal override {
+        super._withdrawFromStrategy(
+            _recipient,
+            _strategyFromAddress,
+            _assets,
+            _amounts
+        );
+
+        IVault(address(this)).addWithdrawalQueueLiquidity();
+    }
+
+    function _withdrawAllFromStrategy(address _strategyAddr) internal override {
+        super._withdrawAllFromStrategy(_strategyAddr);
+
+        IVault(address(this)).addWithdrawalQueueLiquidity();
+    }
+
+    function _withdrawAllFromStrategies() internal override {
+        super._withdrawAllFromStrategies();
+
+        IVault(address(this)).addWithdrawalQueueLiquidity();
+    }
+
+    /// @dev Calculate how much WETH in the vault is not reserved for the withdrawal queue.
+    // That is, it is available to be redeemed or deposited into a strategy.
+    function _wethAvailable() internal view returns (uint256 wethAvailable) {
+        WithdrawalQueueMetadata memory queue = withdrawalQueueMetadata;
+
+        // The amount of WETH that is still to be claimed in the withdrawal queue
+        uint256 outstandingWithdrawals = queue.queued - queue.claimed;
+
+        // The amount of sitting in WETH in the vault
+        uint256 wethBalance = IERC20(weth).balanceOf(address(this));
+
+        // If there is not enough WETH in the vault to cover the outstanding withdrawals
+        if (wethBalance <= outstandingWithdrawals) {
+            return 0;
+        }
+
+        return wethBalance - outstandingWithdrawals;
+    }
 
+    function _swapCollateral(
+        address,
+        address,
+        uint256,
+        uint256,
+        bytes calldata
+    ) internal pure override returns (uint256) {
+        revert("Collateral swap not supported");
+    }
 }