LivenessModule2 implementation

packages/contracts-bedrock/interfaces/safe/ILivenessModule2.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { ISemver } from "interfaces/universal/ISemver.sol";
+
+/// @title ILivenessModule2
+/// @notice Interface for LivenessModule2, a singleton module for challenge-based ownership transfer
+interface ILivenessModule2 is ISemver {
+
+    /// @notice Error for when module is not enabled for the Safe
+    error LivenessModule2_ModuleNotEnabled();
+
+    /// @notice Error for when a challenge already exists
+    error LivenessModule2_ChallengeAlreadyExists();
+
+    /// @notice Error for when no challenge exists
+    error LivenessModule2_ChallengeDoesNotExist();
+
+    /// @notice Error for when challenge is not successful
+    error LivenessModule2_ChallengeNotSuccessful();
+
+    /// @notice Error for when caller is not authorized
+    error LivenessModule2_UnauthorizedCaller();
+
+    /// @notice Error for invalid parameters
+    error LivenessModule2_InvalidParameters();
+
+    /// @notice Error for when an owner is not found in the Safe's owner list
+    error LivenessModule2_OwnerNotFound();
+
+    /// @notice Emitted when a Safe enables the module
+    event ModuleEnabled(address indexed safe, uint256 livenessChallengePeriod, address fallbackOwner);
+
+    /// @notice Emitted when a Safe disables the module
+    event ModuleDisabled(address indexed safe);
+
+    /// @notice Emitted when a challenge is started
+    event ChallengeStarted(address indexed safe, uint256 challengeStartTime);
+
+    /// @notice Emitted when a challenge is cancelled
+    event ChallengeCancelled(address indexed safe);
+
+    /// @notice Emitted when ownership is transferred to the fallback owner
+    event ChallengeExecuted(address indexed safe, address fallbackOwner);
+
+    /// @notice Returns the configuration for a Safe
+    /// @return livenessChallengePeriod The challenge period
+    /// @return fallbackOwner The fallback owner address
+    /// @return challengeStartTime The challenge start time (0 if no challenge)
+    function safeConfigs(address) external view returns (uint256 livenessChallengePeriod, address fallbackOwner, uint256 challengeStartTime);
+
+    /// @notice Semantic version
+    /// @return version The contract version
+    function version() external view returns (string memory);
+
+    /// @notice Enables the module by the multisig to be challenged
+    /// @param _livenessChallengePeriod The period in seconds for a liveness challenge
+    /// @param _fallbackOwner The address that will become owner if challenge succeeds
+    function enableModule(uint256 _livenessChallengePeriod, address _fallbackOwner) external;
+
+    /// @notice Disables the module by an enabled safe
+    function disableModule() external;
+
+    /// @notice Returns the liveness_challenge_period and fallback_owner for a given safe
+    /// @param _safe The Safe address to query
+    /// @return livenessChallengePeriod The challenge period
+    /// @return fallbackOwner The fallback owner address
+    function viewConfiguration(address _safe) external view returns (uint256, address);
+
+    /// @notice Returns challenge_start_time + liveness_challenge_period if there is a challenge, or 0 if not
+    /// @param _safe The Safe address to query
+    /// @return The challenge end timestamp, or 0 if no challenge
+    function isChallenged(address _safe) external view returns (uint256);
+
+    /// @notice Challenges an enabled safe
+    /// @param _safe The Safe to challenge
+    function startChallenge(address _safe) external;
+
+    /// @notice Cancels a challenge for an enabled safe
+    function cancelChallenge() external;
+
+    /// @notice Removes all current owners from an enabled safe and appoints fallback as sole owner
+    /// @param _safe The Safe to transfer ownership of
+    function changeOwnershipToFallback(address _safe) external;
+}

packages/contracts-bedrock/scripts/checks/check-frozen-files.sh

@@ -98,6 +98,7 @@ ALLOWED_FILES=(
   "src/safe/DeputyPauseModule.sol:DeputyPauseModule"
   "src/safe/LivenessGuard.sol:LivenessGuard"
   "src/safe/LivenessModule.sol:LivenessModule"
+  "src/safe/LivenessModule2.sol:LivenessModule2"
   "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20"
   "src/universal/OptimismMintableERC20Factory.sol:OptimismMintableERC20Factory"
   "src/universal/StorageSetter.sol:StorageSetter"

packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol

@@ -7,13 +7,11 @@ import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol";
 import { GnosisSafeProxyFactory as SafeProxyFactory } from "safe-contracts/proxies/GnosisSafeProxyFactory.sol";
 import { OwnerManager } from "safe-contracts/base/OwnerManager.sol";
 import { ModuleManager } from "safe-contracts/base/ModuleManager.sol";
-import { GuardManager } from "safe-contracts/base/GuardManager.sol";
 import { Enum as SafeOps } from "safe-contracts/common/Enum.sol";
 
 import { DeployUtils } from "scripts/libraries/DeployUtils.sol";
 
-import { LivenessGuard } from "src/safe/LivenessGuard.sol";
-import { LivenessModule } from "src/safe/LivenessModule.sol";
+import { LivenessModule2 } from "src/safe/LivenessModule2.sol";
 import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
 
 import { Deploy } from "./Deploy.s.sol";
@@ -240,36 +238,14 @@ contract DeployOwnership is Deploy {
         });
     }
 
