Add helper to set protocol fees by factory

pkg/interfaces/contracts/vault/IProtocolFeeController.sol

@@ -94,6 +94,13 @@ interface IProtocolFeeController {
     /// @dev Returns the main Vault address.
     function vault() external view returns (IVault);
 
+    /**
+     * @dev Return the maximum swap and yield protocol fee percentages.
+     * @return maxProtocolSwapFeePercentage The maximum protocol swap fee percentage
+     * @return maxProtocolYieldFeePercentage The maximum protocol yield fee percentage
+     */
+    function getMaximumProtocolFeePercentages() external pure returns (uint256, uint256);
+
     /// @dev Collects aggregate fees from the Vault for a given pool.
     function collectAggregateFees(address pool) external;
 

pkg/interfaces/contracts/vault/IProtocolFeePercentagesProvider.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { IProtocolFeeController } from "./IProtocolFeeController.sol";
+
+interface IProtocolFeePercentagesProvider {
+    /**
+     * @notice `setFactorySpecificProtocolFeePercentages` has not been called for this factory address.
+     * @dev This error can by thrown by `getFactorySpecificProtocolFeePercentages` or
+     * `setProtocolFeePercentagesForPools`, as both require that valid fee percentages have been set.
+     *
+     * @param factory The unregistered factory address
+     */
+    error FactoryNotRegistered(address factory);
+
+    /**
+     * @notice The factory address provided is not a valid `IBasePoolFactory`.
+     * @dev This means it responds incorrectly to `isPoolFromFactory` (e.g., always responds true). If it doesn't
+     * implement `isPoolFromFactory` or isn't a contract at all, calls on `setFactorySpecificProtocolFeePercentages`
+     * will revert with no data.
+     *
+     * @param factory The address of the invalid factory
+     */
+    error InvalidFactory(address factory);
+
+    /**
+     * @notice The given pool is not from the expected factory.
+     * @dev Occurs when one of the pools supplied to `setProtocolFeePercentagesForPools` is not from the given factory.
+     * @param pool The address of the unrecognized pool
+     * @param factory The address of the factory
+     */
+    error PoolNotFromFactory(address pool, address factory);
+
+    /**
+     * @notice Get the address of the `ProtocolFeeController` used to set fees.
+     * @return protocolFeeController The address of the fee controller
+     */
+    function getProtocolFeeController() external view returns (IProtocolFeeController);
+
+    /**
+     * @notice Query the protocol fee percentages for a given factory.
+     * @param factory The address of the factory
+     * @return protocolSwapFeePercentage The protocol swap fee percentage set for that factory
+     * @return protocolYieldFeePercentage The protocol yield fee percentage set for that factory
+     */
+    function getFactorySpecificProtocolFeePercentages(
+        address factory
+    ) external view returns (uint256 protocolSwapFeePercentage, uint256 protocolYieldFeePercentage);
+
+    /**
+     * @notice Assign intended protocol fee percentages for a given factory.
+     * @dev This is a permissioned call. After the fee percentages have been set, and governance has granted
+     * this contract permission to set fee percentages on pools, anyone can call `setProtocolFeePercentagesForPools`
+     * to update the fee percentages on a set of pools from that factory.
+     *
+     * @param factory The address of the factory
+     * @param protocolSwapFeePercentage The new protocol swap fee percentage
+     * @param protocolYieldFeePercentage The new protocol yield fee percentage
+     */
+    function setFactorySpecificProtocolFeePercentages(
+        address factory,
+        uint256 protocolSwapFeePercentage,
+        uint256 protocolYieldFeePercentage
+    ) external;
+
+    /**
+     * @notice Update the protocol fees for a set of pools from a given factory.
+     * @dev This call is permissionless. Anyone can update the fee percentages, once they're set by governance.
+     * Note that goverance must also grant this contract permmission to set protocol fee percentages on pools.
+     *
+     * @param factory The address of the factory
+     * @param pools The pools whose fees will be set according to `setFactorySpecificProtocolFeePercentages`
+     */
+    function setProtocolFeePercentagesForPools(address factory, address[] memory pools) external;
+}

pkg/vault/contracts/ProtocolFeeController.sol

@@ -82,6 +82,8 @@ contract ProtocolFeeController is
         bool isOverride;
     }
 
+    // Note that the `ProtocolFeePercentagesProvider` assumes the maximum fee bounds are constant.
+
     // Maximum protocol swap fee percentage. FixedPoint.ONE corresponds to a 100% fee.
     uint256 internal constant _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE = 50e16; // 50%
 
