feat: withdrawal credentials

contracts/0.8.9/WithdrawalVault.sol

@@ -9,6 +9,7 @@ import "@openzeppelin/contracts-v4.4/token/ERC721/IERC721.sol";
 import "@openzeppelin/contracts-v4.4/token/ERC20/utils/SafeERC20.sol";
 
 import {Versioned} from "./utils/Versioned.sol";
+import {TriggerableWithdrawals} from "./lib/TriggerableWithdrawals.sol";
 
 interface ILido {
     /**
@@ -27,6 +28,7 @@ contract WithdrawalVault is Versioned {
 
     ILido public immutable LIDO;
     address public immutable TREASURY;
+    address public immutable VALIDATORS_EXIT_BUS;
 
     // Events
     /**
@@ -42,26 +44,24 @@ contract WithdrawalVault is Versioned {
     event ERC721Recovered(address indexed requestedBy, address indexed token, uint256 tokenId);
 
     // Errors
-    error LidoZeroAddress();
-    error TreasuryZeroAddress();
+    error ZeroAddress();
     error NotLido();
+    error NotValidatorExitBus();
     error NotEnoughEther(uint256 requested, uint256 balance);
     error ZeroAmount();
 
     /**
      * @param _lido the Lido token (stETH) address
      * @param _treasury the Lido treasury address (see ERC20/ERC721-recovery interfaces)
      */
-    constructor(ILido _lido, address _treasury) {
-        if (address(_lido) == address(0)) {
-            revert LidoZeroAddress();
-        }
-        if (_treasury == address(0)) {
-            revert TreasuryZeroAddress();
-        }
+    constructor(address _lido, address _treasury, address _validatorsExitBus) {
+        _requireNonZero(_lido);
+        _requireNonZero(_treasury);
+        _requireNonZero(_validatorsExitBus);
 
-        LIDO = _lido;
+        LIDO = ILido(_lido);
         TREASURY = _treasury;
+        VALIDATORS_EXIT_BUS = _validatorsExitBus;
     }
 
     /**
@@ -70,6 +70,12 @@ contract WithdrawalVault is Versioned {
      */
     function initialize() external {
         _initializeContractVersionTo(1);
+        _updateContractVersion(2);
+    }
+
+    function finalizeUpgrade_v2() external {
+        _checkContractVersion(1);
+        _updateContractVersion(2);
     }
 
     /**
@@ -122,4 +128,27 @@ contract WithdrawalVault is Versioned {
 
         _token.transferFrom(address(this), TREASURY, _tokenId);
     }
+
+    /**
+     * @dev Adds full withdrawal requests for the provided public keys.
+     *      The validator will fully withdraw and exit its duties as a validator.
+     * @param pubkeys An array of public keys for the validators requesting full withdrawals.
+     */
+    function addFullWithdrawalRequests(
+        bytes[] calldata pubkeys
+    ) external payable {
+        if(msg.sender != address(VALIDATORS_EXIT_BUS)) {
+            revert NotValidatorExitBus();
+        }
+
+        TriggerableWithdrawals.addFullWithdrawalRequests(pubkeys, msg.value);
+    }
+
+    function getWithdrawalRequestFee() external view returns (uint256) {
+        return TriggerableWithdrawals.getWithdrawalRequestFee();
+    }
+
+    function _requireNonZero(address _address) internal pure {
+        if (_address == address(0)) revert ZeroAddress();
+    }
 }

contracts/0.8.9/lib/TriggerableWithdrawals.sol

@@ -0,0 +1,148 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.9;
+
+library TriggerableWithdrawals {
+    address constant WITHDRAWAL_REQUEST = 0x0c15F14308530b7CDB8460094BbB9cC28b9AaaAA;
+
+    error MismatchedArrayLengths(uint256 keysCount, uint256 amountsCount);
+    error InsufficientBalance(uint256 balance, uint256 totalWithdrawalFee);
+    error FeeNotEnough(uint256 minFeePerRequest, uint256 requestCount, uint256 providedTotalFee);
+
+    error WithdrawalRequestFeeReadFailed();
+    error InvalidPubkeyLength(bytes pubkey);
+    error WithdrawalRequestAdditionFailed(bytes pubkey, uint256 amount);
+    error NoWithdrawalRequests();
+    error PartialWithdrawalRequired(bytes pubkey);
+
+    event WithdrawalRequestAdded(bytes pubkey, uint256 amount);
+
+    /**
+     * @dev Adds full withdrawal requests for the provided public keys.
+     *      The validator will fully withdraw and exit its duties as a validator.
+     * @param pubkeys An array of public keys for the validators requesting full withdrawals.
+     */
+    function addFullWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint256 totalWithdrawalFee
+    ) internal {
+        uint64[] memory amounts = new uint64[](pubkeys.length);
+        _addWithdrawalRequests(pubkeys, amounts, totalWithdrawalFee);
+    }
+
+    /**
+     * @dev Adds partial withdrawal requests for the provided public keys with corresponding amounts.
+     *      A partial withdrawal is any withdrawal where the amount is greater than zero.
+     *      A full withdrawal is any withdrawal where the amount is zero.
+     *      This allows withdrawal of any balance exceeding 32 ETH (e.g., if a validator has 35 ETH, up to 3 ETH can be withdrawn).
+     *      However, the protocol enforces a minimum balance of 32 ETH per validator, even if a higher amount is requested.
+     * @param pubkeys An array of public keys for the validators requesting withdrawals.
+     * @param amounts An array of corresponding withdrawal amounts for each public key.
+     */
+    function addPartialWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint64[] calldata amounts,
+        uint256 totalWithdrawalFee
+    ) internal {
+        _requireArrayLengthsMatch(pubkeys, amounts);
+
+        for (uint256 i = 0; i < amounts.length; i++) {
+            if (amounts[i] == 0) {
+                revert PartialWithdrawalRequired(pubkeys[i]);
+            }
+        }
+
+        _addWithdrawalRequests(pubkeys, amounts, totalWithdrawalFee);
+    }
+
+        /**
+     * @dev Adds partial or full withdrawal requests for the provided public keys with corresponding amounts.
+     *      A partial withdrawal is any withdrawal where the amount is greater than zero.
+     *      This allows withdrawal of any balance exceeding 32 ETH (e.g., if a validator has 35 ETH, up to 3 ETH can be withdrawn).
+     *      However, the protocol enforces a minimum balance of 32 ETH per validator, even if a higher amount is requested.
+     * @param pubkeys An array of public keys for the validators requesting withdrawals.
+     * @param amounts An array of corresponding withdrawal amounts for each public key.
+     */
+    function addWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint64[] calldata amounts,
+        uint256 totalWithdrawalFee
+    ) internal {
+        _requireArrayLengthsMatch(pubkeys, amounts);
+        _addWithdrawalRequests(pubkeys, amounts, totalWithdrawalFee);
+    }
+
+    /**
+     * @dev Retrieves the current withdrawal request fee.
+     * @return The minimum fee required per withdrawal request.
+     */
+    function getWithdrawalRequestFee() internal view returns (uint256) {
+        (bool success, bytes memory feeData) = WITHDRAWAL_REQUEST.staticcall("");
+
+        if (!success) {
+            revert WithdrawalRequestFeeReadFailed();
+        }
+
+        return abi.decode(feeData, (uint256));
+    }
+
+    function _addWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint64[] memory amounts,
+        uint256 totalWithdrawalFee
+    ) internal {
+        uint256 keysCount = pubkeys.length;
+        if (keysCount == 0) {
+            revert NoWithdrawalRequests();
+        }
+
+        if(address(this).balance < totalWithdrawalFee) {
+            revert InsufficientBalance(address(this).balance, totalWithdrawalFee);
+        }
+
+        uint256 minFeePerRequest = getWithdrawalRequestFee();
+        if (minFeePerRequest * keysCount > totalWithdrawalFee) {
+            revert FeeNotEnough(minFeePerRequest, keysCount, totalWithdrawalFee);
+        }
+
+        uint256 feePerRequest = totalWithdrawalFee / keysCount;
+        uint256 unallocatedFee = totalWithdrawalFee % keysCount;
+        uint256 prevBalance = address(this).balance - totalWithdrawalFee;
+
+        for (uint256 i = 0; i < keysCount; ++i) {
+            bytes memory pubkey = pubkeys[i];
+            uint64 amount = amounts[i];
+
+            if(pubkey.length != 48) {
+                revert InvalidPubkeyLength(pubkey);
+            }
+
+            uint256 feeToSend = feePerRequest;
+
+            if (i == keysCount - 1) {
+                feeToSend += unallocatedFee;
+            }
+
+            bytes memory callData = abi.encodePacked(pubkey, amount);
+            (bool success, ) = WITHDRAWAL_REQUEST.call{value: feeToSend}(callData);
+
+            if (!success) {
+                revert WithdrawalRequestAdditionFailed(pubkey, amount);
+            }
+
+            emit WithdrawalRequestAdded(pubkey, amount);
+        }
+
+        assert(address(this).balance == prevBalance);
+    }
+
+    function _requireArrayLengthsMatch(
+        bytes[] calldata pubkeys,
+        uint64[] calldata amounts
+    ) internal pure {
+        if (pubkeys.length != amounts.length) {
+            revert MismatchedArrayLengths(pubkeys.length, amounts.length);
+        }
+    }
+}