-    /// @notice Deploy a LivenessGuard for use on the Security Council Safe.
-    ///         Note this function does not have the broadcast modifier.
-    function deployLivenessGuard() public returns (address addr_) {
-        Safe councilSafe = Safe(payable(artifacts.mustGetAddress("SecurityCouncilSafe")));
-        addr_ = address(new LivenessGuard(councilSafe));
-
-        artifacts.save("LivenessGuard", address(addr_));
-        console.log("New LivenessGuard deployed at %s", address(addr_));
-    }
-
-    /// @notice Deploy a LivenessModule for use on the Security Council Safe
+    /// @notice Deploy a LivenessModule2 singleton for use on Security Council Safes
     ///         Note this function does not have the broadcast modifier.
     function deployLivenessModule() public returns (address addr_) {
-        Safe councilSafe = Safe(payable(artifacts.mustGetAddress("SecurityCouncilSafe")));
-        address guard = artifacts.mustGetAddress("LivenessGuard");
-        LivenessModuleConfig memory livenessModuleConfig = _getExampleCouncilConfig().livenessModuleConfig;
-
-        addr_ = address(
-            new LivenessModule({
-                _safe: councilSafe,
-                _livenessGuard: LivenessGuard(guard),
-                _livenessInterval: livenessModuleConfig.livenessInterval,
-                _thresholdPercentage: livenessModuleConfig.thresholdPercentage,
-                _minOwners: livenessModuleConfig.minOwners,
-                _fallbackOwner: livenessModuleConfig.fallbackOwner
-            })
-        );
+        // Deploy the singleton LivenessModule2 (no parameters needed)
+        addr_ = address(new LivenessModule2());
 
-        artifacts.save("LivenessModule", address(addr_));
-        console.log("New LivenessModule deployed at %s", address(addr_));
+        artifacts.save("LivenessModule2", address(addr_));
+        console.log("New LivenessModule2 deployed at %s", address(addr_));
     }
 
     /// @notice Deploy a Security Council Safe.
@@ -319,11 +295,6 @@ contract DeployOwnership is Deploy {
         SecurityCouncilConfig memory exampleCouncilConfig = _getExampleCouncilConfig();
         Safe safe = Safe(artifacts.mustGetAddress("SecurityCouncilSafe"));
 
-        // Deploy and add the Liveness Guard.
-        address guard = deployLivenessGuard();
-        _callViaSafe({ _safe: safe, _target: address(safe), _data: abi.encodeCall(GuardManager.setGuard, (guard)) });
-        console.log("LivenessGuard setup on SecurityCouncilSafe");
-
         // Deploy and add the Liveness Module.
         address livenessModule = deployLivenessModule();
         _callViaSafe({
@@ -332,13 +303,29 @@ contract DeployOwnership is Deploy {
             _data: abi.encodeCall(ModuleManager.enableModule, (livenessModule))
         });
 
+        // Configure the LivenessModule2 (second step of installation)
+        LivenessModuleConfig memory livenessModuleConfig = exampleCouncilConfig.livenessModuleConfig;
+        _callViaSafe({
+            _safe: safe,
+            _target: livenessModule,
+            _data: abi.encodeCall(
+                LivenessModule2.enableModule, (livenessModuleConfig.livenessInterval, livenessModuleConfig.fallbackOwner)
+            )
+        });
+
         // Finalize configuration by removing the additional deployer key.
         removeDeployerFromSafe({ _name: "SecurityCouncilSafe", _newThreshold: exampleCouncilConfig.safeConfig.threshold });
 
-        address[] memory owners = safe.getOwners();
+        // Verify the module was configured correctly
+        (uint256 configuredPeriod, address configuredFallback) =
+            LivenessModule2(livenessModule).viewConfiguration(address(safe));
+        require(
+            configuredPeriod == exampleCouncilConfig.livenessModuleConfig.livenessInterval,
+            "DeployOwnership: configured liveness interval must match expected value"
+        );
         require(
-            safe.getThreshold() == LivenessModule(livenessModule).getRequiredThreshold(owners.length),
-            "DeployOwnership: safe threshold must be equal to the LivenessModule's required threshold"
+            configuredFallback == exampleCouncilConfig.livenessModuleConfig.fallbackOwner,
+            "DeployOwnership: configured fallback owner must match expected value"
         );
 
         addr_ = address(safe);