ProtocolFeeSplitter factory default

pkg/interfaces/contracts/standalone-utils/IProtocolFeeSplitter.sol

@@ -38,6 +38,8 @@ interface IProtocolFeeSplitter {
     event PoolRevenueShareCleared(bytes32 indexed poolId);
     event PoolBeneficiaryChanged(bytes32 indexed poolId, address newBeneficiary);
     event DefaultRevenueSharePercentageChanged(uint256 revenueSharePercentage);
+    event FactoryDefaultRevenueSharePercentageChanged(address indexed factory, uint256 revenueSharePercentage);
+    event FactoryDefaultRevenueSharePercentageCleared(address indexed factory);
     event DAOFundsRecipientChanged(address newDaoFundsRecipient);
 
     // Fund recipients
@@ -95,10 +97,28 @@ interface IProtocolFeeSplitter {
     function setDefaultRevenueSharePercentage(uint256 defaultRevenueSharePercentage) external;
 
     /**
-     * @notice Allows an authorized user to change the revenueShare for a given pool.
-     * @dev This is a permissioned function.
-     * @param poolId - the poolId of the pool where the revenue share will change.
-     * @param revenueSharePercentage - the new revenue share percentage.
+     * @notice Returns the revenue share associated with the given factory
+     * @dev Reverts if no revenue share was set for this factory
+     * @param factory - the address of the factory with a default revenue share percentage
+     */
+    function getFactoryDefaultRevenueSharePercentage(address factory) external view returns (uint256);
+
+    /**
+     * @notice Allows a authorized user to change the default revenue sharing fee percentage for a given factory
+     * @param factory - address of the factory
+     * @param feePercentage - new default revenue sharing fee percentage
+     */
+    function setFactoryDefaultRevenueSharePercentage(address factory, uint256 feePercentage) external;
+
+    /**
+     * @notice Allows a authorized user to remove a default revenue sharing fee override for a given factory
+     * @param factory - address of the factory
+     */
+    function clearFactoryDefaultRevenueSharePercentage(address factory) external;
+
+    /**
+     * @notice Ignore any previously set revenue sharing percentage, and begin using the default.
+     * @param poolId - the poolId of the pool to begin using the default revenue share percentage.
      */
     function setRevenueSharePercentage(bytes32 poolId, uint256 revenueSharePercentage) external;
 

pkg/standalone-utils/contracts/ProtocolFeeSplitter.sol

@@ -17,14 +17,19 @@ pragma solidity >=0.7.0 <0.9.0;
 import "@balancer-labs/v2-interfaces/contracts/standalone-utils/IProtocolFeeSplitter.sol";
 import "@balancer-labs/v2-interfaces/contracts/standalone-utils/IProtocolFeesWithdrawer.sol";
 import "@balancer-labs/v2-interfaces/contracts/vault/IVault.sol";
+
 import "@balancer-labs/v2-solidity-utils/contracts/helpers/SingletonAuthentication.sol";
+import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableMap.sol";
 import "@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol";
-import "@balancer-labs/v2-interfaces/contracts/vault/IProtocolFeesCollector.sol";
 
 interface Pool {
     function getOwner() external view returns (address);
 }
 
+interface Factory {
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+
 /**
  * @notice Support revenue sharing for individual pools between the DAO and designated recipients.
  * @dev This contract is responsible for splitting the BPT profits collected by the ProtocolFeeCollector between
@@ -36,8 +41,11 @@ interface Pool {
  * token were on this denyList.
  */
 contract ProtocolFeeSplitter is IProtocolFeeSplitter, SingletonAuthentication {
+    using EnumerableMap for EnumerableMap.IERC20ToUint256Map;
     using FixedPoint for uint256;
 
+    string private constant _UNDEFINED_FACTORY_SHARE = "Share undefined for this factory";
+
     // All fee percentages are 18-decimal fixed point numbers.
     // Absolute maximum fee percentage (1e18 = 100%).
     uint256 private constant _MAX_REVENUE_SHARE_PERCENTAGE = 50e16; // 50%
@@ -50,6 +58,11 @@ contract ProtocolFeeSplitter is IProtocolFeeSplitter, SingletonAuthentication {
     // The default revenue share given to pools; can be updated by governance (1e18 = 100%, 1e16 = 1%).
     uint256 private _defaultRevenueSharePercentage;
 
+    // Allow the default revenue sharing fee percentage to be overridden for individual factories.
+    EnumerableMap.IERC20ToUint256Map private _revenueShareFactoryOverrides;
+
+    // By default, the `overrideSet` flag is false, and all Pools use the default revenue share percentage.
+
     // Packed to use 1 storage slot
     // 1e18 (100% - maximum fee value) can fit in uint88
     struct RevenueShareSettings {
@@ -75,6 +88,23 @@ contract ProtocolFeeSplitter is IProtocolFeeSplitter, SingletonAuthentication {
         return _daoFundsRecipient;
     }
 
+    function setFactoryDefaultRevenueSharePercentage(address factory, uint256 feePercentage)
+        external
+        override
+        authenticate
+    {
+        _require(feePercentage <= _MAX_REVENUE_SHARE_PERCENTAGE, Errors.SPLITTER_FEE_PERCENTAGE_TOO_HIGH);
+        _revenueShareFactoryOverrides.set(IERC20(factory), feePercentage);
+
+        emit FactoryDefaultRevenueSharePercentageChanged(factory, feePercentage);
+    }
+
+    function clearFactoryDefaultRevenueSharePercentage(address factory) external override authenticate {
+        require(_revenueShareFactoryOverrides.remove(IERC20(factory)), _UNDEFINED_FACTORY_SHARE);
+
+        emit FactoryDefaultRevenueSharePercentageCleared(factory);
+    }
+
     /// @inheritdoc IProtocolFeeSplitter
     function setDaoFundsRecipient(address newDaoFundsRecipient) external override authenticate {
         _daoFundsRecipient = newDaoFundsRecipient;
@@ -182,6 +212,13 @@ contract ProtocolFeeSplitter is IProtocolFeeSplitter, SingletonAuthentication {
 
     // Internal functions
 
+    function getFactoryDefaultRevenueSharePercentage(address factory) external view override returns (uint256) {
+        require(_revenueShareFactoryOverrides.contains(IERC20(factory)), _UNDEFINED_FACTORY_SHARE);
+
+        // We have checked about that the key exists, so `get` should not revert.
+        return _revenueShareFactoryOverrides.get(IERC20(factory), Errors.SHOULD_NOT_HAPPEN);
+    }
+
     function _withdrawBpt(
         IERC20 bpt,
         uint256 amount,
@@ -231,6 +268,24 @@ contract ProtocolFeeSplitter is IProtocolFeeSplitter, SingletonAuthentication {
     function _getPoolBeneficiaryFeePercentage(bytes32 poolId) private view returns (uint256) {
         RevenueShareSettings memory settings = _poolSettings[poolId];
 
-        return settings.overrideSet ? settings.revenueSharePercentageOverride : _defaultRevenueSharePercentage;
+        if (settings.overrideSet) {
+            // If there is an override for this specific pool, use it.
+            return settings.revenueSharePercentageOverride;
+        }
+
+        // Is this pool from a factory with an overridden default? If so, use it.
+        (address poolAddress, ) = getVault().getPool(poolId);
+
+        for (uint256 i = 0; i < _revenueShareFactoryOverrides.length(); i++) {
+            (IERC20 factoryAddress, uint256 factoryDefaultRevenueSharePercentage) = _revenueShareFactoryOverrides
+                .unchecked_at(i);
+
+            if (Factory(address(factoryAddress)).isPoolFromFactory(poolAddress)) {
+                return factoryDefaultRevenueSharePercentage;
+            }
+        }
+
+        // If there is no override set, and no factory override, fall back to the overall default.
+        return _defaultRevenueSharePercentage;
     }
 }