Feature/withdrawals PoC

.editorconfig

@@ -0,0 +1,12 @@
+# top-most EditorConfig file
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 4
+
+[*.js]
+indent_size = 2

contracts/0.4.24/Lido.sol

@@ -14,6 +14,7 @@ import "./interfaces/ILido.sol";
 import "./interfaces/INodeOperatorsRegistry.sol";
 import "./interfaces/IDepositContract.sol";
 import "./interfaces/ILidoExecutionLayerRewardsVault.sol";
+import "./interfaces/IWithdrawalQueue.sol";
 
 import "./StETH.sol";
 
@@ -103,6 +104,11 @@ contract Lido is ILido, StETH, AragonApp {
     bytes32 internal constant BEACON_BALANCE_POSITION = keccak256("lido.Lido.beaconBalance");
     /// @dev number of Lido's validators available in the Beacon state
     bytes32 internal constant BEACON_VALIDATORS_POSITION = keccak256("lido.Lido.beaconValidators");
+    /// @dev number of Lido's validators exited, according to the Beacon state
+    bytes32 internal constant BEACON_EXITED_VALIDATORS_POSITION = keccak256("lido.Lido.exitedValidators");
+
+    /// @dev amount of ether buffered for withdrawals, but not finalized yet
+    bytes32 internal constant WC_BUFFERED_ETHER_POSITION = keccak256("lido.Lido.wcBufferedEther");
 
     /// @dev percent in basis points of total pooled ether allowed to withdraw from LidoExecutionLayerRewardsVault per LidoOracle report
     bytes32 internal constant EL_REWARDS_WITHDRAWAL_LIMIT_POSITION = keccak256("lido.Lido.ELRewardsWithdrawalLimit");
@@ -459,12 +465,61 @@ contract Lido is ILido, StETH, AragonApp {
     }
 
     /**
-    * @notice Updates beacon stats, collects rewards from LidoExecutionLayerRewardsVault and distributes all rewards if beacon balance increased
+    * @notice this method is responsible for locking StETH and placing user 
+    * in the queue  
+    * @param _amountOfStETH StETH to be locked. `msg.sender` should have the `_amountOfStETH` StETH balance upon this call
+    * @return ticketId id string that can be used by user to claim their ETH later
+    */
+    function requestWithdrawal(uint256 _amountOfStETH) external returns (uint256 requestId) {
+        address withdrawal = address(uint160(getWithdrawalCredentials()));
+        // lock StETH to withdrawal contract
+        _transfer(msg.sender, withdrawal, _amountOfStETH);
+
+        uint shares = getSharesByPooledEth(_amountOfStETH);
+        requestId = IWithdrawalQueue(withdrawal).enqueue(msg.sender, _amountOfStETH, shares);
+
+        emit WithdrawalRequested(msg.sender, _amountOfStETH, shares, requestId);
+    }
+
+    /**
+     * @notice Burns a ticket and transfer ETH to ticket owner address
+     * @param _requestId id of the ticket to burn
+     * Permissionless.
+     */
+    function claimWithdrawal(uint256 _requestId, uint256 _priceIndexHint) external {
+        /// Just forward it to withdrawals
+        address withdrawal = address(uint160(getWithdrawalCredentials()));
+        address recipient = IWithdrawalQueue(withdrawal).claim(_requestId, _priceIndexHint);
+
+        emit WithdrawalClaimed(_requestId, recipient, msg.sender);
+    }
+
+    // TODO:
+    function withdrawalRequestStatus(uint _requestId) external view returns (
+        bool finalized,
+        uint256 etherToWithdraw,
+        address recipient
+    ) {
+        IWithdrawalQueue withdrawal = IWithdrawalQueue(address(uint160(getWithdrawalCredentials())));
+
+        (recipient, etherToWithdraw,) = withdrawal.queue(_requestId);
+        finalized = _requestId < withdrawal.finalizedQueueLength();
+    }
+
+    /**
+    * @notice Updates CL stats, collects rewards from LidoExecutionLayerRewardsVault and distributes all rewards if beacon balance increased
     * @dev periodically called by the Oracle contract
-    * @param _beaconValidators number of Lido's keys in the beacon state
-    * @param _beaconBalance summarized balance of Lido-controlled keys in wei
     */
-    function handleOracleReport(uint256 _beaconValidators, uint256 _beaconBalance) external whenNotStopped {
+    function handleOracleReport(
+        // CL values
+        uint256 _beaconValidators,
+        uint256 _beaconBalance,
+        uint256 _exitedValidators,
+        // EL values
+        uint256 _wcBufferedEther,
+        // decision
+        uint256 _newFinalizedLength
+    ) external whenNotStopped {
         require(msg.sender == getOracle(), "APP_AUTH_FAILED");
 
         uint256 depositedValidators = DEPOSITED_VALIDATORS_POSITION.getStorageUint256();
@@ -476,6 +531,10 @@ contract Lido is ILido, StETH, AragonApp {
         // reported number (we'll be unable to figure out who is in the queue and count them).
         // See LIP-1 for details https://github.com/lidofinance/lido-improvement-proposals/blob/develop/LIPS/lip-1.md
         require(_beaconValidators >= beaconValidators, "REPORTED_LESS_VALIDATORS");
+
+        uint256 exitedValidators = BEACON_EXITED_VALIDATORS_POSITION.getStorageUint256();
+        require(_exitedValidators >= exitedValidators, "REPORTED_LESS_EXITED_VALIDATORS");
+
         uint256 appearedValidators = _beaconValidators.sub(beaconValidators);
 
         // RewardBase is the amount of money that is not included in the reward calculation
@@ -486,6 +545,8 @@ contract Lido is ILido, StETH, AragonApp {
         // calculate rewards on the next push
         BEACON_BALANCE_POSITION.setStorageUint256(_beaconBalance);
         BEACON_VALIDATORS_POSITION.setStorageUint256(_beaconValidators);
+        BEACON_EXITED_VALIDATORS_POSITION.setStorageUint256(_exitedValidators);
+        WC_BUFFERED_ETHER_POSITION.setStorageUint256(_wcBufferedEther);
 
         // If LidoExecutionLayerRewardsVault address is not set just do as if there were no execution layer rewards at all
         // Otherwise withdraw all rewards and put them to the buffer
@@ -504,6 +565,10 @@ contract Lido is ILido, StETH, AragonApp {
             }
         }
 
+        uint256 toRestake = _wcBufferedEther - _processWithdrawals(_newFinalizedLength, _wcBufferedEther);
+
+        // withdrawal.restake(toRestake);
+
         // Don’t mint/distribute any protocol fee on the non-profitable Lido oracle report
         // (when beacon chain balance delta is zero or negative).
         // See ADR #3 for details: https://research.lido.fi/t/rewards-distribution-after-the-merge-architecture-decision-record/1535
@@ -651,6 +716,40 @@ contract Lido is ILido, StETH, AragonApp {
         return EL_REWARDS_VAULT_POSITION.getStorageAddress();
     }
 
+    function _processWithdrawals(
+        uint256 _newFinalizedLength, 
+        uint256 _wcBufferedEther
+    ) internal returns (uint256 lockedEther) {
+        address withdrawalAddress = address(uint160(getWithdrawalCredentials()));
+        IWithdrawalQueue withdrawal = IWithdrawalQueue(withdrawalAddress);
+
+        lockedEther = 0;
+
+        if (withdrawalAddress != address(0) && _newFinalizedLength > withdrawal.finalizedQueueLength()) {
+            uint256 totalPooledEther = getTotalPooledEther();
+            uint256 totalShares = getTotalShares();
+
+            (uint256 etherToLock, uint256 sharesToBurn) = withdrawal.calculateFinalizationParams(
+                _newFinalizedLength - 1,
+                totalPooledEther,
+                totalShares 
+            );
+
+            _burnShares(withdrawalAddress, sharesToBurn);
+
+            uint256 additionalFunds = etherToLock > _wcBufferedEther ? etherToLock.sub(_wcBufferedEther) : 0;
+
+            withdrawal.finalize.value(additionalFunds)(
+                _newFinalizedLength - 1,
+                etherToLock, 
+                totalPooledEther,
+                totalShares
+            );
+
+            lockedEther = etherToLock;
+        }
+    }
+
     /**
     * @dev Internal function to set authorized oracle address
     * @param _oracle oracle contract
@@ -922,19 +1021,21 @@ contract Lido is ILido, StETH, AragonApp {
     function _getTransientBalance() internal view returns (uint256) {
         uint256 depositedValidators = DEPOSITED_VALIDATORS_POSITION.getStorageUint256();
         uint256 beaconValidators = BEACON_VALIDATORS_POSITION.getStorageUint256();
+        uint256 exitedValidators = BEACON_EXITED_VALIDATORS_POSITION.getStorageUint256();
         // beaconValidators can never be less than deposited ones.
-        assert(depositedValidators >= beaconValidators);
-        return depositedValidators.sub(beaconValidators).mul(DEPOSIT_SIZE);
+        assert(depositedValidators.sub(exitedValidators) >= beaconValidators);
+        return depositedValidators.sub(exitedValidators).sub(beaconValidators).mul(DEPOSIT_SIZE);
     }
 
     /**
     * @dev Gets the total amount of Ether controlled by the system
     * @return total balance in wei
     */
     function _getTotalPooledEther() internal view returns (uint256) {
-        return _getBufferedEther().add(
-            BEACON_BALANCE_POSITION.getStorageUint256()
-        ).add(_getTransientBalance());
+        return _getBufferedEther()
+        .add(_getTransientBalance())
+        .add(BEACON_BALANCE_POSITION.getStorageUint256())
+        .add(WC_BUFFERED_ETHER_POSITION.getStorageUint256());
     }
 
     /**

contracts/0.4.24/interfaces/ILido.sol

@@ -216,10 +216,14 @@ interface ILido {
 
     /**
       * @notice Ether on the ETH 2.0 side reported by the oracle
-      * @param _epoch Epoch id
-      * @param _eth2balance Balance in wei on the ETH 2.0 side
       */
-    function handleOracleReport(uint256 _epoch, uint256 _eth2balance) external;
+    function handleOracleReport(
+        uint256 _beaconValidators, 
+        uint256 _beaconBalance, 
+        uint256 _exitedValidators, 
+        uint256 _wcBufferedEther,
+        uint256 _newFinalizedLength
+    ) external;
 
 
     // User functions
@@ -236,11 +240,20 @@ interface ILido {
     // The `amount` of ether was sent to the deposit_contract.deposit function
     event Unbuffered(uint256 amount);
 
-    // Requested withdrawal of `etherAmount` to `pubkeyHash` on the ETH 2.0 side, `tokenAmount` burned by `sender`,
-    // `sentFromBuffer` was sent on the current Ethereum side.
-    event Withdrawal(address indexed sender, uint256 tokenAmount, uint256 sentFromBuffer,
-                     bytes32 indexed pubkeyHash, uint256 etherAmount);
+    // Withdrawal functions
+    function requestWithdrawal(uint256 _amountOfStETH) external returns (uint256 requestId);
+
+    function claimWithdrawal(uint256 _requestId, uint256 _priceIndexHint) external;
+
+    function withdrawalRequestStatus(uint _requestId) external view returns (
+        bool finalized,
+        uint256 ethToWithdraw,
+        address recipient
+    );
+
+    event WithdrawalRequested(address indexed receiver, uint256 amountOfStETH, uint256 amountOfShares, uint256 requestId);
 
+    event WithdrawalClaimed(uint256 indexed requestId, address indexed receiver, address initiator);
 
     // Info functions
 

contracts/0.4.24/interfaces/IWithdrawalQueue.sol

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2021 Lido <[email protected]>
+
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.4.24;
+
+/**
+ * @notice an interface for witdrawal queue. See `WithdrawalQueue.sol` for docs
+ */
+interface IWithdrawalQueue {
+    function enqueue(
+        address _recipient, 
+        uint256 _etherAmount, 
+        uint256 _sharesAmount
+    ) external returns (uint256 requestId);
+
+    function claim(uint256 _requestId, uint256 _priceIndexHint) external returns (address recipient);
+
+    function calculateFinalizationParams(
+        uint256 _lastIdToFinalize,
+        uint256 _totalPooledEther,
+        uint256 _totalShares
+    ) view returns (uint256 sharesToBurn, uint256 etherToLock);
+
+    function finalize(
+        uint256 _lastIdToFinalize,
+        uint256 _etherToLock, 
+        uint256 _totalPooledEther,
+        uint256 _totalShares
+    ) external payable;
+
+    function queue(uint256 _requestId) external view returns (address, uint256, uint256);
+    function finalizedQueueLength() external view returns (uint256);
+}

contracts/0.4.24/oracle/LidoOracle.sol

@@ -635,7 +635,7 @@ contract LidoOracle is ILidoOracle, AragonApp {
         // report to the Lido and collect stats
         ILido lido = getLido();
         uint256 prevTotalPooledEther = lido.totalSupply();
-        lido.handleOracleReport(_beaconValidators, _beaconBalanceEth1);
+        lido.handleOracleReport(_beaconValidators, _beaconBalanceEth1, 0, 0, 0); // here should be withdrawal params
         uint256 postTotalPooledEther = lido.totalSupply();
 
         PRE_COMPLETED_TOTAL_POOLED_ETHER_POSITION.setStorageUint256(prevTotalPooledEther);

contracts/0.4.24/test_helpers/LidoMockForOracle.sol

@@ -15,7 +15,7 @@ contract LidoMockForOracle {
         return totalPooledEther;
     }
 
-    function handleOracleReport(uint256 /*_beaconValidators*/, uint256 _beaconBalance) external {
+    function handleOracleReport(uint256, uint256 _beaconBalance, uint256, uint256, uint256) external {
         totalPooledEther = _beaconBalance;
     }
 

contracts/0.4.24/test_helpers/OracleMock.sol

@@ -19,7 +19,7 @@ contract OracleMock {
     }
 
     function reportBeacon(uint256 _epochId, uint128 _beaconValidators, uint128 _beaconBalance) external {
-        pool.handleOracleReport(_beaconValidators, _beaconBalance);
+        pool.handleOracleReport(_beaconValidators, _beaconBalance, 0, 0, 0);
     }
 
     function setBeaconReportReceiver(address _receiver) {