Skip to content

Commit

Permalink
feat: tiebreaker improvements and unit tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@rkolpakov
rkolpakov committed Aug 14, 2024
1 parent 5cedbd4 commit 2e4b118
Show file tree
Hide file tree
Showing 2 changed files with 245 additions and 28 deletions.
80 changes: 52 additions & 28 deletions contracts/libraries/Tiebreaker.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,43 +2,45 @@
pragma solidity 0.8.26;

import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

import {Duration} from "../types/Duration.sol";
import {Timestamp, Timestamps} from "../types/Duration.sol";

import {ISealable} from "../interfaces/ISealable.sol";

import {SealableCalls} from "./SealableCalls.sol";
import {State as DualGovernanceState} from "./DualGovernanceStateMachine.sol";

/// @title Tiebreaker Library
/// @dev Library for managing tiebreaker functionality in a dual governance system.
library Tiebreaker {
using SealableCalls for ISealable;
using EnumerableSet for EnumerableSet.AddressSet;

error TiebreakDisallowed();
error InvalidSealable(address value);
error InvalidTiebreakerCommittee(address value);
error InvalidTiebreakerActivationTimeout(Duration value);
error TiebreakNotAllowed();
error InvalidSealable(address sealable);
error InvalidTiebreakerCommittee(address account);
error InvalidTiebreakerActivationTimeout(Duration timeout);
error CallerIsNotTiebreakerCommittee(address caller);
error SealableWithdrawalBlockersLimitReached();

event SealableWithdrawalBlockerAdded(address sealable);
event SealableWithdrawalBlockerRemoved(address sealable);
event TiebreakerCommitteeSet(address newTiebreakerCommittee);
event TiebreakerActivationTimeoutSet(Duration newTiebreakerActivationTimeout);

/// @dev Context struct to store tiebreaker-related data.
/// @param tiebreakerCommittee Address of the tiebreaker committee.
/// @param tiebreakerActivationTimeout Duration for tiebreaker activation timeout.
/// @param sealableWithdrawalBlockers Set of addresses that are sealable withdrawal blockers.
struct Context {
/// @dev slot0 [0..159]
address tiebreakerCommittee;
/// @dev slot0 [160..191]
Duration tiebreakerActivationTimeout;
/// @dev slot1 [0..255]
EnumerableSet.AddressSet sealableWithdrawalBlockers;
}

// ---
// Setup functionality
// ---

/// @notice Adds a sealable withdrawal blocker.
/// @dev Reverts if the maximum number of sealable withdrawal blockers is reached or if the sealable is invalid.
/// @param self The context storage.
/// @param sealableWithdrawalBlocker The address of the sealable withdrawal blocker to add.
/// @param maxSealableWithdrawalBlockersCount The maximum number of sealable withdrawal blockers allowed.
function addSealableWithdrawalBlocker(
Context storage self,
address sealableWithdrawalBlocker,
Expand All @@ -48,7 +50,6 @@ library Tiebreaker {
if (sealableWithdrawalBlockersCount == maxSealableWithdrawalBlockersCount) {
revert SealableWithdrawalBlockersLimitReached();
}

(bool isCallSucceed, /* lowLevelError */, /* isPaused */ ) = ISealable(sealableWithdrawalBlocker).callIsPaused();
if (!isCallSucceed) {
revert InvalidSealable(sealableWithdrawalBlocker);
Expand All @@ -60,13 +61,20 @@ library Tiebreaker {
}
}

/// @notice Removes a sealable withdrawal blocker.
/// @param self The context storage.
/// @param sealableWithdrawalBlocker The address of the sealable withdrawal blocker to remove.
function removeSealableWithdrawalBlocker(Context storage self, address sealableWithdrawalBlocker) internal {
bool isSuccessfullyRemoved = self.sealableWithdrawalBlockers.remove(sealableWithdrawalBlocker);
if (isSuccessfullyRemoved) {
emit SealableWithdrawalBlockerRemoved(sealableWithdrawalBlocker);
}
}

/// @notice Sets the tiebreaker committee.
/// @dev Reverts if the new tiebreaker committee address is invalid.
/// @param self The context storage.
/// @param newTiebreakerCommittee The address of the new tiebreaker committee.
function setTiebreakerCommittee(Context storage self, address newTiebreakerCommittee) internal {
if (newTiebreakerCommittee == address(0)) {
revert InvalidTiebreakerCommittee(newTiebreakerCommittee);
Expand All @@ -78,6 +86,12 @@ library Tiebreaker {
emit TiebreakerCommitteeSet(newTiebreakerCommittee);
}

/// @notice Sets the tiebreaker activation timeout.
/// @dev Reverts if the new timeout is outside the allowed range.
/// @param self The context storage.
/// @param minTiebreakerActivationTimeout The minimum allowed tiebreaker activation timeout.
/// @param newTiebreakerActivationTimeout The new tiebreaker activation timeout.
/// @param maxTiebreakerActivationTimeout The maximum allowed tiebreaker activation timeout.
function setTiebreakerActivationTimeout(
Context storage self,
Duration minTiebreakerActivationTimeout,
Expand All @@ -98,58 +112,68 @@ library Tiebreaker {
emit TiebreakerActivationTimeoutSet(newTiebreakerActivationTimeout);
}

// ---
// Checks
// ---

/// @notice Checks if the caller is the tiebreaker committee.
/// @dev Reverts if the caller is not the tiebreaker committee.
/// @param self The context storage.
function checkCallerIsTiebreakerCommittee(Context storage self) internal view {
if (msg.sender != self.tiebreakerCommittee) {
revert InvalidTiebreakerCommittee(msg.sender);
revert CallerIsNotTiebreakerCommittee(msg.sender);
}
}

/// @notice Checks if a tie exists.
/// @dev Reverts if no tie exists.
/// @param self The context storage.
/// @param state The current state of dual governance.
/// @param normalOrVetoCooldownExitedAt The timestamp when normal or veto cooldown exited.
function checkTie(
Context storage self,
DualGovernanceState state,
Timestamp normalOrVetoCooldownExitedAt
) internal view {
if (!isTie(self, state, normalOrVetoCooldownExitedAt)) {
revert TiebreakDisallowed();
revert TiebreakNotAllowed();
}
}

// ---
// Getters
// ---

/// @notice Determines if a tie exists.
/// @param self The context storage.
/// @param state The current state of dual governance.
/// @param normalOrVetoCooldownExitedAt The timestamp when normal or veto cooldown exited.
/// @return True if a tie exists, false otherwise.
function isTie(
Context storage self,
DualGovernanceState state,
Timestamp normalOrVetoCooldownExitedAt
) internal view returns (bool) {
if (state == DualGovernanceState.Normal || state == DualGovernanceState.VetoCooldown) return false;

// when the governance is locked for long period of time
if (Timestamps.now() >= self.tiebreakerActivationTimeout.addTo(normalOrVetoCooldownExitedAt)) {
return true;
}

return state == DualGovernanceState.RageQuit && isSomeSealableWithdrawalBlockerPaused(self);
}

/// @notice Checks if any sealable withdrawal blocker is paused.
/// @param self The context storage.
/// @return True if any sealable withdrawal blocker is paused, false otherwise.
function isSomeSealableWithdrawalBlockerPaused(Context storage self) internal view returns (bool) {
uint256 sealableWithdrawalBlockersCount = self.sealableWithdrawalBlockers.length();
for (uint256 i = 0; i < sealableWithdrawalBlockersCount; ++i) {
(bool isCallSucceed, /* lowLevelError */, bool isPaused) =
ISealable(self.sealableWithdrawalBlockers.at(i)).callIsPaused();

// in normal condition this call must never fail, so if some sealable withdrawal blocker
// started behave unexpectedly tiebreaker action may be the last hope for the protocol saving
if (isPaused || !isCallSucceed) return true;
}
return false;
}

/// @notice Gets the tiebreaker information.
/// @param self The context storage.
/// @return tiebreakerCommittee The address of the tiebreaker committee.
/// @return tiebreakerActivationTimeout The duration of the tiebreaker activation timeout.
/// @return sealableWithdrawalBlockers The addresses of the sealable withdrawal blockers.
function getTiebreakerInfo(Context storage self)
internal
view
Expand Down
193 changes: 193 additions & 0 deletions test/unit/libraries/Tiebreaker.t.sol
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,193 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

import {State as DualGovernanceState} from "contracts/libraries/DualGovernanceStateMachine.sol";
import {Tiebreaker} from "contracts/libraries/Tiebreaker.sol";
import {Duration, Durations, Timestamp, Timestamps} from "contracts/types/Duration.sol";
import {ISealable} from "contracts/interfaces/ISealable.sol";

import {UnitTest} from "test/utils/unit-test.sol";
import {SealableMock} from "../../mocks/SealableMock.sol";

contract TiebreakerTest is UnitTest {
using EnumerableSet for EnumerableSet.AddressSet;

Tiebreaker.Context private context;
SealableMock private mockSealable1;
SealableMock private mockSealable2;

function setUp() external {
mockSealable1 = new SealableMock();
mockSealable2 = new SealableMock();
}

function test_addSealableWithdrawalBlocker() external {
vm.expectEmit();
emit Tiebreaker.SealableWithdrawalBlockerAdded(address(mockSealable1));
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 1);

assertTrue(context.sealableWithdrawalBlockers.contains(address(mockSealable1)));
}

function test_AddSealableWithdrawalBlocker_RevertOn_LimitReached() external {
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 1);

vm.expectRevert(Tiebreaker.SealableWithdrawalBlockersLimitReached.selector);
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable2), 1);
}

function test_AddSealableWithdrawalBlocker_RevertOn_InvalidSealable() external {
mockSealable1.setShouldRevertIsPaused(true);

vm.expectRevert(abi.encodeWithSelector(Tiebreaker.InvalidSealable.selector, address(mockSealable1)));
// external call should be used to intercept the revert
this.external__addSealableWithdrawalBlocker(address(mockSealable1));

vm.expectRevert();
// external call should be used to intercept the revert
this.external__addSealableWithdrawalBlocker(address(0x123));
}

function test_RemoveSealableWithdrawalBlocker() external {
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 1);
assertTrue(context.sealableWithdrawalBlockers.contains(address(mockSealable1)));

vm.expectEmit();
emit Tiebreaker.SealableWithdrawalBlockerRemoved(address(mockSealable1));

Tiebreaker.removeSealableWithdrawalBlocker(context, address(mockSealable1));
assertFalse(context.sealableWithdrawalBlockers.contains(address(mockSealable1)));
}

function test_SetTiebreakerCommittee() external {
address newCommittee = address(0x123);

vm.expectEmit();
emit Tiebreaker.TiebreakerCommitteeSet(newCommittee);
Tiebreaker.setTiebreakerCommittee(context, newCommittee);

assertEq(context.tiebreakerCommittee, newCommittee);
}

function test_SetTiebreakerCommittee_WithExistingCommitteeAddress() external {
address newCommittee = address(0x123);

Tiebreaker.setTiebreakerCommittee(context, newCommittee);
Tiebreaker.setTiebreakerCommittee(context, newCommittee);
}

function test_SetTiebreakerCommittee_RevertOn_ZeroAddress() external {
vm.expectRevert(abi.encodeWithSelector(Tiebreaker.InvalidTiebreakerCommittee.selector, address(0)));
Tiebreaker.setTiebreakerCommittee(context, address(0));
}

function testFuzz_SetTiebreakerActivationTimeout(uint32 minTimeout, uint32 maxTimeout, uint32 timeout) external {
vm.assume(minTimeout < timeout && timeout < maxTimeout);

Duration min = Duration.wrap(minTimeout);
Duration max = Duration.wrap(maxTimeout);
Duration newTimeout = Duration.wrap(timeout);

vm.expectEmit();
emit Tiebreaker.TiebreakerActivationTimeoutSet(newTimeout);

Tiebreaker.setTiebreakerActivationTimeout(context, min, newTimeout, max);
assertEq(context.tiebreakerActivationTimeout, newTimeout);
}

function test_SetTiebreakerActivationTimeout_RevertOn_InvalidTimeout() external {
Duration minTimeout = Duration.wrap(1 days);
Duration maxTimeout = Duration.wrap(10 days);
Duration newTimeout = Duration.wrap(15 days);

vm.expectRevert(abi.encodeWithSelector(Tiebreaker.InvalidTiebreakerActivationTimeout.selector, newTimeout));
Tiebreaker.setTiebreakerActivationTimeout(context, minTimeout, newTimeout, maxTimeout);

newTimeout = Duration.wrap(0 days);

vm.expectRevert(abi.encodeWithSelector(Tiebreaker.InvalidTiebreakerActivationTimeout.selector, newTimeout));
Tiebreaker.setTiebreakerActivationTimeout(context, minTimeout, newTimeout, maxTimeout);
}

function test_IsSomeSealableWithdrawalBlockerPaused() external {
mockSealable1.pauseFor(1 days);
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 2);

bool result = Tiebreaker.isSomeSealableWithdrawalBlockerPaused(context);
assertTrue(result);

mockSealable1.resume();

result = Tiebreaker.isSomeSealableWithdrawalBlockerPaused(context);
assertFalse(result);

mockSealable1.setShouldRevertIsPaused(true);

result = Tiebreaker.isSomeSealableWithdrawalBlockerPaused(context);
assertTrue(result);
}

function test_CheckTie() external {
Timestamp cooldownExitedAt = Timestamps.from(block.timestamp);

Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 1);
Tiebreaker.setTiebreakerActivationTimeout(
context, Duration.wrap(1 days), Duration.wrap(3 days), Duration.wrap(10 days)
);

mockSealable1.pauseFor(1 days);
Tiebreaker.checkTie(context, DualGovernanceState.RageQuit, cooldownExitedAt);

_wait(Duration.wrap(3 days));
Tiebreaker.checkTie(context, DualGovernanceState.VetoSignalling, cooldownExitedAt);
}

