(pausable option C) Pausable sapient signer (#96)

* Pausable base contract

* Pausable sapient

* emit set operator events on constructor

* Revert on paused

* disable renounceOwnership

* Use enumerable set for getOperators

* add co-signer need comment to pausable

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Agusx1211

src/autoRecovery/Allowlist.sol

@@ -14,6 +14,8 @@ contract Allowlist is Ownable {
   error NotAllowed(address addr);
   /// @notice The provided index hint does not point at the expected address.
   error IndexMismatch(uint256 index, address expected, address actual);
+  /// @notice Ownership renunciation is disabled to keep allowlist administration available.
+  error OwnershipRenunciationDisabled();
 
   mapping(address => bool) private _allowed;
   address[] private _entries;
@@ -74,6 +76,11 @@ contract Allowlist is Ownable {
     return _entries;
   }
 
+  /// @notice Disables ownership renunciation to avoid permanently locked administration.
+  function renounceOwnership() public view override onlyOwner {
+    revert OwnershipRenunciationDisabled();
+  }
+
   function _add(address addr) private {
     if (addr == address(0)) revert ZeroAddress();
     if (_allowed[addr]) revert AlreadyAllowed(addr);

src/pausable/Pausable.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.27;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+/// @title Pausable
+/// @notice Owner-controlled pause state with additional operators that may only pause.
+abstract contract Pausable is Ownable {
+  using EnumerableSet for EnumerableSet.AddressSet;
+
+  /// @notice The zero address was provided where an operator address is required.
+  error ZeroAddress();
+  /// @notice The caller is neither the owner nor a pause operator.
+  error UnauthorizedPauser(address account);
+  /// @notice The contract is paused.
+  error EnforcedPause();
+  /// @notice The contract is not paused.
+  error ExpectedPause();
+  /// @notice Ownership renunciation is disabled to keep pause recovery available.
+  error OwnershipRenunciationDisabled();
+
+  EnumerableSet.AddressSet private _operators;
+  /// @notice Returns whether the contract is currently paused.
+  bool public paused;
+
+  /// @notice Emitted when `account` pauses the contract.
+  event Paused(address indexed account);
+  /// @notice Emitted when `account` unpauses the contract.
+  event Unpaused(address indexed account);
+  /// @notice Emitted when an operator permission is updated.
+  event OperatorSet(address indexed operator, bool allowed);
+
+  /// @notice Initializes the owner and optional initial pause operators.
+  /// @param owner_ The owner allowed to manage operators and unpause.
+  /// @param initialOperators The initial set of addresses allowed to pause.
+  constructor(address owner_, address[] memory initialOperators) Ownable(owner_) {
+    for (uint256 i; i < initialOperators.length; i++) {
+      _setOperator(initialOperators[i], true);
+    }
+  }
+
+  /// @notice Reverts when the contract is paused.
+  modifier whenNotPaused() {
+    if (paused) {
+      revert EnforcedPause();
+    }
+    _;
+  }
+
+  /// @notice Reverts when the contract is not paused.
+  modifier whenPaused() {
+    if (!paused) {
+      revert ExpectedPause();
+    }
+    _;
+  }
+
+  /// @notice Pauses the contract.
+  /// @dev Callable by the owner or an approved operator.
+  function pause() external whenNotPaused {
+    if (msg.sender != owner() && !_operators.contains(msg.sender)) {
+      revert UnauthorizedPauser(msg.sender);
+    }
+
+    paused = true;
+    emit Paused(msg.sender);
+  }
+
+  /// @notice Unpauses the contract.
+  /// @dev Callable only by the owner.
+  function unpause() external onlyOwner whenPaused {
+    paused = false;
+    emit Unpaused(msg.sender);
+  }
+
+  /// @notice Updates whether `operator` is allowed to pause.
+  /// @param operator The address to update.
+  /// @param allowed Whether the address may pause.
+  function setOperator(address operator, bool allowed) external onlyOwner {
+    _setOperator(operator, allowed);
+  }
+
+  /// @notice Returns whether `account` is allowed to pause.
+  function isOperator(address account) external view returns (bool) {
+    return _operators.contains(account);
+  }
+
+  /// @notice Returns the current pause operators in storage order.
+  /// @dev Ordering is not guaranteed and may change when operators are removed.
+  function getOperators() external view returns (address[] memory) {
+    return _operators.values();
+  }
+
+  /// @notice Disables ownership renunciation to avoid permanently locked pause state.
+  function renounceOwnership() public view override onlyOwner {
+    revert OwnershipRenunciationDisabled();
+  }
+
+  function _setOperator(address operator, bool allowed) private {
+    if (operator == address(0)) {
+      revert ZeroAddress();
+    }
+
+    if (allowed) {
+      _operators.add(operator);
+    } else {
+      _operators.remove(operator);
+    }
+
+    emit OperatorSet(operator, allowed);
+  }
+}

src/pausable/PausableSapient.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.27;
+
+import {Pausable} from "src/pausable/Pausable.sol";
+import {ISapientCompact} from "wallet-contracts-v3/modules/interfaces/ISapient.sol";
+
+/// @title PausableSapient
+/// @notice Compact sapient signer that returns a fixed image hash unless paused.
+/// @dev Reverts with `EnforcedPause` while paused.
+/// @dev Does not verify signatures; use co-signers with real verification at the nested tree level.
+contract PausableSapient is ISapientCompact, Pausable {
+  /// @notice Image hash returned while the signer is active.
+  bytes32 public constant UNPAUSED_IMAGE_HASH = bytes32(uint256(1));
+
+  /// @notice Initializes the pause controller.
+  /// @param owner_ The owner allowed to manage operators and unpause.
+  /// @param initialOperators The initial set of addresses allowed to pause.
+  constructor(address owner_, address[] memory initialOperators) Pausable(owner_, initialOperators) {}
+
+  /// @inheritdoc ISapientCompact
+  function recoverSapientSignatureCompact(bytes32, bytes calldata)
+    external
+    view
+    whenNotPaused
+    returns (bytes32 imageHash)
+  {
+    return UNPAUSED_IMAGE_HASH;
+  }
+}

test/Allowlist.t.sol

@@ -441,6 +441,29 @@ contract AllowlistTest is Test {
     assertEq(allowlist.getAllowed().length, 0);
   }
 
+  function testFuzz_renounceOwnership_revertsAndKeepsOwner(address owner_) external {
+    vm.assume(owner_ != address(0));
+
+    Allowlist allowlist = _newAllowlist(owner_);
+
+    vm.prank(owner_);
+    vm.expectRevert(Allowlist.OwnershipRenunciationDisabled.selector);
+    allowlist.renounceOwnership();
+
+    assertEq(allowlist.owner(), owner_);
+  }
+
+  function testFuzz_renounceOwnership_revertsForNonOwner(address owner_, address caller) external {
+    vm.assume(owner_ != address(0));
+    vm.assume(caller != owner_);
+
+    Allowlist allowlist = _newAllowlist(owner_);
+
+    vm.prank(caller);
+    vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, caller));
+    allowlist.renounceOwnership();
+  }
+
   function testFuzz_addRemoveAdd(address owner_, address addr) external {
     vm.assume(owner_ != address(0));
     vm.assume(addr != address(0));

test/MalleableSapient.t.sol

@@ -167,8 +167,9 @@ contract MalleableSapientTest is Test {
       });
     }
 
