simplify protocol fees

Author: hoytech

remappings.txt

@@ -5,4 +5,3 @@ ethereum-vault-connector/=lib/ethereum-vault-connector/src/
 evk-test/=lib/euler-vault-kit/test/
 permit2/=lib/euler-vault-kit/lib/permit2/
 @uniswap/v4-core/=lib/v4-periphery/lib/v4-core/
-solmate/=lib/v4-periphery/lib/v4-core/lib/solmate/src

script/DeployProtocol.s.sol

@@ -6,6 +6,7 @@ import {EulerSwapFactory} from "../src/EulerSwapFactory.sol";
 import {EulerSwapRegistry} from "../src/EulerSwapRegistry.sol";
 import {EulerSwapPeriphery} from "../src/EulerSwapPeriphery.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {EulerSwapProtocolFeeConfig} from "../src/EulerSwapProtocolFeeConfig.sol";
 import {EulerSwap} from "../src/EulerSwap.sol";
 import {EulerSwapManagement} from "../src/EulerSwapManagement.sol";
 
@@ -22,16 +23,17 @@ contract DeployProtocol is ScriptUtil {
 
         address evc = vm.parseJsonAddress(json, ".evc");
         address poolManager = vm.parseJsonAddress(json, ".poolManager");
-        address feeOwner = vm.parseJsonAddress(json, ".feeOwner");
-        address feeRecipientSetter = vm.parseJsonAddress(json, ".feeRecipientSetter");
+        address protocolFeeAdmin = vm.parseJsonAddress(json, ".protocolFeeAdmin");
         address validVaultPerspective = vm.parseJsonAddress(json, ".validVaultPerspective");
         address curator = vm.parseJsonAddress(json, ".curator");
 
         vm.startBroadcast(deployerAddress);
 
+        address eulerSwapProtocolFeeConfig = address(new EulerSwapProtocolFeeConfig(evc, protocolFeeAdmin));
         address eulerSwapManagementImpl = address(new EulerSwapManagement(evc));
-        address eulerSwapImpl = address(new EulerSwap(evc, poolManager, eulerSwapManagementImpl));
-        address eulerSwapFactory = address(new EulerSwapFactory(evc, eulerSwapImpl, feeOwner, feeRecipientSetter));
+        address eulerSwapImpl =
+            address(new EulerSwap(evc, eulerSwapProtocolFeeConfig, poolManager, eulerSwapManagementImpl));
+        address eulerSwapFactory = address(new EulerSwapFactory(evc, eulerSwapImpl));
         new EulerSwapRegistry(evc, eulerSwapFactory, validVaultPerspective, curator);
         new EulerSwapPeriphery();
         vm.stopBroadcast();

script/json/DeployProtocol_input.json

@@ -1,8 +1,7 @@
 {
     "evc": "0x5301c7dD20bD945D2013b48ed0DEE3A284ca8989",
     "poolManager": "0x498581fF718922c3f8e6A244956aF099B2652b2b",
-    "feeOwner": "0x33C71422B3E20ef2472Bc9aa9252220CAeAF207e",
-    "feeRecipientSetter": "0x33C71422B3E20ef2472Bc9aa9252220CAeAF207e",
+    "protocolFeeAdmin": "0x33C71422B3E20ef2472Bc9aa9252220CAeAF207e",
     "validVaultPerspective": "0xFEA8e8a4d7ab8C517c3790E49E92ED7E1166F651",
     "curator": "0x33C71422B3E20ef2472Bc9aa9252220CAeAF207e"
 }

src/EulerSwap.sol

@@ -23,7 +23,9 @@ contract EulerSwap is IEulerSwap, UniswapHook {
     /// @notice Emitted upon EulerSwap instance creation or reconfiguration.
     event EulerSwapManagerSet(address indexed manager, bool installed);
 
-    constructor(address evc_, address poolManager_, address managementImpl_) UniswapHook(evc_, poolManager_) {
+    constructor(address evc_, address protocolFeeConfig_, address poolManager_, address managementImpl_)
+        UniswapHook(evc_, protocolFeeConfig_, poolManager_)
+    {
         managementImpl = managementImpl_;
     }
 
@@ -140,7 +142,7 @@ contract EulerSwap is IEulerSwap, UniswapHook {
 
         // Setup context
 
-        SwapLib.SwapContext memory ctx = SwapLib.init(address(evc), _msgSender(), to);
+        SwapLib.SwapContext memory ctx = SwapLib.init(address(evc), protocolFeeConfig, _msgSender(), to);
         SwapLib.setAmountsOut(ctx, amount0Out, amount1Out);
         SwapLib.invokeBeforeSwapHook(ctx);
 

src/EulerSwapFactory.sol

@@ -5,13 +5,12 @@ import {IEulerSwapFactory, IEulerSwap} from "./interfaces/IEulerSwapFactory.sol"
 import {EVCUtil} from "ethereum-vault-connector/utils/EVCUtil.sol";
 
 import {EulerSwap} from "./EulerSwap.sol";
-import {ProtocolFee} from "./utils/ProtocolFee.sol";
 import {MetaProxyDeployer} from "./utils/MetaProxyDeployer.sol";
 
 /// @title EulerSwapFactory contract
 /// @custom:security-contact [email protected]
 /// @author Euler Labs (https://www.eulerlabs.com/)
-contract EulerSwapFactory is IEulerSwapFactory, EVCUtil, ProtocolFee {
+contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     /// @dev The EulerSwap code instance that will be proxied to
     address public immutable eulerSwapImpl;
 
@@ -20,12 +19,8 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil, ProtocolFee {
 
     error Unauthorized();
     error OperatorNotInstalled();
-    error InvalidProtocolFee();
 
-    constructor(address evc, address eulerSwapImpl_, address feeOwner_, address feeRecipientSetter_)
-        EVCUtil(evc)
-        ProtocolFee(feeOwner_, feeRecipientSetter_)
-    {
+    constructor(address evc, address eulerSwapImpl_) EVCUtil(evc) {
         eulerSwapImpl = eulerSwapImpl_;
     }
 
@@ -37,10 +32,6 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil, ProtocolFee {
         bytes32 salt
     ) external returns (address) {
         require(_msgSender() == sParams.eulerAccount, Unauthorized());
-        require(
-            sParams.protocolFee == protocolFee && sParams.protocolFeeRecipient == protocolFeeRecipient,
-            InvalidProtocolFee()
-        );
 
         EulerSwap pool = EulerSwap(MetaProxyDeployer.deployMetaProxy(eulerSwapImpl, abi.encode(sParams), salt));
         deployedPools[address(pool)] = true;
@@ -67,9 +58,4 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil, ProtocolFee {
             )
         );
     }
-
-    /// @dev For ProtocolFee access
-    function _eulerSwapImpl() internal view override returns (address) {
-        return eulerSwapImpl;
-    }
 }

src/EulerSwapProtocolFeeConfig.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import {EVCUtil} from "evc/utils/EVCUtil.sol";
+
+/// @title EulerSwapProtocolFeeConfig contract
+/// @custom:security-contact [email protected]
+/// @author Euler Labs (https://www.eulerlabs.com/)
+contract EulerSwapProtocolFeeConfig is EVCUtil {
+    /// @dev Protocol fee admin
+    address public admin;
+
+    /// @dev Admin is not allowed to set a protocol fee larger than this
+    uint64 public constant MAX_PROTOCOL_FEE = 0.15e18;
+
+    /// @dev Destination of collected protocol fees, unless overridden
+    address public defaultRecipient;
+    /// @dev Default protocol fee, 1e18-scale
+    uint64 public defaultFee;
+
+    struct Override {
+        bool exists;
+        address recipient;
+        uint64 fee;
+    }
+
+    /// @dev EulerSwap-instance specific fee override
+    mapping(address pool => Override) public overrides;
+
+    error Unauthorized();
+    error InvalidProtocolFee();
+
+    constructor(address evc, address admin_) EVCUtil(evc) {
+        admin = admin_;
+    }
+
+    modifier onlyAdmin() {
+        // Ensures that the caller is not an operator, controller, etc
+        _authenticateCallerWithStandardContextState(true);
+
+        require(_msgSender() == admin, Unauthorized());
+
+        _;
+    }
+
+    function setDefaults(address recipient, uint64 fee) external onlyAdmin {
+        require(fee <= MAX_PROTOCOL_FEE, InvalidProtocolFee());
+
+        defaultRecipient = recipient;
+        defaultFee = fee;
+    }
+
+    function setOverride(address pool, address recipient, uint64 fee) external onlyAdmin {
+        require(fee <= MAX_PROTOCOL_FEE, InvalidProtocolFee());
+
+        overrides[pool] = Override({exists: true, recipient: recipient, fee: fee});
+    }
+
+    function removeOverride(address pool) external onlyAdmin {
+        delete overrides[pool];
+    }
+
+    function getProtocolFee(address pool) external view returns (address recipient, uint64 fee) {
+        Override memory o = overrides[pool];
+
+        if (o.exists) {
+            recipient = o.recipient;
+            fee = o.fee;
+
+            if (recipient == address(0)) recipient = defaultRecipient;
+        } else {
+            recipient = defaultRecipient;
+            fee = defaultFee;
+        }
+    }
+}

src/UniswapHook.sol

@@ -25,9 +25,16 @@ import {SwapLib} from "./libraries/SwapLib.sol";
 abstract contract UniswapHook is EulerSwapBase, BaseHook {
     using SafeCast for uint256;
 
+    address public immutable protocolFeeConfig;
+
     PoolKey internal _poolKey;
 
-    constructor(address evc_, address _poolManager) EulerSwapBase(evc_) BaseHook(IPoolManager(_poolManager)) {}
+    constructor(address evc_, address protocolFeeConfig_, address _poolManager)
+        EulerSwapBase(evc_)
+        BaseHook(IPoolManager(_poolManager))
+    {
+        protocolFeeConfig = protocolFeeConfig_;
+    }
 
     function activateHook(IEulerSwap.StaticParams memory sParams) internal nonReentrant {
         if (address(poolManager) == address(0)) return;
@@ -65,7 +72,7 @@ abstract contract UniswapHook is EulerSwapBase, BaseHook {
         nonReentrant
         returns (bytes4, BeforeSwapDelta, uint24)
     {
-        SwapLib.SwapContext memory ctx = SwapLib.init(address(evc), sender, msg.sender);
+        SwapLib.SwapContext memory ctx = SwapLib.init(address(evc), protocolFeeConfig, sender, msg.sender);
 
         uint256 amountIn;
         uint256 amountOut;

src/interfaces/IEulerSwap.sol

@@ -10,8 +10,6 @@ interface IEulerSwap {
         address borrowVault1;
         address eulerAccount;
         address feeRecipient;
-        address protocolFeeRecipient;
-        uint64 protocolFee;
     }
 
     /// @dev Reconfigurable pool parameters, loaded from storage.

src/libraries/CtxLib.sol

@@ -60,11 +60,11 @@ library CtxLib {
 
     /// @dev Unpacks encoded Params from trailing calldata. Loosely based on
     /// the implementation from EIP-3448 (except length is hard-coded).
-    /// 256 is the size of the StaticParams struct after ABI encoding.
+    /// 192 is the size of the StaticParams struct after ABI encoding.
     function getStaticParams() internal pure returns (IEulerSwap.StaticParams memory p) {
-        require(msg.data.length >= 256, InsufficientCalldata());
+        require(msg.data.length >= 192, InsufficientCalldata());
         unchecked {
-            return abi.decode(msg.data[msg.data.length - 256:], (IEulerSwap.StaticParams));
+            return abi.decode(msg.data[msg.data.length - 192:], (IEulerSwap.StaticParams));
         }
     }
 }

src/libraries/SwapLib.sol

@@ -9,6 +9,7 @@ import {CtxLib} from "./CtxLib.sol";
 import {CurveLib} from "./CurveLib.sol";
 import {FundsLib} from "./FundsLib.sol";
 import {QuoteLib} from "./QuoteLib.sol";
+import {EulerSwapProtocolFeeConfig} from "../EulerSwapProtocolFeeConfig.sol";
 import {IEulerSwap} from "../interfaces/IEulerSwap.sol";
 import "../interfaces/IEulerSwapHookTarget.sol";
 
@@ -40,6 +41,7 @@ library SwapLib {
     struct SwapContext {
         // Populated by init
         address evc;
+        address protocolFeeConfig;
         IEulerSwap.StaticParams sParams;
         IEulerSwap.DynamicParams dParams;
         address asset0;
@@ -56,8 +58,13 @@ library SwapLib {
         uint256 amount1In; // full minus fees
     }
 
-    function init(address evc, address sender, address to) internal view returns (SwapContext memory ctx) {
+    function init(address evc, address protocolFeeConfig, address sender, address to)
+        internal
+        view
+        returns (SwapContext memory ctx)
+    {
         ctx.evc = evc;
+        ctx.protocolFeeConfig = protocolFeeConfig;
         ctx.sParams = CtxLib.getStaticParams();
         ctx.dParams = CtxLib.getDynamicParams();
 
@@ -170,14 +177,19 @@ library SwapLib {
 
         // Slice off protocol fee
 
-        if (ctx.sParams.protocolFeeRecipient != address(0)) {
-            uint256 protocolFeeAmount = feeAmount * ctx.sParams.protocolFee / 1e18;
+        {
+            (address protocolFeeRecipient, uint64 protocolFee) =
+                EulerSwapProtocolFeeConfig(ctx.protocolFeeConfig).getProtocolFee(address(this));
 
-            if (protocolFeeAmount != 0) {
-                IERC20(assetInput).safeTransfer(ctx.sParams.protocolFeeRecipient, protocolFeeAmount);
+            if (protocolFee != 0) {
+                uint256 protocolFeeAmount = feeAmount * protocolFee / 1e18;
 
-                amount -= protocolFeeAmount;
-                feeAmount -= protocolFeeAmount;
+                if (protocolFeeAmount != 0) {
+                    IERC20(assetInput).safeTransfer(protocolFeeRecipient, protocolFeeAmount);
+
+                    amount -= protocolFeeAmount;
+                    feeAmount -= protocolFeeAmount;
+                }
             }
         }