@@ -161,6 +163,11 @@ contract ProtocolFeeController is
         return _vault;
     }
 
+    /// @inheritdoc IProtocolFeeController
+    function getMaximumProtocolFeePercentages() external pure returns (uint256, uint256) {
+        return (_MAX_PROTOCOL_SWAP_FEE_PERCENTAGE, _MAX_PROTOCOL_YIELD_FEE_PERCENTAGE);
+    }
+
     /// @inheritdoc IProtocolFeeController
     function collectAggregateFees(address pool) public {
         _vault.unlock(abi.encodeWithSelector(ProtocolFeeController.collectAggregateFeesHook.selector, pool));

pkg/vault/contracts/ProtocolFeePercentagesProvider.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.24;
+
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+import {
+    IProtocolFeePercentagesProvider
+} from "@balancer-labs/v3-interfaces/contracts/vault/IProtocolFeePercentagesProvider.sol";
+import { IProtocolFeeController } from "@balancer-labs/v3-interfaces/contracts/vault/IProtocolFeeController.sol";
+import { IBasePoolFactory } from "@balancer-labs/v3-interfaces/contracts/vault/IBasePoolFactory.sol";
+import { IVault } from "@balancer-labs/v3-interfaces/contracts/vault/IVault.sol";
+
+import {
+    SingletonAuthentication
+} from "@balancer-labs/v3-solidity-utils/contracts/helpers/SingletonAuthentication.sol";
+
+contract ProtocolFeePercentagesProvider is IProtocolFeePercentagesProvider, SingletonAuthentication {
+    using SafeCast for uint256;
+
+    /// @notice The protocol fee controller was configured with an incorrect Vault address.
+    error WrongProtocolFeeControllerDeployment();
+
+    /**
+     * @dev Data structure to store default protocol fees by factory. Fee percentages are 18-decimal floating point
+     * numbers, so we know they fit in 64 bits, allowing the fees to be stored in a single slot.
+     *
+     * @param protocolSwapFee The protocol swap fee
+     * @param protocolYieldFee The protocol yield fee
+     * @param isFactoryRegistered Flag indicating fees have been set (allows zero values)
+     */
+    struct FactoryProtocolFees {
+        uint64 protocolSwapFeePercentage;
+        uint64 protocolYieldFeePercentage;
+        bool isFactoryRegistered;
+    }
+
+    IProtocolFeeController private immutable _protocolFeeController;
+
+    uint256 private immutable _maxProtocolSwapFeePercentage;
+    uint256 private immutable _maxProtocolYieldFeePercentage;
+
+    // Factory address => FactoryProtocolFees
+    mapping(IBasePoolFactory => FactoryProtocolFees) private _factoryDefaultFeePercentages;
+
+    constructor(IVault vault, IProtocolFeeController protocolFeeController) SingletonAuthentication(vault) {
+        _protocolFeeController = protocolFeeController;
+
+        if (protocolFeeController.vault() != vault) {
+            revert WrongProtocolFeeControllerDeployment();
+        }
+
+        // These values are constant in the `ProtocolFeeController`.
+        (_maxProtocolSwapFeePercentage, _maxProtocolYieldFeePercentage) = protocolFeeController
+            .getMaximumProtocolFeePercentages();
+    }
+
+    /// @inheritdoc IProtocolFeePercentagesProvider
+    function getProtocolFeeController() external view returns (IProtocolFeeController) {
+        return _protocolFeeController;
+    }
+
+    /// @inheritdoc IProtocolFeePercentagesProvider
+    function getFactorySpecificProtocolFeePercentages(
+        address factory
+    ) external view returns (uint256 protocolSwapFeePercentage, uint256 protocolYieldFeePercentage) {
+        FactoryProtocolFees memory factoryFees = _getValidatedProtocolFees(factory);
+
+        protocolSwapFeePercentage = factoryFees.protocolSwapFeePercentage;
+        protocolYieldFeePercentage = factoryFees.protocolYieldFeePercentage;
+    }
+
+    /// @inheritdoc IProtocolFeePercentagesProvider
+    function setFactorySpecificProtocolFeePercentages(
+        address factory,
+        uint256 protocolSwapFeePercentage,
+        uint256 protocolYieldFeePercentage
+    ) external authenticate {
+        // Validate the fee percentages; don't store values that the `ProtocolFeeCollector` will reject.
+        if (protocolSwapFeePercentage > _maxProtocolSwapFeePercentage) {
+            revert IProtocolFeeController.ProtocolSwapFeePercentageTooHigh();
+        }
+
+        if (protocolYieldFeePercentage > _maxProtocolYieldFeePercentage) {
+            revert IProtocolFeeController.ProtocolYieldFeePercentageTooHigh();
+        }
+
+        // Best effort check that `factory` is the address of an IBasePoolFactory.
+        bool poolFromFactory = IBasePoolFactory(factory).isPoolFromFactory(address(0));
+        if (poolFromFactory) {
+            revert InvalidFactory(factory);
+        }
+
+        // Store the default fee percentages, and mark the factory as registered.
+        _factoryDefaultFeePercentages[IBasePoolFactory(factory)] = FactoryProtocolFees({
+            protocolSwapFeePercentage: protocolSwapFeePercentage.toUint64(),
+            protocolYieldFeePercentage: protocolYieldFeePercentage.toUint64(),
+            isFactoryRegistered: true
+        });
+    }
+
+    /// @inheritdoc IProtocolFeePercentagesProvider
+    function setProtocolFeePercentagesForPools(address factory, address[] memory pools) external {
+        FactoryProtocolFees memory factoryFees = _getValidatedProtocolFees(factory);
+
+        for (uint256 i = 0; i < pools.length; ++i) {
+            address currentPool = pools[i];
+
+            if (IBasePoolFactory(factory).isPoolFromFactory(currentPool) == false) {
+                revert PoolNotFromFactory(currentPool, factory);
+            }
+
+            _setPoolProtocolFees(
+                currentPool,
+                factoryFees.protocolSwapFeePercentage,
+                factoryFees.protocolYieldFeePercentage
+            );
+        }
+    }
+
+    function _getValidatedProtocolFees(address factory) private view returns (FactoryProtocolFees memory factoryFees) {
+        factoryFees = _factoryDefaultFeePercentages[IBasePoolFactory(factory)];
+
+        if (factoryFees.isFactoryRegistered == false) {
+            revert FactoryNotRegistered(factory);
+        }
+    }
+
+    // These are permissioned functions on `ProtocolFeeController`, so governance will need to allow this contract
+    // to call `setProtocolSwapFeePercentage` and `setProtocolYieldFeePercentage`.
+    function _setPoolProtocolFees(
+        address pool,
+        uint256 protocolSwapFeePercentage,
+        uint256 protocolYieldFeePercentage
+    ) private {
+        _protocolFeeController.setProtocolSwapFeePercentage(pool, protocolSwapFeePercentage);
+        _protocolFeeController.setProtocolYieldFeePercentage(pool, protocolYieldFeePercentage);
+    }
+}

pkg/vault/contracts/test/PoolFactoryMock.sol

@@ -169,6 +169,10 @@ contract PoolFactoryMock is IBasePoolFactory, SingletonAuthentication, FactoryWi
         );
     }
 
