Resumed sealable handling on tiebreaker vote

contracts/committees/HashConsensus.sol

@@ -5,7 +5,7 @@ pragma solidity 0.8.26;
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-import {Duration} from "../types/Duration.sol";
+import {Duration, Durations} from "../types/Duration.sol";
 import {Timestamp, Timestamps} from "../types/Timestamp.sol";
 
 /// @title HashConsensus Contract
@@ -49,6 +49,8 @@ abstract contract HashConsensus is Ownable {
     uint256 private _quorum;
     Duration private _timelockDuration;
 
+    Duration private immutable EXPIRATION_TIME = Durations.from(3 days);
+
     mapping(bytes32 hash => HashState state) private _hashStates;
     EnumerableSet.AddressSet private _members;
     mapping(address signer => mapping(bytes32 hash => bool approve)) public approves;
@@ -306,4 +308,8 @@ abstract contract HashConsensus is Ownable {
             revert CallerIsNotMember(msg.sender);
         }
     }
+
+    function _isExpired(bytes32 hash) internal view returns (bool) {
+        return EXPIRATION_TIME.addTo(_timelockDuration.addTo(_hashStates[hash].scheduledAt)) > Timestamps.now();
+    }
 }

contracts/committees/TiebreakerCoreCommittee.sol

@@ -15,6 +15,8 @@ import {ITiebreakerCoreCommittee} from "../interfaces/ITiebreakerCoreCommittee.s
 import {HashConsensus} from "./HashConsensus.sol";
 import {ProposalsList} from "./ProposalsList.sol";
 