-    // Prevent overlap by requring separate tindex for each repeat section
+    // Prevent overlap by requiring separate tindex for each repeat section.
     uint256[] memory tindexWithRepeat = new uint256[](sections * 2);
+    uint256 repeatTindexCount;
 
     SignatureParts memory parts;
     bytes memory signature;
@@ -185,12 +186,14 @@ contract MalleableSapientTest is Test {
         parts.tindex2 = uint8(uint256(keccak256(abi.encodePacked(seed, "t2", i))) % callCount);
         // Prevent collision by checking tindex is not repeated
         vm.assume(parts.tindex != parts.tindex2);
-        for (uint256 j = 0; j < i * 2; j++) {
+        for (uint256 j = 0; j < repeatTindexCount; j++) {
           vm.assume(parts.tindex != tindexWithRepeat[j]);
           vm.assume(parts.tindex2 != tindexWithRepeat[j]);
         }
-        tindexWithRepeat[i] = parts.tindex;
-        tindexWithRepeat[i + 1] = parts.tindex2;
+        tindexWithRepeat[repeatTindexCount] = parts.tindex;
+        repeatTindexCount++;
+        tindexWithRepeat[repeatTindexCount] = parts.tindex2;
+        repeatTindexCount++;
 
         uint256 dataLen2 = payload.calls[parts.tindex2].data.length;
         // forge-lint: disable-next-line(unsafe-typecast)