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";
 
@@ -458,6 +459,47 @@ contract Lido is ILido, StETH, AragonApp {
         emit ELRewardsWithdrawalLimitSet(_limitPoints);
     }
 
+    /**
+    * @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 ticketId) {
+        address withdrawal = address(uint160(getWithdrawalCredentials()));
+        // lock StETH to withdrawal contract
+        _transfer(msg.sender, withdrawal, _amountOfStETH);
+
+        uint shares = getSharesByPooledEth(_amountOfStETH);
+        ticketId = IWithdrawalQueue(withdrawal).createTicket(msg.sender, _amountOfStETH, shares);
+
+        emit WithdrawalRequested(msg.sender, _amountOfStETH, shares, ticketId);
+    }
+
+    /**
+     * @notice Burns a ticket and transfer ETH to ticket owner address
+     * @param _ticketId id of the ticket to burn
+     * Permissionless.
+     */
+    function claimWithdrawal(uint256 _ticketId) external {
+        /// Just forward it to withdrawals
+        address withdrawal = address(uint160(getWithdrawalCredentials()));
+        address recipient = IWithdrawalQueue(withdrawal).withdraw(_ticketId);
+
+        emit WithdrawalClaimed(_ticketId, recipient, msg.sender);
+    }
+
+    function withdrawalRequestStatus(uint _ticketId) external view returns (
+        bool finalized,
+        uint256 ethToWithdraw,
+        address recipient
+    ) {
+        IWithdrawalQueue withdrawal = IWithdrawalQueue(address(uint160(getWithdrawalCredentials())));
+
+        (recipient, ethToWithdraw,) = withdrawal.queue(_ticketId);
+        finalized = _ticketId < withdrawal.finalizedQueueLength();
+    }
+
     /**
     * @notice Updates beacon stats, collects rewards from LidoExecutionLayerRewardsVault and distributes all rewards if beacon balance increased
     * @dev periodically called by the Oracle contract

contracts/0.4.24/interfaces/ILido.sol

@@ -230,17 +230,25 @@ interface ILido {
       */
     function submit(address _referral) external payable returns (uint256 StETH);
 
+    function requestWithdrawal(uint256 _amountOfStETH) external returns (uint256 ticketId);
+
+    function claimWithdrawal(uint256 _ticketId) external;
+
+    function withdrawalRequestStatus(uint _ticketId) external view returns (
+        bool finalized,
+        uint256 ethToWithdraw,
+        address recipient
+    );
+
     // Records a deposit made by a user
     event Submitted(address indexed sender, uint256 amount, address referral);
 
     // 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);
+    event WithdrawalRequested(address indexed receiver, uint256 amountOfStETH, uint256 amountOfShares, uint256 ticketId);
 
+    event WithdrawalClaimed(uint256 indexed ticketId, address indexed receiver, address initiator);
 
     // Info functions
 

contracts/0.4.24/interfaces/IWithdrawalQueue.sol

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: 2021 Lido <[email protected]>
+
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.4.24;
+
+
+interface IWithdrawalQueue {
+  function createTicket(address _from, uint256 _maxETHToWithdraw, uint256 _sharesToBurn) external returns (uint256);
+  function withdraw(uint256 _ticketId) external returns (address);
+  function queue(uint256 _ticketId) external view returns (address, uint, uint);
+  function finalizedQueueLength() external view returns (uint);
+}

contracts/0.8.9/WithdrawalQueue.sol

