Account for change in minipool staking counts during bond reduction

Author: kanewallmann

contracts/contract/minipool/RocketMinipoolBondReducer.sol

@@ -12,6 +12,7 @@ import "../../interface/dao/node/settings/RocketDAONodeTrustedSettingsMinipoolIn
 import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
 import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsRewardsInterface.sol";
 import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
+import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
 
 /// @notice Handles bond reduction window and trusted node cancellation
 contract RocketMinipoolBondReducer is RocketBase, RocketMinipoolBondReducerInterface {

contracts/contract/minipool/RocketMinipoolDelegate.sol

@@ -646,20 +646,25 @@ contract RocketMinipoolDelegate is RocketMinipoolStorageLayout, RocketMinipoolIn
         // Approve reduction and handle external state changes
         RocketMinipoolBondReducerInterface rocketBondReducer = RocketMinipoolBondReducerInterface(getContractAddress("rocketMinipoolBondReducer"));
         uint256 previousBond = nodeDepositBalance;
-        uint256 newBondAmount = rocketBondReducer.reduceBondAmount();
+        uint256 newBond = rocketBondReducer.reduceBondAmount();
         // Update user/node balances
-        userDepositBalance = getUserDepositBalance().add(previousBond.sub(newBondAmount));
-        nodeDepositBalance = newBondAmount;
+        userDepositBalance = getUserDepositBalance().add(previousBond.sub(newBond));
+        nodeDepositBalance = newBond;
         // Reset node fee to current network rate
         RocketNetworkFeesInterface rocketNetworkFees = RocketNetworkFeesInterface(getContractAddress("rocketNetworkFees"));
-        nodeFee = rocketNetworkFees.getNodeFee();
+        uint256 prevFee = nodeFee;
+        uint256 newFee = rocketNetworkFees.getNodeFee();
+        nodeFee = newFee;
+        // Update staking minipool counts and fee numerator
+        RocketMinipoolManagerInterface rocketMinipoolManager = RocketMinipoolManagerInterface(getContractAddress("rocketMinipoolManager"));
+        rocketMinipoolManager.updateNodeStakingMinipoolCount(previousBond, newBond, prevFee, newFee);
         // Break state to prevent rollback exploit
         if (depositType != MinipoolDeposit.Variable) {
-            userDepositBalanceLegacy = 2**256-1;
+            userDepositBalanceLegacy = 2 ** 256 - 1;
             depositType = MinipoolDeposit.Variable;
         }
         // Emit event
-        emit BondReduced(previousBond, newBondAmount, block.timestamp);
+        emit BondReduced(previousBond, newBond, block.timestamp);
     }
 
     /// @dev Distributes the current contract balance based on capital ratio and node fee

contracts/contract/minipool/RocketMinipoolManager.sol

@@ -251,6 +251,42 @@ contract RocketMinipoolManager is RocketBase, RocketMinipoolManagerInterface {
         return abi.encodePacked(byte(0x01), bytes11(0x0), address(_minipoolAddress));
     }
 
+    /// @notice Decrements a node operator's number of staking minipools based on the minipools prior bond amount and
+    ///         increments it based on their new bond amount.
+    /// @param _previousBond The minipool's previous bond value
+    /// @param _newBond The minipool's new bond value
+    /// @param _previousFee The fee of the minipool prior to the bond change
+    /// @param _newFee The fee of the minipool after the bond change
+    function updateNodeStakingMinipoolCount(uint256 _previousBond, uint256 _newBond, uint256 _previousFee, uint256 _newFee) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
+        bytes32 nodeKey;
+        bytes32 numeratorKey;
+        // Get contracts
+        RocketMinipoolInterface minipool = RocketMinipoolInterface(msg.sender);
+        address nodeAddress = minipool.getNodeAddress();
+        // Try to distribute current fees at previous average commission rate
+        _tryDistribute(nodeAddress);
+        // Decrement previous bond count
+        if (_previousBond == 16 ether){
+            nodeKey = keccak256(abi.encodePacked("node.minipools.staking.count", nodeAddress));
+            numeratorKey = keccak256(abi.encodePacked("node.average.fee.numerator", nodeAddress));
+        } else {
+            nodeKey = keccak256(abi.encodePacked("node.minipools.staking.count", nodeAddress, _previousBond));
+            numeratorKey = keccak256(abi.encodePacked("node.average.fee.numerator", nodeAddress, _previousBond));
+        }
+        subUint(nodeKey, 1);
+        subUint(numeratorKey, _previousFee);
+        // Increment new bond count
+        if (_newBond == 16 ether){
+            nodeKey = keccak256(abi.encodePacked("node.minipools.staking.count", nodeAddress));
+            numeratorKey = keccak256(abi.encodePacked("node.average.fee.numerator", nodeAddress));
+        } else {
+            nodeKey = keccak256(abi.encodePacked("node.minipools.staking.count", nodeAddress, _newBond));
+            numeratorKey = keccak256(abi.encodePacked("node.average.fee.numerator", nodeAddress, _newBond));
+        }
+        addUint(nodeKey, 1);
+        addUint(numeratorKey, _newFee);
+    }
+
     /// @dev Increments a node operator's number of staking minipools and calculates updated average node fee.
     ///      Must be called from the minipool itself as msg.sender is used to query the minipool's node fee
     /// @param _nodeAddress The node address to increment the number of staking minipools of

