feat: update MultiPause contract (#32)

Compared to the previous implementation:
- works with new governance framework
- actually pauses all contracts in a suite instead of just pools/facades
- removed `unpause...` functions as they were meaningless
- added metadata to be compatible with BCR

Author: lekhovitsky

contracts/emergency/MultiPause.sol

@@ -1,105 +1,120 @@
 // SPDX-License-Identifier: BUSL-1.1
 // Gearbox Protocol. Generalized leverage for DeFi protocols
-// (c) Gearbox Foundation, 2024.
-pragma solidity ^0.8.17;
+// (c) Gearbox Foundation, 2025.
+pragma solidity ^0.8.23;
 
-import {ICreditManagerV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
-import {IContractsRegister} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegister.sol";
+import {IStateSerializer} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IStateSerializer.sol";
+import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
 import {ACLTrait} from "@gearbox-protocol/core-v3/contracts/traits/ACLTrait.sol";
 import {ContractsRegisterTrait} from "@gearbox-protocol/core-v3/contracts/traits/ContractsRegisterTrait.sol";
-import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
 
-enum PausableAction {
-    Pause,
-    Unpause
-}
-
-interface PausableContract {
-    /// @notice Pauses contract, can only be called by an account with pausable admin role
-    /// @dev Reverts if contract is already paused
-    function pause() external;
+import {IContractsRegister} from "@gearbox-protocol/permissionless/contracts/interfaces/IContractsRegister.sol";
+import {IMarketConfigurator} from "@gearbox-protocol/permissionless/contracts/interfaces/IMarketConfigurator.sol";
+import {MarketFactories} from "@gearbox-protocol/permissionless/contracts/interfaces/Types.sol";
 
-    /// @notice Unpauses contract, can only be called by an account with unpausable admin role
-    /// @dev Reverts if contract is already unpaused
-    function unpause() external;
-}
+import {IPausable} from "../interfaces/IPausable.sol";
 
 /// @title MultiPause
 /// @author Gearbox Foundation
-/// @notice Allows pausable admins to pause multiple contracts in a single transaction
-/// @dev This contract is expected to be one of pausable admins in the ACL contract
-contract MultiPause is ACLTrait, ContractsRegisterTrait {
-    constructor(address acl_, address contractsRegister_) ACLTrait(acl_) ContractsRegisterTrait(contractsRegister_) {}
+/// @notice Allows pausable admins to pause multiple contracts via single call.
+///         This contract itself is expected to have the `PAUSABLE_ADMIN` role in the ACL contract.
+contract MultiPause is IVersion, IStateSerializer, ACLTrait, ContractsRegisterTrait {
+    /// @notice Contract type
+    bytes32 public constant override contractType = "MULTI_PAUSE";
+
+    /// @notice Contract version
+    uint256 public constant override version = 3_10;
+
+    /// @notice Market configurator address
+    address public immutable marketConfigurator;
+
+    /// @notice Constructor
+    /// @param marketConfigurator_ Market configurator address
+    constructor(address marketConfigurator_)
+        ACLTrait(IMarketConfigurator(marketConfigurator_).acl())
+        ContractsRegisterTrait(IMarketConfigurator(marketConfigurator_).contractsRegister())
+    {
+        marketConfigurator = marketConfigurator_;
+    }
+
+    /// @notice Empty state serialization
+    function serialize() external pure override returns (bytes memory) {}
 
-    /// @notice Pauses contracts from the given list
-    /// @dev Ignores contracts that are already paused
+    /// @notice Pauses given contracts
     /// @dev Reverts if caller is not a pausable admin
-    function pauseContracts(address[] memory contracts) external pausableAdminsOnly {
-        _pauseContracts(contracts, PausableAction.Pause);
+    function pauseContracts(address[] calldata contracts) external pausableAdminsOnly {
+        uint256 numContracts = contracts.length;
+        for (uint256 i; i < numContracts; ++i) {
+            _pause(contracts[i]);
+        }
     }
 
-    /// @notice Pauses all registered pools
-    /// @dev Ignores contracts that are already paused
+    /// @notice Pauses all contracts within all registered markets and credit suites
     /// @dev Reverts if caller is not a pausable admin
-    function pauseAllPools() external pausableAdminsOnly {
-        _pauseAllPools(PausableAction.Pause);
+    function pauseAllContracts() external pausableAdminsOnly {
+        address[] memory pools = IContractsRegister(contractsRegister).getPools();
+        uint256 numPools = pools.length;
+        for (uint256 i; i < numPools; ++i) {
+            _pauseMarket(pools[i]);
+        }
     }
 
-    /// @notice Pauses all registered credit managers
-    /// @dev For V3, credit facades are paused instead
-    /// @dev Ignores contracts that are already paused
+    /// @notice Pauses all contracts within a given market and connected credit suites
     /// @dev Reverts if caller is not a pausable admin
-    function pauseAllCreditManagers() external pausableAdminsOnly {
-        _pauseAllCreditManagers(PausableAction.Pause);
+    /// @dev Reverts if `pool` is not registered
+    function pauseMarket(address pool) external pausableAdminsOnly registeredPoolOnly(pool) {
+        _pauseMarket(pool);
     }
 
-    /// @notice Pauses all registered credit managers and pools
-    /// @dev Ignores contracts that are already paused
+    /// @notice Pauses all contracts within a given credit suite
     /// @dev Reverts if caller is not a pausable admin
-    function pauseAllContracts() external pausableAdminsOnly {
-        _pauseAllPools(PausableAction.Pause);
-        _pauseAllCreditManagers(PausableAction.Pause);
+    /// @dev Reverts if `creditManager` is not registered
+    function pauseCreditSuite(address creditManager)
+        external
+        pausableAdminsOnly
+        registeredCreditManagerOnly(creditManager)
+    {
+        _pauseCreditSuite(creditManager);
     }
 
-    /// @notice Unpauses all registered credit managers and pools
-    /// @dev Ignores contracts that aren't paused
-    /// @dev Reverts if caller is not a unpausable admin
-    function unpauseAllContracts() external unpausableAdminsOnly {
-        _pauseAllPools(PausableAction.Unpause);
-        _pauseAllCreditManagers(PausableAction.Unpause);
+    // --------- //
+    // INTERNALS //
+    // --------- //
+
+    /// @dev Pauses all contracts within a given market and connected credit suites
+    function _pauseMarket(address pool) internal {
+        MarketFactories memory factories = IMarketConfigurator(marketConfigurator).getMarketFactories(pool);
+        _pauseFactoryTargets(factories.poolFactory, pool);
+        _pauseFactoryTargets(factories.priceOracleFactory, pool);
+        _pauseFactoryTargets(factories.interestRateModelFactory, pool);
+        _pauseFactoryTargets(factories.rateKeeperFactory, pool);
+        _pauseFactoryTargets(factories.lossPolicyFactory, pool);
+        address[] memory creditManagers = IContractsRegister(contractsRegister).getCreditManagers(pool);
+        uint256 numCreditManagers = creditManagers.length;
+        for (uint256 i; i < numCreditManagers; ++i) {
+            _pauseCreditSuite(creditManagers[i]);
+        }
     }
 
-    /// @dev Internal function to pause all pools
-    function _pauseAllPools(PausableAction action) internal {
-        _pauseContracts(IContractsRegister(contractsRegister).getPools(), action);
+    /// @dev Pauses all contracts within a given credit suite
+    function _pauseCreditSuite(address creditManager) internal {
+        address factory = IMarketConfigurator(marketConfigurator).getCreditFactory(creditManager);
+        _pauseFactoryTargets(factory, creditManager);
     }
 
-    /// @dev Internal function to pause all credit managers
-    function _pauseAllCreditManagers(PausableAction action) internal {
-        address[] memory contracts = IContractsRegister(contractsRegister).getCreditManagers();
-        uint256 len = contracts.length;
-        unchecked {
-            for (uint256 i; i < len; ++i) {
-                if (ICreditManagerV3(contracts[i]).version() < 3_00) continue;
-                contracts[i] = ICreditManagerV3(contracts[i]).creditFacade();
-            }
+    /// @dev Pauses all contracts configurable by `factory` in a given market or credit `suite`
+    function _pauseFactoryTargets(address factory, address suite) internal {
+        address[] memory targets = IMarketConfigurator(marketConfigurator).getFactoryTargets(factory, suite);
+        uint256 numTargets = targets.length;
+        for (uint256 i; i < numTargets; ++i) {
+            _pause(targets[i]);
         }
-        _pauseContracts(contracts, action);
     }
 
-    /// @dev Internal function to pause/unpause contracts from the given list
-    function _pauseContracts(address[] memory contracts, PausableAction action) internal {
-        uint256 len = contracts.length;
-        unchecked {
-            for (uint256 i; i < len; ++i) {
-                if (action == PausableAction.Pause) {
-                    if (Pausable(contracts[i]).paused()) continue;
-                    PausableContract(contracts[i]).pause();
-                } else {
-                    if (!Pausable(contracts[i]).paused()) continue;
-                    PausableContract(contracts[i]).unpause();
-                }
-            }
-        }
+    /// @dev Pauses `target` if it's pausable and not already paused
+    function _pause(address target) internal {
+        try IPausable(target).paused() returns (bool paused) {
+            if (!paused) try IPausable(target).pause{gas: 30_000}() {} catch {}
+        } catch {}
     }
 }

contracts/interfaces/IPausable.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2025.
+pragma solidity ^0.8.23;
+
+/// @title Pausable interface
+/// @notice Generic interface of a contract that can be paused and unpaused
+interface IPausable {
+    function paused() external view returns (bool);
+    function pause() external;
+    function unpause() external;
+}