Add function to withdraw credit as rETH from withdrawal address

Author: kanewallmann

contracts/contract/deposit/RocketDepositPool.sol

@@ -44,7 +44,7 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
     event FundsRequested(address indexed receiver, uint256 validatorId, uint256 amount, bool expressQueue, uint256 time);
     event FundsAssigned(address indexed receiver, uint256 amount, uint256 time);
     event QueueExited(address indexed nodeAddress, uint256 time);
-    event CreditWithdrawn(address indexed receiver, uint256 amount, uint256 time);
+    event CreditWithdrawn(address indexed nodeAddress, uint256 amount, uint256 time);
 
     // Structs
     struct MinipoolAssignment {
@@ -563,27 +563,43 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
     /// @notice Allows node operator to withdraw any ETH credit they have as rETH
     /// @param _amount Amount in ETH to withdraw
     function withdrawCredit(uint256 _amount) override external onlyRegisteredNode(msg.sender) onlyThisLatestContract {
+        address withdrawalAddress = rocketStorage.getNodeWithdrawalAddress(msg.sender);
+        _withdrawCreditFor(msg.sender, withdrawalAddress, _amount);
+    }
+
+    /// @notice Allows node operator to withdraw any ETH credit they have as rETH from their withdrawal address
+    /// @param _nodeAddress Address of the node operator
+    /// @param _amount Amount in ETH to withdraw
+    function withdrawCreditFor(address _nodeAddress, uint256 _amount) override public onlyRegisteredNode(_nodeAddress) onlyThisLatestContract {
+        // Check caller
+        address withdrawalAddress = rocketStorage.getNodeWithdrawalAddress(_nodeAddress);
+        require(msg.sender == withdrawalAddress, "Must be called from withdrawal address");
+        // Withdraw credit
+        _withdrawCreditFor(_nodeAddress, withdrawalAddress, _amount);
+    }
+
+    /// @dev Withdraws credit from a given node operator as rETH
+    function _withdrawCreditFor(address _nodeAddress, address _recipient, uint256 _amount) internal {
         // Check deposits are enabled
         RocketDAOProtocolSettingsDepositInterface rocketDAOProtocolSettingsDeposit = RocketDAOProtocolSettingsDepositInterface(getContractAddress("rocketDAOProtocolSettingsDeposit"));
         require(rocketDAOProtocolSettingsDeposit.getDepositEnabled(), "Deposits into Rocket Pool are currently disabled");
         // Check node operator has sufficient credit
-        uint256 credit = getUint(keccak256(abi.encodePacked("node.deposit.credit.balance", msg.sender)));
+        uint256 credit = getUint(keccak256(abi.encodePacked("node.deposit.credit.balance", _nodeAddress)));
         require(credit >= _amount, "Amount exceeds credit available");
         // Account for balance changes
-        subUint(keccak256(abi.encodePacked("node.deposit.credit.balance", msg.sender)), _amount);
+        subUint(keccak256(abi.encodePacked("node.deposit.credit.balance", _nodeAddress)), _amount);
         // Note: The funds are already stored in RocketVault under RocketDepositPool so no ETH transfer is required
         // Get the node operator's withdrawal address
         RocketNodeManagerInterface rocketNodeManager = RocketNodeManagerInterface(getContractAddress("rocketNodeManager"));
-        address nodeWithdrawalAddress = rocketNodeManager.getNodeWithdrawalAddress(msg.sender);
         // Calculate deposit fee
         unchecked { // depositFee < msg.value
             uint256 depositFee = _amount * rocketDAOProtocolSettingsDeposit.getDepositFee() / calcBase;
             uint256 depositNet = _amount - depositFee;
-            // Mint rETH to node
-            rocketTokenRETH.mint(depositNet, nodeWithdrawalAddress);
+            // Mint rETH to recipient address
+            rocketTokenRETH.mint(depositNet, _recipient);
         }
         // Emit event
-        emit CreditWithdrawn(msg.sender, _amount, block.timestamp);
+        emit CreditWithdrawn(_nodeAddress, _amount, block.timestamp);
     }
 
     /// @notice Gets the receiver next to be assigned and whether it can be assigned immediately

contracts/interface/deposit/RocketDepositPoolInterface.sol

@@ -23,6 +23,7 @@ interface RocketDepositPoolInterface {
     function reduceBond(address _nodeAddress, uint256 _amount) external;
     function fundsReturned(address _nodeAddress, uint256 _nodeAmount, uint256 _userAmount) external;
     function withdrawCredit(uint256 _amount) external;
+    function withdrawCreditFor(address _nodeAddress, uint256 _amount) external;
     function getQueueTop() external view returns (address receiver, bool assignmentPossible, uint256 headMovedBlock);
     function getQueueIndex() external view returns (uint256);
     function getMinipoolQueueLength() external view returns (uint256);

test/megapool/megapool-tests.js

@@ -860,6 +860,18 @@ export default function() {
                 await withdrawCredit(node, '2'.ether);
             });
 
+            it(printTitle('node', 'can reduce bond to new requirement and use credit to mint rETH from their withdrawal address'), async () => {
+                await reduceBond(megapool, '2'.ether);
+                // Fail to withdraw credit from random address
+                await shouldRevert(
+                    withdrawCredit(node, '2'.ether, random),
+                    'Was able to withdraw credit from random address',
+                    'Must be called from withdrawal address'
+                );
+                // Withdraw credit from withdrawal address
+                await withdrawCredit(node, '2'.ether, nodeWithdrawalAddress);
+            });
+
             it(printTitle('node', 'can reduce bond to new requirement and use some credit for another validator and some for rETH'), async () => {
                 await reduceBond(megapool, '2'.ether);
                 await withdrawCredit(node, '1'.ether);

test/megapool/scenario-withdraw-credit.js

@@ -6,7 +6,7 @@ import {
 } from '../_utils/artifacts';
 import { assertBN } from '../_helpers/bn';
 
-export async function withdrawCredit(node, amount) {
+export async function withdrawCredit(node, amount, from = node) {
     const rocketDepositPool = await RocketDepositPool.deployed();
     const rocketStorage = await RocketStorage.deployed();
     const rocketTokenRETH = await RocketTokenRETH.deployed();
@@ -37,7 +37,11 @@ export async function withdrawCredit(node, amount) {
 
     const dataBefore = await getData();
 
-    await rocketDepositPool.connect(node).withdrawCredit(amount);
+    if (from === node) {
+        await rocketDepositPool.connect(from).withdrawCredit(amount);
+    } else {
+        await rocketDepositPool.connect(from).withdrawCreditFor(node.address, amount);
+    }
 
     const dataAfter = await getData();