test/0.8.9/contracts/TriggerableWithdrawals_Harness.sol

@@ -0,0 +1,38 @@
+pragma solidity 0.8.9;
+
+import {TriggerableWithdrawals} from "contracts/0.8.9/lib/TriggerableWithdrawals.sol";
+
+contract TriggerableWithdrawals_Harness {
+    function addFullWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint256 totalWithdrawalFee
+    ) external {
+        TriggerableWithdrawals.addFullWithdrawalRequests(pubkeys, totalWithdrawalFee);
+    }
+
+    function addPartialWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint64[] calldata amounts,
+        uint256 totalWithdrawalFee
+    ) external {
+        TriggerableWithdrawals.addPartialWithdrawalRequests(pubkeys, amounts, totalWithdrawalFee);
+    }
+
+    function addWithdrawalRequests(
+        bytes[] calldata pubkeys,
+        uint64[] calldata amounts,
+        uint256 totalWithdrawalFee
+    ) external {
+        TriggerableWithdrawals.addWithdrawalRequests(pubkeys, amounts, totalWithdrawalFee);
+    }
+
+    function getWithdrawalRequestFee() external view returns (uint256) {
+        return TriggerableWithdrawals.getWithdrawalRequestFee();
+    }
+
+    function getWithdrawalsContractAddress() public pure returns (address) {
+        return TriggerableWithdrawals.WITHDRAWAL_REQUEST;
+    }
+
+    function deposit() external payable {}
+}