+import {SealableCalls} from "../libraries/SealableCalls.sol";
+
 enum ProposalType {
     ScheduleProposal,
     ResumeSealable
@@ -27,7 +29,9 @@ contract TiebreakerCoreCommittee is ITiebreakerCoreCommittee, HashConsensus, Pro
     error ResumeSealableNonceMismatch();
     error ProposalDoesNotExist(uint256 proposalId);
     error InvalidSealable(address sealable);
+    error ExecutionExpired(bytes32 key);
 
+    uint256 public constant PAUSE_INFINITELY = type(uint256).max;
     address public immutable DUAL_GOVERNANCE;
 
     mapping(address sealable => uint256 nonce) private _sealableResumeNonces;
@@ -105,9 +109,13 @@ contract TiebreakerCoreCommittee is ITiebreakerCoreCommittee, HashConsensus, Pro
     /// @notice Gets the current resume nonce for a sealable address
     /// @dev Retrieves the resume nonce for the given sealable address
     /// @param sealable The address of the sealable to get the nonce for
-    /// @return The current resume nonce for the sealable address
-    function getSealableResumeNonce(address sealable) external view returns (uint256) {
-        return _sealableResumeNonces[sealable];
+    /// @return currentNonce The current resume nonce for the sealable address
+    function getSealableResumeNonce(address sealable) public view returns (uint256 currentNonce) {
+        currentNonce = _sealableResumeNonces[sealable];
+        (, bytes32 key) = _encodeSealableResume(sealable, currentNonce);
+        if (_isExpired(key)) {
+            currentNonce++;
+        }
     }
 
     /// @notice Votes on a proposal to resume a sealable address
@@ -118,13 +126,23 @@ contract TiebreakerCoreCommittee is ITiebreakerCoreCommittee, HashConsensus, Pro
     function sealableResume(address sealable, uint256 nonce) external {
         _checkCallerIsMember();
 
-        if (sealable == address(0)) {
+        (bool isCallSucceed, uint256 resumeSinceTimestamp) = SealableCalls.callGetResumeSinceTimestamp(sealable);
+
+        /// @dev Prevents addition of paused or misbehaving sealables.
+        ///     According to the current PausableUntil implementation, a contract is paused if `block.timestamp < resumeSinceTimestamp`.
+        ///     Reference: https://github.com/lidofinance/core/blob/60bc9b77b036eec22b2ab8a3a1d49c6b6614c600/contracts/0.8.9/utils/PausableUntil.sol#L52
+        if (!isCallSucceed || block.timestamp >= resumeSinceTimestamp || resumeSinceTimestamp == PAUSE_INFINITELY) {
             revert InvalidSealable(sealable);
         }
 
-        if (nonce != _sealableResumeNonces[sealable]) {
+        uint256 currentNonce = getSealableResumeNonce(sealable);
+
+        if (nonce != currentNonce) {
             revert ResumeSealableNonceMismatch();
         }
+        if (currentNonce != _sealableResumeNonces[sealable]) {
+            _sealableResumeNonces[sealable] = currentNonce;
+        }
 
         (bytes memory proposalData, bytes32 key) = _encodeSealableResume(sealable, nonce);
         _vote(key, true);
@@ -151,7 +169,13 @@ contract TiebreakerCoreCommittee is ITiebreakerCoreCommittee, HashConsensus, Pro
     /// @dev Executes the resume sealable proposal by calling the tiebreakerResumeSealable function on the Dual Governance contract
     /// @param sealable The address to resume
     function executeSealableResume(address sealable) external {
-        (, bytes32 key) = _encodeSealableResume(sealable, _sealableResumeNonces[sealable]);
+        uint256 currentNonce = getSealableResumeNonce(sealable);
+        (, bytes32 key) = _encodeSealableResume(sealable, currentNonce);
+
+        if (_isExpired(key)) {
+            revert ExecutionExpired(key);
+        }
+
         _markUsed(key);
         _sealableResumeNonces[sealable]++;
         Address.functionCall(

contracts/committees/TiebreakerSubCommittee.sol

@@ -12,6 +12,8 @@ import {ITiebreakerCoreCommittee} from "../interfaces/ITiebreakerCoreCommittee.s
 import {HashConsensus} from "./HashConsensus.sol";
 import {ProposalsList} from "./ProposalsList.sol";
 
+import {SealableCalls} from "../libraries/SealableCalls.sol";
+
 enum ProposalType {
     ScheduleProposal,
     ResumeSealable
@@ -23,6 +25,7 @@ enum ProposalType {
 contract TiebreakerSubCommittee is HashConsensus, ProposalsList {
     error InvalidSealable(address sealable);
 
+    uint256 public constant PAUSE_INFINITELY = type(uint256).max;
     address public immutable TIEBREAKER_CORE_COMMITTEE;
 
     constructor(
@@ -100,9 +103,15 @@ contract TiebreakerSubCommittee is HashConsensus, ProposalsList {
     function sealableResume(address sealable) external {
         _checkCallerIsMember();
 
-        if (sealable == address(0)) {
+        (bool isCallSucceed, uint256 resumeSinceTimestamp) = SealableCalls.callGetResumeSinceTimestamp(sealable);
+
+        /// @dev Prevents addition of paused or misbehaving sealables.
+        ///     According to the current PausableUntil implementation, a contract is paused if `block.timestamp < resumeSinceTimestamp`.
+        ///     Reference: https://github.com/lidofinance/core/blob/60bc9b77b036eec22b2ab8a3a1d49c6b6614c600/contracts/0.8.9/utils/PausableUntil.sol#L52
+        if (!isCallSucceed || block.timestamp >= resumeSinceTimestamp || resumeSinceTimestamp == PAUSE_INFINITELY) {
             revert InvalidSealable(sealable);
         }
+
         (bytes memory proposalData, bytes32 key,) = _encodeSealableResume(sealable);
         _vote(key, true);
         _pushProposal(key, uint256(ProposalType.ResumeSealable), proposalData);

test/unit/committees/TiebreakerCore.t.sol

@@ -8,6 +8,7 @@ import {Timestamp} from "contracts/types/Timestamp.sol";
 
 import {ITimelock} from "contracts/interfaces/ITimelock.sol";
 import {ITiebreaker} from "contracts/interfaces/ITiebreaker.sol";
+import {ISealable} from "contracts/libraries/SealableCalls.sol";
 
 import {TargetMock} from "test/utils/target-mock.sol";
 import {UnitTest} from "test/utils/unit-test.sol";
@@ -125,6 +126,7 @@ contract TiebreakerCoreUnitTest is UnitTest {
     function test_sealableResume_HappyPath() external {
         uint256 nonce = tiebreakerCore.getSealableResumeNonce(sealable);
 
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1);
         vm.prank(committeeMembers[0]);
         tiebreakerCore.sealableResume(sealable, nonce);
 
@@ -159,6 +161,7 @@ contract TiebreakerCoreUnitTest is UnitTest {
     function test_executeSealableResume_HappyPath() external {
         uint256 nonce = tiebreakerCore.getSealableResumeNonce(sealable);
 
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1000);
         vm.prank(committeeMembers[0]);
         tiebreakerCore.sealableResume(sealable, nonce);
         vm.prank(committeeMembers[1]);
@@ -215,4 +218,12 @@ contract TiebreakerCoreUnitTest is UnitTest {
         assertEq(quorumAt, quorumAtExpected);
         assertTrue(isExecuted);
     }
+
+    function _mockSealableResumeSinceTimestampResult(address sealableAddress, uint256 resumeSinceTimestamp) internal {
+        vm.mockCall(
+            sealableAddress,
+            abi.encodeWithSelector(ISealable.getResumeSinceTimestamp.selector),
+            abi.encode(resumeSinceTimestamp)
+        );
+    }
 }

test/unit/committees/TiebreakerSubCommittee.t.sol

@@ -7,6 +7,7 @@ import {TiebreakerCoreCommittee} from "contracts/committees/TiebreakerCoreCommit
 import {TiebreakerSubCommittee, ProposalType} from "contracts/committees/TiebreakerSubCommittee.sol";
 import {HashConsensus} from "contracts/committees/HashConsensus.sol";
 import {Timestamp} from "contracts/types/Timestamp.sol";
+import {ISealable} from "contracts/libraries/SealableCalls.sol";
 import {UnitTest} from "test/utils/unit-test.sol";
 
 import {TargetMock} from "test/utils/target-mock.sol";
@@ -121,6 +122,7 @@ contract TiebreakerSubCommitteeUnitTest is UnitTest {
             abi.encode(0)
         );
 
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1);
         vm.prank(committeeMembers[0]);
         tiebreakerSubCommittee.sealableResume(sealable);
 
@@ -158,7 +160,7 @@ contract TiebreakerSubCommitteeUnitTest is UnitTest {
             abi.encodeWithSelector(ITiebreakerCoreCommittee.getSealableResumeNonce.selector, sealable),
             abi.encode(0)
         );
-
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1);
         vm.prank(committeeMembers[0]);
         tiebreakerSubCommittee.sealableResume(sealable);
         vm.prank(committeeMembers[1]);
@@ -181,6 +183,8 @@ contract TiebreakerSubCommitteeUnitTest is UnitTest {
             abi.encode(0)
         );
 
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1);
+
         vm.prank(committeeMembers[0]);
         tiebreakerSubCommittee.sealableResume(sealable);
 
@@ -236,6 +240,7 @@ contract TiebreakerSubCommitteeUnitTest is UnitTest {
             abi.encodeWithSelector(ITiebreakerCoreCommittee.getSealableResumeNonce.selector, sealable),
             abi.encode(0)
         );
+        _mockSealableResumeSinceTimestampResult(sealable, block.timestamp + 1);
 
         (uint256 support, uint256 executionQuorum, Timestamp quorumAt, bool isExecuted) =
             tiebreakerSubCommittee.getSealableResumeState(sealable);
@@ -271,4 +276,12 @@ contract TiebreakerSubCommitteeUnitTest is UnitTest {
         assertEq(quorumAt, Timestamp.wrap(uint40(block.timestamp)));
         assertTrue(isExecuted);
     }
+
+    function _mockSealableResumeSinceTimestampResult(address sealableAddress, uint256 resumeSinceTimestamp) internal {
+        vm.mockCall(
+            sealableAddress,
+            abi.encodeWithSelector(ISealable.getResumeSinceTimestamp.selector),
+            abi.encode(resumeSinceTimestamp)
+        );
+    }
 }

test/utils/scenario-test-blueprint.sol

@@ -23,6 +23,7 @@ import {IDualGovernance} from "contracts/interfaces/IDualGovernance.sol";
 import {ITimelock} from "contracts/interfaces/ITimelock.sol";
 import {IWithdrawalQueue} from "contracts/interfaces/IWithdrawalQueue.sol";
 import {IPotentiallyDangerousContract} from "./interfaces/IPotentiallyDangerousContract.sol";
+import {ISealable} from "contracts/libraries/SealableCalls.sol";
 
 // ---
 // Libraries
@@ -601,4 +602,12 @@ contract ScenarioTestBlueprint is TestingAssertEqExtender, SetupDeployment {
             )
         );
     }
+
+    function _mockSealableResumeSinceTimestampResult(address sealableAddress, uint256 resumeSinceTimestamp) internal {
+        vm.mockCall(
+            sealableAddress,
+            abi.encodeWithSelector(ISealable.getResumeSinceTimestamp.selector),
+            abi.encode(resumeSinceTimestamp)
+        );
+    }
 }