Balancer pause helper

pkg/standalone-utils/contracts/PauseHelper.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import { IVault } from "@balancer-labs/v3-interfaces/contracts/vault/IVault.sol";
+import { IVaultAdmin } from "@balancer-labs/v3-interfaces/contracts/vault/IVaultAdmin.sol";
+import { SingletonAuthentication } from "@balancer-labs/v3-vault/contracts/SingletonAuthentication.sol";
+
+contract PauseHelper is SingletonAuthentication {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    event PoolAdded(address pool);
+    event PoolRemoved(address pool);
+
+    EnumerableSet.AddressSet private _poolsSet;
+
+    constructor(IVault vault) SingletonAuthentication(vault) {}
+
+    // --------------------------  Manage Pools --------------------------
+
+    /**
+     * @notice Add pools to the list of pools that can be paused
+     * @param newPools List of pools to add
+     */
+    function addPools(address[] calldata newPools) external authenticate {
+        uint256 length = newPools.length;
+
+        for (uint256 i = 0; i < length; i++) {
+            _poolsSet.add(newPools[i]);
+
+            emit PoolAdded(newPools[i]);
+        }
+    }
+
+    /**
+     * @notice Remove pools from the list of pools that can be paused
+     * @param pools List of pools to remove
+     */
+    function removePools(address[] memory pools) public authenticate {
+        uint256 length = pools.length;
+        for (uint256 i = 0; i < length; i++) {
+            _poolsSet.remove(pools[i]);
+
+            emit PoolRemoved(pools[i]);
+        }
+    }
+
+    /**
+     * @notice Pause pools
+     * @param pools List of pools to pause
+     */
+    function pause(address[] memory pools) public authenticate {
+        uint256 length = pools.length;
+        for (uint256 i = 0; i < length; i++) {
+            require(_poolsSet.contains(pools[i]), "Pool is not in the list of pools");
+
+            getVault().pausePool(pools[i]);
+        }
+    }
+
+    // --------------------------  Getters --------------------------
+    /**
+     * @notice Get the number of pools
+     * @return Number of pools
+     */
+    function getPoolsCount() external view returns (uint256) {
+        return _poolsSet.length();
+    }
+
+    /**
+     * @notice Check if a pool is in the list of pools
+     * @param pool Pool to check
+     * @return True if the pool is in the list, false otherwise
+     */
+    function hasPool(address pool) external view returns (bool) {
+        return _poolsSet.contains(pool);
+    }
+
+    /**
+     * @notice Get a range of pools
+     * @param from Start index
+     * @param to End index
+     * @return pools List of pools
+     */
+    function getPools(uint256 from, uint256 to) public view returns (address[] memory pools) {
+        uint256 poolLength = _poolsSet.length();
+        require(from <= to, "'From' must be less than 'to'");
+        require(to <= poolLength, "'To' must be less than or eq the number of pools");
+        require(from < poolLength, "'From' must be less than the number of pools");
+
+        pools = new address[](to - from);
+        for (uint256 i = from; i < to; i++) {
+            pools[i - from] = _poolsSet.at(i);
+        }
+    }
+}

pkg/standalone-utils/foundry.toml

@@ -19,7 +19,8 @@ remappings = [
     '@openzeppelin/=../../node_modules/@openzeppelin/',
     'permit2/=../../node_modules/permit2/',
     '@balancer-labs/=../../node_modules/@balancer-labs/',
-    'forge-gas-snapshot/=../../node_modules/forge-gas-snapshot/src/'
+    'forge-gas-snapshot/=../../node_modules/forge-gas-snapshot/src/',
+    '@safe-global/safe-contracts/=../../node_modules/@safe-global/safe-contracts/'
 ]
 optimizer = true
 optimizer_runs = 999