test/0.8.9/contracts/predeployed/WithdrawalsPredeployed_Mock.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.9;
+
+/**
+ * @notice This is an mock of EIP-7002's pre-deploy contract.
+ */
+contract WithdrawalsPredeployed_Mock {
+    uint256 public fee;
+    bool public failOnAddRequest;
+    bool public failOnGetFee;
+
+    event eip7002WithdrawalRequestAdded(bytes request, uint256 fee);
+
+    function setFailOnAddRequest(bool _failOnAddRequest) external {
+        failOnAddRequest = _failOnAddRequest;
+    }
+
+    function setFailOnGetFee(bool _failOnGetFee) external {
+        failOnGetFee = _failOnGetFee;
+    }
+
+    function setFee(uint256 _fee) external {
+        require(_fee > 0, "fee must be greater than 0");
+        fee = _fee;
+    }
+
+    fallback(bytes calldata input) external payable returns (bytes memory output){
+        if (input.length == 0) {
+            require(!failOnGetFee, "fail on get fee");
+
+            output = abi.encode(fee);
+            return output;
+        }
+
+        require(!failOnAddRequest, "fail on add request");
+
+        require(input.length == 56, "Invalid callData length");
+
+        emit eip7002WithdrawalRequestAdded(
+            input,
+            msg.value
+        );
+    }
+}

test/0.8.9/lib/triggerableWithdrawals/findEvents.ts

@@ -0,0 +1,23 @@
+import { ContractTransactionReceipt } from "ethers";
+import { ethers } from "hardhat";
+
+import { findEventsWithInterfaces } from "lib";
+
+const withdrawalRequestEventABI = ["event WithdrawalRequestAdded(bytes pubkey, uint256 amount)"];
+const withdrawalRequestEventInterface = new ethers.Interface(withdrawalRequestEventABI);
+type WithdrawalRequestEvents = "WithdrawalRequestAdded";
+
+export function findEvents(receipt: ContractTransactionReceipt, event: WithdrawalRequestEvents) {
+  return findEventsWithInterfaces(receipt!, event, [withdrawalRequestEventInterface]);
+}
+
+const eip7002TriggerableWithdrawalMockEventABI = ["event eip7002WithdrawalRequestAdded(bytes request, uint256 fee)"];
+const eip7002TriggerableWithdrawalMockInterface = new ethers.Interface(eip7002TriggerableWithdrawalMockEventABI);
+type Eip7002WithdrawalEvents = "eip7002WithdrawalRequestAdded";
+
+export function findEip7002TriggerableWithdrawalMockEvents(
+  receipt: ContractTransactionReceipt,
+  event: Eip7002WithdrawalEvents,
+) {
+  return findEventsWithInterfaces(receipt!, event, [eip7002TriggerableWithdrawalMockInterface]);
+}