Work on penalties and bond reduction

kanewallmann · kanewallmann · commit 6c6d52d08ca4 · 2025-04-07T09:24:14.000+10:00
diff --git a/contracts/contract/deposit/RocketDepositPool.sol b/contracts/contract/deposit/RocketDepositPool.sol
@@ -516,6 +516,7 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
         RocketMegapoolDelegateInterface megapool = RocketMegapoolDelegateInterface(msg.sender);
         address nodeAddress = megapool.getNodeAddress();
         addUint(keccak256(abi.encodePacked("node.deposit.credit.balance", nodeAddress)), _amount);
+        addUint("deposit.pool.node.balance", _amount);
     }
 
     /// @notice Allows node operator to withdraw any ETH credit they have as rETH
diff --git a/contracts/contract/megapool/RocketMegapoolDelegate.sol b/contracts/contract/megapool/RocketMegapoolDelegate.sol
@@ -37,6 +37,7 @@ contract RocketMegapoolDelegate is RocketMegapoolDelegateBase, RocketMegapoolDel
     event MegapoolValidatorStaked(uint256 indexed validatorId, uint256 time);
     event MegapoolDebtIncreased(uint256 amount, uint256 time);
     event MegapoolDebtReduced(uint256 amount, uint256 time);
+    event MegapoolBondReduced(uint256 amount, uint256 time);
     event RewardsDistributed(uint256 nodeAmount, uint256 voterAmount, uint256 rethAmount, uint256 time);
     event RewardsClaimed(uint256 amount, uint256 time);
 
@@ -138,6 +139,31 @@ contract RocketMegapoolDelegate is RocketMegapoolDelegateBase, RocketMegapoolDel
         emit MegapoolValidatorDequeued(_validatorId, block.timestamp);
     }
 