@@ -0,0 +1,137 @@
+// SPDX-FileCopyrightText: 2022 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.9;
+
+/**
+  * @title A dedicated contract for handling stETH withdrawal request queue
+  * @notice it responsible for:
+  * - taking withdrawal requests, issuing a ticket in return
+  * - finalizing tickets in queue (making tickets withdrawable)
+  * - processing claims for finalized tickets
+  * @author folkyatina
+  */
+contract WithdrawalQueue {
+    /**
+     * We don't want to deal with small amounts because there is a gas spent on oracle 
+     * for each request. 
+     * But exact threshhold should be defined later when it will be clear how much will 
+     * it cost to withdraw.
+     */
+    uint256 public constant MIN_WITHDRAWAL = 0.1 ether;
+
+    /**
+     * @notice All state-modifying calls are allowed only from owner protocol. 
+     * @dev should be Lido
+     */ 
+    address public immutable OWNER;
+
+    /**
+     * @notice amount of ETH on this contract balance that is locked for withdrawal and waiting for cashout
+     * @dev Invariant: `lockedETHAmount <= this.balance`
+     */
+    uint256 public lockedETHAmount = 0;
+
+    /**
+     * @notice queue for withdrawas, implemented as mapping of incremental index to respective Ticket
+     * @dev We want to delete items on after cashout to save some gas, so we don't use array here.
+     */ 
+    mapping(uint => Ticket) public queue;
+
+    uint256 public queueLength = 0;
+    uint256 public finalizedQueueLength = 0;
+
+    struct Ticket {
+        address holder;
+        uint256 maxETHToClaim;
+        uint256 sharesToBurn;
+    }
+
+    constructor(address _owner) {
+        OWNER = _owner;
+    }
+
+    /**
+     * @notice reserve a place in queue for withdrawal and assign a Ticket to `_from` address
+     * @dev Assuming that _stethAmount is locked before invoking this function 
+     * @return ticketId id of a ticket to withdraw funds once it is available
+     */
+    function createTicket(address _from, uint256 _ETHToClaim, uint256 _shares) external onlyOwner returns (uint256) {
+        // issue a ticket
+        uint256 ticketId = queueLength++;
+        queue[ticketId] = Ticket(_from, _ETHToClaim, _shares);
+
+        return ticketId;
+    }
+
+    /**
+     * @notice Mark next tickets finalized up to `lastTicketIdToFinalize` index in the queue.
+     * @dev expected that `lastTicketIdToFinalize` is chosen by criteria:
+     *  - it is the last ticket that come before the oracle report block
+     *  - we have enough money to fullfill it
+     */
+    function finalizeTickets(
+        uint256 lastTicketIdToFinalize, 
+        uint256 totalPooledEther,
+        uint256 totalShares
+    ) external payable onlyOwner returns (uint sharesToBurn) {
+        uint ethToLock = 0;
+        for (uint i = finalizedQueueLength; i <= lastTicketIdToFinalize; i++) {
+            uint ticketShares = queue[i].sharesToBurn;
+            uint ticketETH = queue[i].maxETHToClaim;
+
+             // discount for slashing
+            uint256 currentEth = totalPooledEther * ticketShares / totalShares;
+            if (currentEth < ticketETH) {
+                queue[i].maxETHToClaim = currentEth;
+                ticketETH = currentEth;
+            }
+
+            sharesToBurn += ticketShares;
+            ethToLock += ticketETH;
+        }
+
+        // check that tickets are came before report and move lastNonFinalizedTicketId 
+        // to last ticket that came before report and we have enough ETH for
+        require(lockedETHAmount + ethToLock <= address(this).balance, "NOT_ENOUGH_ETHER");
+
+        lockedETHAmount += ethToLock;
+        finalizedQueueLength = lastTicketIdToFinalize + 1; 
+    }
+
+    /**
+     * @notice Burns a `_ticketId` ticket and transfer reserver ether to `_to` address. 
+     */
+    function withdraw(uint256 _ticketId) external returns (address recipient) {
+        // ticket must be finalized
+        require(finalizedQueueLength > _ticketId, "TICKET_NOT_FINALIZED");
+
+        // transfer designated amount to ticket owner
+        recipient = holderOf(_ticketId);
+        uint256 ethAmount = queue[_ticketId].maxETHToClaim;
+
+        // find a discount if applicable
+
+        lockedETHAmount -= ethAmount;
+
+        payable(recipient).transfer(ethAmount);
+
+        // free storage to save some gas
+        delete queue[_ticketId];
+    }
+
+    function holderOf(uint256 _ticketId) public view returns (address) {
+        address holder = queue[_ticketId].holder;
+        require(holder != address(0), "TICKET_NOT_FOUND");
+        return holder;
+    }
+
+    function _exists(uint256 _ticketId) internal view returns (bool) {
+        return queue[_ticketId].holder != address(0);
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == OWNER, "NOT_OWNER");
+        _;
+    }
+}

lib/abi/WithdrawalQueue.json