function test_CheckTie_RevertOn_NormalOrVetoCooldownState() external {
Timestamp cooldownExitedAt = Timestamps.from(block.timestamp);

vm.expectRevert(Tiebreaker.TiebreakNotAllowed.selector);
Tiebreaker.checkTie(context, DualGovernanceState.Normal, cooldownExitedAt);

vm.expectRevert(Tiebreaker.TiebreakNotAllowed.selector);
Tiebreaker.checkTie(context, DualGovernanceState.VetoCooldown, cooldownExitedAt);
}

function test_CheckCallerIsTiebreakerCommittee() external {
context.tiebreakerCommittee = address(this);

vm.expectRevert(abi.encodeWithSelector(Tiebreaker.CallerIsNotTiebreakerCommittee.selector, address(0x456)));
vm.prank(address(0x456));
this.external__checkCallerIsTiebreakerCommittee();

this.external__checkCallerIsTiebreakerCommittee();
}

function test_GetTimebreakerInfo() external {
Tiebreaker.addSealableWithdrawalBlocker(context, address(mockSealable1), 1);

Duration minTimeout = Duration.wrap(1 days);
Duration maxTimeout = Duration.wrap(10 days);
Duration timeout = Duration.wrap(5 days);

context.tiebreakerActivationTimeout = timeout;
context.tiebreakerCommittee = address(0x123);

(address committee, Duration activationTimeout, address[] memory blockers) =
Tiebreaker.getTiebreakerInfo(context);

assertEq(committee, context.tiebreakerCommittee);
assertEq(activationTimeout, context.tiebreakerActivationTimeout);
assertEq(blockers[0], address(mockSealable1));
assertEq(blockers.length, 1);
}

function external__checkCallerIsTiebreakerCommittee() external {
Tiebreaker.checkCallerIsTiebreakerCommittee(context);
}

function external__addSealableWithdrawalBlocker(address sealable) external {
Tiebreaker.addSealableWithdrawalBlocker(context, sealable, 1);
}
}

0 comments on commit 2e4b118

Please sign in to comment.