+    /// @notice Reduces this megapool's bond and applies credit if current bond exceeds requirement
+    /// @param _amount Amount in ETH to reduce bond by
+    function reduceBond(uint256 _amount) override external onlyMegapoolOwner {
+        // Check pre-conditions
+        require(_amount > 0, "Invalid amount");
+        require(debt == 0, "Cannot reduce bond with debt");
+        RocketNodeDepositInterface rocketNodeDeposit = RocketNodeDepositInterface(getContractAddress("rocketNodeDeposit"));
+        uint256 newBondRequirement = rocketNodeDeposit.getBondRequirement(getActiveValidatorCount());
+        require (nodeBond > newBondRequirement, "Bond is at minimum");
+        uint256 maxReduce = nodeBond - newBondRequirement;
+        require(_amount <= maxReduce, "New bond is too low");
+        // Force distribute at previous capital ratio
+        uint256 pendingRewards = getPendingRewards();
+        if (pendingRewards > 0) {
+            _distributeAmount(pendingRewards);
+        }
+        // Reduce node bond
+        nodeBond -= _amount;
+        // Apply credit
+        RocketDepositPoolInterface rocketDepositPool = RocketDepositPoolInterface(getContractAddress("rocketDepositPool"));
+        rocketDepositPool.applyCredit(_amount);
+        // Emit event
+        emit MegapoolBondReduced(_amount, block.timestamp);
+    }
+
     /// @notice Accepts requested funds from the deposit pool
     /// @param _validatorId the validator ID
     function assignFunds(uint32 _validatorId) external payable onlyLatestContract("rocketDepositPool", msg.sender) {
diff --git a/contracts/contract/megapool/RocketMegapoolPenalties.sol b/contracts/contract/megapool/RocketMegapoolPenalties.sol
@@ -9,10 +9,11 @@ import {RocketNetworkSnapshotsInterface} from "../../interface/network/RocketNet
 import {RocketMegapoolDelegateInterface} from "../../interface/megapool/RocketMegapoolDelegateInterface.sol";
 import {RocketMegapoolPenaltiesInterface} from "../../interface/megapool/RocketMegapoolPenaltiesInterface.sol";
 
-/// @notice Performs deterministic deployment of megapool delegate contracts and handles deprecation of old ones
+/// @notice Applies penalties to megapools for MEV theft
 contract RocketMegapoolPenalties is RocketBase, RocketMegapoolPenaltiesInterface {
     // Constants
     uint256 constant internal penaltyMaximumPeriod = 50400;
+    bytes32 constant internal penaltyKey = keccak256(abi.encodePacked("megapool.running.penalty"));
 
     constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
     }
@@ -30,7 +31,9 @@ contract RocketMegapoolPenalties is RocketBase, RocketMegapoolPenaltiesInterface
     /// @param _megapool Address of the accused megapool
     /// @param _block Block that the theft occurred (used for uniqueness)
     /// @param _amount Amount in ETH of the penalty
-    function penalise(address _megapool, uint256 _block, uint256 _amount) override external onlyTrustedNode(msg.sender) {
+    function penalise(address _megapool, uint256 _block, uint256 _amount) override external onlyTrustedNode(msg.sender) onlyRegisteredMegapool(_megapool) {
+        require(_amount > 0, "Invalid penalty amount");
+        require(_block < block.number, "Invalid block number");
         // Check this penalty hasn't already reach majority and been applied
         bytes32 penaltyAppliedKey = keccak256(abi.encodePacked("megapool.penalty.submission.applied", _megapool, _block, _amount));
         require(!getBool(penaltyAppliedKey), "Penalty already applied");
@@ -52,41 +55,54 @@ contract RocketMegapoolPenalties is RocketBase, RocketMegapoolPenaltiesInterface
         }
     }
 
-    function getPenaltyRunningTotalAtBlock(address _megapool, uint32 _block) override external view returns (uint256) {
+    /// @dev Manually execute a penalty that has hit majority vote
+    /// @param _megapool Address of the accused megapool
+    /// @param _block Block that the theft occurred (used for uniqueness)
+    /// @param _amount Amount in ETH of the penalty
+    function executePenalty(address _megapool, uint256 _block, uint256 _amount) override external {
+        // Check this penalty hasn't already reach majority and been applied
+        bytes32 penaltyAppliedKey = keccak256(abi.encodePacked("megapool.penalty.submission.applied", _megapool, _block, _amount));
+        require(!getBool(penaltyAppliedKey), "Penalty already applied");
+        // Get submission keys
+        bytes32 submissionCountKey = keccak256(abi.encodePacked("megapool.penalty.submission", _megapool, _block, _amount));
+        // Increment submission count
+        uint256 submissionCount = getUint(submissionCountKey);
+        // Check for majority
+        RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
+        if (calcBase * submissionCount / rocketDAONodeTrusted.getMemberCount() > 0.5 ether) {
+            // Apply penalty and mark as applied
+            applyPenalty(_megapool, _amount);
+            setBool(penaltyAppliedKey, true);
+        }
+    }
+
+    function getPenaltyRunningTotalAtBlock(uint32 _block) override external view returns (uint256) {
         RocketNetworkSnapshotsInterface rocketNetworkSnapshots = RocketNetworkSnapshotsInterface(getContractAddress("rocketNetworkSnapshots"));
-        bytes32 penaltyKey = keccak256(abi.encodePacked("megapool.running.penalty", _megapool));
         return rocketNetworkSnapshots.lookup(penaltyKey, _block);
     }
 
-    function getCurrentPenaltyRunningTotal(address _megapool) override external view returns (uint256) {
+    function getCurrentPenaltyRunningTotal() override external view returns (uint256) {
         RocketNetworkSnapshotsInterface rocketNetworkSnapshots = RocketNetworkSnapshotsInterface(getContractAddress("rocketNetworkSnapshots"));
-        bytes32 penaltyKey = keccak256(abi.encodePacked("megapool.running.penalty", _megapool));
         (,,uint224 value) =  rocketNetworkSnapshots.latest(penaltyKey);
         return uint256(value);
     }
 
-    function getCurrentMaxPenalty(address _megapool) override external view returns (uint256) {
+    function getCurrentMaxPenalty() override external view returns (uint256) {
         // Get contracts
         RocketNetworkSnapshotsInterface rocketNetworkSnapshots = RocketNetworkSnapshotsInterface(getContractAddress("rocketNetworkSnapshots"));
         RocketDAOProtocolSettingsMegapoolInterface rocketDAOProtocolSettingsMegapool = RocketDAOProtocolSettingsMegapoolInterface(getContractAddress("rocketDAOProtocolSettingsMegapool"));
         // Grab max weekly penalty
         uint256 maxPenalty = rocketDAOProtocolSettingsMegapool.getMaximumEthPenalty();
-        // Precompute storage key
-        bytes32 penaltyKey = keccak256(abi.encodePacked("megapool.running.penalty", _megapool));
         // Get running total from 50400 slots ago
         uint256 earlierBlock = 0;
         if (block.number > penaltyMaximumPeriod) {
             earlierBlock = block.number - penaltyMaximumPeriod;
         }
-        uint256 earlierRunningTotal = rocketNetworkSnapshots.lookupRecent(penaltyKey, uint32(earlierBlock), 5);
+        uint256 earlierRunningTotal = uint256(rocketNetworkSnapshots.lookup(penaltyKey, uint32(earlierBlock)));
         // Get current running total
-        (bool exists, uint32 slot, uint224 value) = rocketNetworkSnapshots.latest(penaltyKey);
-        uint256 currentTotal = 0;
-        if (exists) {
-            currentTotal = value;
-        }
+        (bool exists,, uint224 currentTotal) = rocketNetworkSnapshots.latest(penaltyKey);
         // Cap the penalty at the maximum amount based on past 50400 blocks
-        return maxPenalty - (currentTotal - earlierRunningTotal);
+        return maxPenalty - (uint256(currentTotal) - earlierRunningTotal);
     }
 
     /// @dev Applies a penalty up to given amount, honouring the max penalty parameter
@@ -96,29 +112,19 @@ contract RocketMegapoolPenalties is RocketBase, RocketMegapoolPenaltiesInterface
         RocketDAOProtocolSettingsMegapoolInterface rocketDAOProtocolSettingsMegapool = RocketDAOProtocolSettingsMegapoolInterface(getContractAddress("rocketDAOProtocolSettingsMegapool"));
         // Grab max weekly penalty
         uint256 maxPenalty = rocketDAOProtocolSettingsMegapool.getMaximumEthPenalty();
-        // Precompute storage key
-        bytes32 penaltyKey = keccak256(abi.encodePacked("megapool.running.penalty", _megapool));
         // Get running total from 50400 slots ago
         uint256 earlierBlock = 0;
         if (block.number > penaltyMaximumPeriod) {
             earlierBlock = block.number - penaltyMaximumPeriod;
         }
-        uint256 earlierRunningTotal = rocketNetworkSnapshots.lookupRecent(penaltyKey, uint32(earlierBlock), 5);
+        uint256 earlierRunningTotal = rocketNetworkSnapshots.lookup(penaltyKey, uint32(earlierBlock));
         // Get current running total
-        (bool exists, uint32 slot, uint224 value) = rocketNetworkSnapshots.latest(penaltyKey);
-        uint256 currentTotal = 0;
-        if (exists) {
-            currentTotal = value;
-        }
+        (,, uint224 currentTotal) = rocketNetworkSnapshots.latest(penaltyKey);
         // Cap the penalty at the maximum amount based on past 50400 blocks
-        uint256 maxCurrentPenalty = maxPenalty - (currentTotal - earlierRunningTotal);
-        if (_amount > maxCurrentPenalty) {
-            _amount = maxCurrentPenalty;
-        }
-        // Prevent useless penalty
-        require(_amount > 0, "No penalty to apply");
+        uint256 maxCurrentPenalty = maxPenalty - (uint256(currentTotal) - earlierRunningTotal);
+        require(_amount <= maxCurrentPenalty, "Max penalty exceeded");
         // Insert new running total
-        rocketNetworkSnapshots.push(penaltyKey, uint224(currentTotal + _amount));
+        rocketNetworkSnapshots.push(penaltyKey, currentTotal + uint224(_amount));
         // Call megapool to increase debt
         RocketMegapoolDelegateInterface(_megapool).applyPenalty(_amount);
     }
diff --git a/contracts/interface/megapool/RocketMegapoolDelegateInterface.sol b/contracts/interface/megapool/RocketMegapoolDelegateInterface.sol
@@ -12,6 +12,7 @@ interface RocketMegapoolDelegateInterface is RocketMegapoolDelegateBaseInterface
 
     function newValidator(uint256 _bondAmount, bool _useExpressTicket, bytes calldata _validatorPubkey, bytes calldata _validatorSignature, bytes32 _depositDataRoot) external;
     function dequeue(uint32 _validatorId) external;
+    function reduceBond(uint256 _amount) external;
     function assignFunds(uint32 _validatorId) external payable;
     function stake(uint32 _validatorId, ValidatorProof calldata _proof) external;
     function dissolveValidator(uint32 _validatorId) external;
diff --git a/contracts/interface/megapool/RocketMegapoolPenaltiesInterface.sol b/contracts/interface/megapool/RocketMegapoolPenaltiesInterface.sol
@@ -4,7 +4,8 @@ pragma solidity >0.5.0 <0.9.0;
 interface RocketMegapoolPenaltiesInterface {
     function getVoteCount(address _megapool, uint256 _block, uint256 _amount) external view returns (uint256);
     function penalise(address _megapool, uint256 _block, uint256 _amount) external;
-    function getPenaltyRunningTotalAtBlock(address _megapool, uint32 _block) external view returns (uint256);
-    function getCurrentPenaltyRunningTotal(address _megapool) external view returns (uint256);
-    function getCurrentMaxPenalty(address _megapool) external view returns (uint256);
+    function executePenalty(address _megapool, uint256 _block, uint256 _amount) external;
+    function getPenaltyRunningTotalAtBlock(uint32 _block) external view returns (uint256);
+    function getCurrentPenaltyRunningTotal() external view returns (uint256);
+    function getCurrentMaxPenalty() external view returns (uint256);
 }
diff --git a/test/megapool/megapool-tests.js b/test/megapool/megapool-tests.js
@@ -345,7 +345,7 @@ export default function() {
             await deployMegapool({ from: node });
 
             await applyPenalty(megapool, 0n, '301'.ether, trustedNode1);
-            await applyPenalty(megapool, 0n, '301'.ether, trustedNode2);
+            await shouldRevert(applyPenalty(megapool, 0n, '301'.ether, trustedNode2), 'Max penalty exceeded', 'Max penalty exceeded');
         });
 
         it(printTitle('trusted node', 'can apply another penalty only after 50400 blocks'), async () => {
@@ -357,14 +357,62 @@ export default function() {
             const megapoolDebtBefore = await megapool.getDebt();
             await helpers.mine(50397);
             await applyPenalty(megapool, 1n, '300'.ether, trustedNode1);
-            await shouldRevert(applyPenalty(megapool, 1n, '300'.ether, trustedNode2), 'Applied greater penalty', 'No penalty to apply');
+            await shouldRevert(applyPenalty(megapool, 1n, '300'.ether, trustedNode2), 'Applied greater penalty', 'Max penalty exceeded');
             await helpers.mine(3);
             await applyPenalty(megapool, 1n, '300'.ether, trustedNode2);
             const megapoolDebtAfter = await megapool.getDebt();
             const debtDelta = megapoolDebtAfter - megapoolDebtBefore;
             assertBN.equal(debtDelta, '300'.ether);
         });
 
+        snapshotDescribe('With overbonded megapool', () => {
+            before(async () => {
+                // Deposit enough for 4 validators
+                await userDeposit({ from: random, value: ('32'.ether - '4'.ether) * 4n });
+                await nodeDeposit(node, '4'.ether);
+                await nodeDeposit(node, '4'.ether);
+                await nodeDeposit(node, '4'.ether);
+                // Reduce 'reduced.bond' to 2 ETH
+                await setDAOProtocolBootstrapSetting(RocketDAOProtocolSettingsNode, 'reduced.bond', '2'.ether, { from: owner });
+                // Node is now overbonded by 2 ETH
+            });
+
+            it(printTitle('node', 'can not reduce bond below requirement'), async () => {
+                await shouldRevert(megapool.reduceBond('3'.ether), 'Reduced bond below requirement', 'New bond is too low');
+            });
+
+            it(printTitle('node', 'can partially reduce bond'), async () => {
+                await megapool.reduceBond('1'.ether);
+            });
+
+            it(printTitle('node', 'can not reduce bond while at minimum'), async () => {
+                await megapool.reduceBond('2'.ether);
+                await shouldRevert(megapool.reduceBond('1'.ether), 'Reduced bond below requirement', 'Bond is at minimum');
+            });
+
+            it(printTitle('node', 'can not reduce bond with debt'), async () => {
+                await applyPenalty(megapool, 0n, '1'.ether, trustedNode1);
+                await applyPenalty(megapool, 0n, '1'.ether, trustedNode2);
+                await shouldRevert(megapool.reduceBond('2'.ether), 'Reduced bond with debt', 'Cannot reduce bond with debt');
+            });
+
+            it(printTitle('node', 'can reduce bond to new requirement and use credit for another validator'), async () => {
+                await megapool.reduceBond('2'.ether);
+                await nodeDeposit(node, '2'.ether, false, '2'.ether);
+            });
+
+            it(printTitle('node', 'can reduce bond to new requirement and use credit to mint rETH'), async () => {
+                await megapool.reduceBond('2'.ether);
+                await withdrawCredit(node, '2'.ether);
+            });
+
+            it(printTitle('node', 'can reduce bond to new requirement and use some credit for another validator and some for rETH'), async () => {
+                await megapool.reduceBond('2'.ether);
+                await withdrawCredit(node, '1'.ether);
+                await nodeDeposit(node, '2'.ether, false, '1'.ether);
+            });
+        });
+
         snapshotDescribe('With full deposit pool', () => {
             const dissolvePeriod = (60 * 60 * 48); // 24 hours
 
diff --git a/test/megapool/scenario-apply-penalty.js b/test/megapool/scenario-apply-penalty.js
@@ -16,8 +16,8 @@ export async function applyPenalty(megapool, slot, amount, trustedNode) {
         let [voteCount, nodeDebt, currentMaxPenalty, currentPenaltyRunningTotal] = await Promise.all([
             rocketMegapoolPenalties.getVoteCount(megapool.target, slot, amount),
             megapool.getDebt(),
-            rocketMegapoolPenalties.getCurrentMaxPenalty(megapool.target),
-            rocketMegapoolPenalties.getCurrentPenaltyRunningTotal(megapool.target),
+            rocketMegapoolPenalties.getCurrentMaxPenalty(),
+            rocketMegapoolPenalties.getCurrentPenaltyRunningTotal(),
         ]);
         return { voteCount, nodeDebt, currentMaxPenalty, currentPenaltyRunningTotal };
     }

Original file line number	Diff line number	Diff line change
`@@ -516,6 +516,7 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul`
`516`	`516`	`RocketMegapoolDelegateInterface megapool = RocketMegapoolDelegateInterface(msg.sender);`
`517`	`517`	`address nodeAddress = megapool.getNodeAddress();`
`518`	`518`	`addUint(keccak256(abi.encodePacked("node.deposit.credit.balance", nodeAddress)), _amount);`
	`519`	`+ addUint("deposit.pool.node.balance", _amount);`
`519`	`520`	`}`
`520`	`521`
`521`	`522`	`/// @notice Allows node operator to withdraw any ETH credit they have as rETH`