@@ -0,0 +1 @@
+[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"MIN_WITHDRAWAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OWNER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_ETHToClaim","type":"uint256"},{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"createTicket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lastTicketIdToFinalize","type":"uint256"},{"internalType":"uint256","name":"totalPooledEther","type":"uint256"},{"internalType":"uint256","name":"totalShares","type":"uint256"}],"name":"finalizeTickets","outputs":[{"internalType":"uint256","name":"sharesToBurn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"finalizedQueueLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ticketId","type":"uint256"}],"name":"holderOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedETHAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"queue","outputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"maxETHToClaim","type":"uint256"},{"internalType":"uint256","name":"sharesToBurn","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"queueLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ticketId","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"address","name":"recipient","type":"address"}],"stateMutability":"nonpayable","type":"function"}]

test/0.8.9/withdrawal-queue.test.js

@@ -0,0 +1,130 @@
+const { artifacts, contract } = require('hardhat')
+const { bn } = require('@aragon/contract-helpers-test')
+const { assertBn, assertRevert } = require('@aragon/contract-helpers-test/src/asserts')
+const { assert } = require('chai')
+
+const WithdrawalQueue = artifacts.require('WithdrawalQueue.sol')
+
+contract('WithdrawalQueue', ([deployer, owner, holder, stranger]) => {
+  console.log('Addresses:')
+  console.log(`Deployer: ${deployer}`)
+  console.log(`Owner: ${owner}`)
+
+  let withdrawal
+
+  beforeEach('Deploy', async () => {
+    withdrawal = await WithdrawalQueue.new(owner)
+  })
+
+  context('Create a ticket', async () => {
+    let ticketId
+
+    beforeEach('Read some state', async () => {
+      ticketId = await withdrawal.queueLength()
+    })
+
+    it('Owner can create a ticket', async () => {
+      await withdrawal.createTicket(holder, 1, 1, { from: owner })
+
+      assertBn(await withdrawal.holderOf(ticketId), holder)
+      assertBn(await withdrawal.queueLength(), +ticketId + 1)
+      assert(ticketId >= (await withdrawal.finalizedQueueLength()))
+      const ticket = await withdrawal.queue(ticketId)
+      assert.equal(ticket[0], holder)
+      assertBn(ticket[1], bn(1))
+      assertBn(ticket[2], bn(1))
+    })
+
+    it('Only owner can create a ticket', async () => {
+      await assertRevert(withdrawal.createTicket(holder, 1, 1, { from: stranger }), 'NOT_OWNER')
+      await assertRevert(withdrawal.holderOf(ticketId), 'TICKET_NOT_FOUND')
+
+      assertBn(await withdrawal.queueLength(), ticketId)
+    })
+  })
+
+  context('Finalization', async () => {
+    let ticketId
+    let amountOfStETH
+    const amountOfShares = 1
+    beforeEach('Create a ticket', async () => {
+      amountOfStETH = 100
+      ticketId = await withdrawal.queueLength()
+      await withdrawal.createTicket(holder, amountOfStETH, amountOfShares, { from: owner })
+    })
+
+    it('Only owner can finalize a ticket', async () => {
+      await withdrawal.finalizeTickets(0, amountOfStETH, amountOfShares, { from: owner, value: amountOfStETH })
+      await assertRevert(
+        withdrawal.finalizeTickets(0, amountOfStETH, amountOfShares, { from: stranger, value: amountOfStETH }),
+        'NOT_OWNER'
+      )
+
+      assertBn(await withdrawal.lockedETHAmount(), bn(amountOfStETH))
+    })
+
+    it('One cannot finalize tickets with no ether', async () => {
+      await assertRevert(
+        withdrawal.finalizeTickets(0, amountOfStETH, amountOfShares, { from: owner, value: amountOfStETH - 1 }),
+        'NOT_ENOUGH_ETHER'
+      )
+
+      assertBn(await withdrawal.lockedETHAmount(), bn(0))
+    })
+
+    it('One can finalize tickets with discount', async () => {
+      shares = 2
+
+      await withdrawal.finalizeTickets(0, amountOfStETH, shares, { from: owner, value: amountOfStETH / shares })
+
+      assertBn(await withdrawal.lockedETHAmount(), bn(amountOfStETH / shares))
+    })
+
+    it('One can finalize part of the queue', async () => {
+      await withdrawal.createTicket(holder, amountOfStETH, amountOfShares, { from: owner })
+
+      await withdrawal.finalizeTickets(0, amountOfStETH, amountOfShares, { from: owner, value: amountOfStETH })
+
+      assertBn(await withdrawal.queueLength(), +ticketId + 2)
+      assertBn(await withdrawal.finalizedQueueLength(), +ticketId + 1)
+      assertBn(await withdrawal.lockedETHAmount(), bn(amountOfStETH))
+    })
+  })
+
+  context('Withdraw', async () => {
+    let ticketId
+    beforeEach('Create a ticket', async () => {
+      ticketId = await withdrawal.queueLength()
+      await withdrawal.createTicket(holder, 100, 1, { from: owner })
+    })
+
+    it('One cant withdraw not finalized ticket', async () => {
+      await assertRevert(withdrawal.withdraw(ticketId, { from: owner }), 'TICKET_NOT_FINALIZED')
+    })
+
+    it('Anyone can withdraw a finalized token', async () => {
+      const balanceBefore = bn(await web3.eth.getBalance(holder))
+      await withdrawal.finalizeTickets(0, 100, 1, { from: owner, value: 100 })
+
+      await withdrawal.withdraw(ticketId, { from: stranger })
+
+      assertBn(await web3.eth.getBalance(holder), balanceBefore.add(bn(100)))
+    })
+
+    it('Cant withdraw token two times', async () => {
+      await withdrawal.finalizeTickets(0, 100, 1, { from: owner, value: 100 })
+      await withdrawal.withdraw(ticketId)
+
+      await assertRevert(withdrawal.withdraw(ticketId, { from: stranger }), 'TICKET_NOT_FOUND')
+    })
+
+    it('Discounted withdrawals produce less eth', async () => {
+      const balanceBefore = bn(await web3.eth.getBalance(holder))
+      await withdrawal.finalizeTickets(0, 50, 1, { from: owner, value: 50 })
+
+      await withdrawal.withdraw(ticketId, { from: stranger })
+
+      assertBn(await web3.eth.getBalance(holder), balanceBefore.add(bn(50)))
+    })
+  })
+})