+    function manualSetPoolFromFactory(address pool) external {
+        _isPoolFromFactory[pool] = true;
+    }
+
     function _getDefaultLiquidityManagement() private pure returns (LiquidityManagement memory) {
         LiquidityManagement memory liquidityManagement;
         liquidityManagement.enableAddLiquidityCustom = true;

pkg/vault/test/foundry/ProtocolFeeController.t.sol

@@ -74,6 +74,14 @@ contract ProtocolFeeControllerTest is BaseVaultTest {
         assertEq(feeAmounts[1], 0, "Collected creator fee amount [1] is non-zero");
     }
 
+    function testGetMaximumProtocolFeePercentages() public view {
+        (uint256 maxSwapFeePercentage, uint256 maxYieldFeePercentage) = feeController
+            .getMaximumProtocolFeePercentages();
+
+        assertEq(maxSwapFeePercentage, MAX_PROTOCOL_SWAP_FEE_PCT, "Wrong maximum swap fee percentage");
+        assertEq(maxYieldFeePercentage, MAX_PROTOCOL_YIELD_FEE_PCT, "Wrong maximum yield fee percentage");
+    }
+
     function testSetGlobalProtocolSwapFeePercentageRange() public {
         authorizer.grantRole(
             feeControllerAuth.getActionId(IProtocolFeeController.setGlobalProtocolSwapFeePercentage.selector),