contracts/interface/minipool/RocketMinipoolManagerInterface.sol

@@ -28,6 +28,7 @@ interface RocketMinipoolManagerInterface {
     function getMinipoolExists(address _minipoolAddress) external view returns (bool);
     function getMinipoolDestroyed(address _minipoolAddress) external view returns (bool);
     function getMinipoolPubkey(address _minipoolAddress) external view returns (bytes memory);
+    function updateNodeStakingMinipoolCount(uint256 _previousBond, uint256 _newBond, uint256 _previousFee, uint256 _newFee) external;
     function getMinipoolWithdrawalCredentials(address _minipoolAddress) external pure returns (bytes memory);
     function createMinipool(address _nodeAddress, uint256 _salt) external returns (RocketMinipoolInterface);
     function createVacantMinipool(address _nodeAddress, uint256 _salt, bytes calldata _validatorPubkey, uint256 _bondAmount, uint256 _currentBalance) external returns (RocketMinipoolInterface);

test/minipool/scenario-reduce-bond.js

@@ -1,4 +1,9 @@
-import { RocketMinipoolBondReducer, RocketNodeDeposit, RocketNodeStaking } from '../_utils/artifacts';
+import {
+    RocketMinipoolBondReducer,
+    RocketMinipoolManager,
+    RocketNodeDeposit,
+    RocketNodeStaking,
+} from '../_utils/artifacts';
 import { assertBN } from '../_helpers/bn';
 
 
@@ -7,8 +12,12 @@ export async function reduceBond(minipool, txOptions = null) {
     const rocketNodeDeposit = await RocketNodeDeposit.deployed();
     const rocketNodeStaking = await RocketNodeStaking.deployed();
     const rocketMinipoolBondReducer = await RocketMinipoolBondReducer.deployed();
+    const rocketNodeManager = await RocketMinipoolManager.deployed();
     const node = await minipool.getNodeAddress();
 
+    const newBond = await rocketMinipoolBondReducer.getReduceBondValue(minipool.address);
+    const prevBond = await minipool.getNodeDepositBalance();
+
     // Get minipool balances
     function getMinipoolBalances() {
         return Promise.all([
@@ -22,19 +31,39 @@ export async function reduceBond(minipool, txOptions = null) {
         );
     }
 
+    // Get node details
+    function getNodeDetails() {
+        return Promise.all([
+            rocketNodeManager.getNodeStakingMinipoolCountBySize(node, prevBond),
+            rocketNodeManager.getNodeStakingMinipoolCountBySize(node, newBond),
+            rocketNodeManager.getNodeStakingMinipoolCount(node),
+        ]).then(
+            ([prevBondCount, newBondCount, totalCount]) =>
+                ({prevBondCount, newBondCount, totalCount})
+        )
+    }
+
     // Get new bond amount
     const amount = await rocketMinipoolBondReducer.getReduceBondValue(minipool.address);
 
     // Record balances before and after calling reduce bond function
     const balances1 = await getMinipoolBalances();
+    const details1 = await getNodeDetails();
     await minipool.reduceBondAmount(txOptions);
     const balances2 = await getMinipoolBalances();
-
-    const delta = balances1.nodeDepositBalance.sub(amount);
+    const details2 = await getNodeDetails();
 
     // Verify results
+    const delta = balances1.nodeDepositBalance.sub(amount);
     assertBN.equal(balances2.nodeDepositBalance, delta);
     assertBN.equal(balances2.userDepositBalance.sub(balances1.userDepositBalance), delta);
     assertBN.equal(balances2.nodeDepositCredit.sub(balances1.nodeDepositCredit), delta);
     assertBN.equal(balances2.ethMatched.sub(balances1.ethMatched), delta);
+
+    // Overall number of minipools shouldn't change
+    assertBN.equal(details2.totalCount, details1.totalCount);
+    // Prev bond amount should decrement by 1
+    assertBN.equal(details1.prevBondCount.sub(details2.prevBondCount), '1'.BN);
+    // New bond amount should increment by 1
+    assertBN.equal(details2.newBondCount.sub(details1.newBondCount), '1'.BN);
 }