pkg/standalone-utils/test/foundry/PauseHelper.t.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { PoolMock } from "@balancer-labs/v3-vault/contracts/test/PoolMock.sol";
+import { PoolFactoryMock } from "@balancer-labs/v3-vault/contracts/test/PoolFactoryMock.sol";
+import { BaseVaultTest } from "@balancer-labs/v3-vault/test/foundry/utils/BaseVaultTest.sol";
+import { IAuthentication } from "@balancer-labs/v3-interfaces/contracts/solidity-utils/helpers/IAuthentication.sol";
+
+import { PauseHelper } from "../../contracts/PauseHelper.sol";
+
+contract PauseHelperTest is BaseVaultTest {
+    PauseHelper pauseHelper;
+
+    function setUp() public virtual override {
+        BaseVaultTest.setUp();
+
+        address[] memory owners = new address[](1);
+        owners[0] = address(this);
+
+        pauseHelper = new PauseHelper(vault);
+
+        authorizer.grantRole(pauseHelper.getActionId(pauseHelper.addPools.selector), address(this));
+        authorizer.grantRole(pauseHelper.getActionId(pauseHelper.removePools.selector), address(this));
+        authorizer.grantRole(pauseHelper.getActionId(pauseHelper.pause.selector), address(this));
+
+        authorizer.grantRole(vault.getActionId(vault.pausePool.selector), address(pauseHelper));
+    }
+
+    function testAddPoolsWithTwoBatches() public {
+        address[] memory firstPools = _addPools(10);
+        assertEq(pauseHelper.getPoolsCount(), firstPools.length, "Pools count should be 10");
+
+        address[] memory secondPools = _addPools(10);
+        assertEq(pauseHelper.getPoolsCount(), firstPools.length + secondPools.length, "Pools count should be 20");
+
+        for (uint256 i = 0; i < firstPools.length; i++) {
+            assertTrue(pauseHelper.hasPool(firstPools[i]));
+        }
+
+        for (uint256 i = 0; i < secondPools.length; i++) {
+            assertTrue(pauseHelper.hasPool(secondPools[i]));
+        }
+    }
+
+    function testAddPoolWithoutPermission() public {
+        authorizer.revokeRole(pauseHelper.getActionId(pauseHelper.addPools.selector), address(this));
+
+        vm.expectRevert(IAuthentication.SenderNotAllowed.selector);
+        pauseHelper.addPools(new address[](0));
+    }
+
+    function testRemovePools() public {
+        address[] memory pools = _addPools(10);
+        assertEq(pauseHelper.getPoolsCount(), 10, "Pools count should be 10");
+
+        for (uint256 i = 0; i < pools.length; i++) {
+            vm.expectEmit();
+            emit PauseHelper.PoolRemoved(pools[i]);
+        }
+
+        pauseHelper.removePools(pools);
+
+        assertEq(pauseHelper.getPoolsCount(), 0, "Pools count should be 0");
+
+        for (uint256 i = 0; i < pools.length; i++) {
+            assertFalse(pauseHelper.hasPool(pools[i]));
+        }
+    }
+
+    function testRemovePoolWithoutPermission() public {
+        address[] memory pools = _addPools(10);
+
+        authorizer.revokeRole(pauseHelper.getActionId(pauseHelper.removePools.selector), address(this));
+
+        vm.expectRevert(IAuthentication.SenderNotAllowed.selector);
+        pauseHelper.removePools(pools);
+    }
+
+    function testPause() public {
+        address[] memory pools = _addPools(10);
+
+        pauseHelper.pause(pools);
+
+        for (uint256 i = 0; i < pools.length; i++) {
+            assertTrue(vault.isPoolPaused(pools[i]), "Pool should be paused");
+        }
+    }
+
+    function testPauseWithoutPermission() public {
+        address[] memory pools = _addPools(10);
+
+        authorizer.revokeRole(pauseHelper.getActionId(pauseHelper.pause.selector), address(this));
+
+        vm.expectRevert(IAuthentication.SenderNotAllowed.selector);
+        pauseHelper.pause(pools);
+    }
+
+    function testPauseIfPoolIsNotInList() public {
+        _addPools(10);
+
+        vm.expectRevert("Pool is not in the list of pools");
+        pauseHelper.pause(new address[](1));
+    }
+
+    function testGetPools() public {
+        address[] memory pools = _addPools(10);
+        address[] memory storedPools = pauseHelper.getPools(0, 10);
+
+        for (uint256 i = 0; i < pools.length; i++) {
+            assertEq(pools[i], storedPools[i], "Stored pool should be the same as the added pool");
+        }
+    }
+
+    function _addPools(uint256 length) internal returns (address[] memory pools) {
+        pools = new address[](length);
+        for (uint256 i = 0; i < length; i++) {
+            pools[i] = PoolFactoryMock(poolFactory).createPool("Test", "TEST");
+            PoolFactoryMock(poolFactory).registerTestPool(
+                pools[i],
+                vault.buildTokenConfig(tokens),
+                poolHooksContract,
+                lp
+            );
+        }
+
+        for (uint256 i = 0; i < pools.length; i++) {
+            vm.expectEmit();
+            emit PauseHelper.PoolAdded(pools[i]);
+        }
+
+        pauseHelper.addPools(pools);
+    }
+}