Merge pull request #61 from euler-xyz/sauce/protocol-fee-ops

Protocol Fee Ops

Author: hoytech

docs/audits/EulerSwapHook_Audit_Scope.md

@@ -50,4 +50,12 @@ The scope of audit involves a re-audit of EulerSwap, primarily `src/`:
 
 Due to technical requirements, EulerSwapHook must take the input token from PoolManager and deposit it into Euler Vaults. It will appear that EulerSwapHook can only support input sizes of `IERC20.balanceOf(PoolManager)`. However swap routers can pre-emptively send input tokens (from user wallet to PoolManager) prior to calling `poolManager.swap` to get around this limitation.
 
-An example `test/utils/MinimalRouter.sol` is provided as an example.
+An example `test/utils/MinimalRouter.sol` is provided as an example.
+
+### Invalidated Salts
+
+Uniswap v4 Hooks encode their behaviors within the address, requiring deployers to mine salts for a particular address pattern. Because constructor arguments influence the precomputed address during the salt-finding process, governance may accidentally invalidate a discovered salt by updating the protocol fee.
+
+The EulerSwapFactory passes a protocol fee and protocol fee recipient to a EulerSwap instance (hook). If governance were modify either values between salt-discovery and EulerSwap deployment, the deployment would fail.
+
+This scenario is unlikely to happen as we do not expect protocol fee parameters to change; as well, governance can pre-emptively warn deployers of the parameter change.

src/EulerSwapFactory.sol

@@ -6,12 +6,13 @@ import {EVCUtil} from "ethereum-vault-connector/utils/EVCUtil.sol";
 import {GenericFactory} from "evk/GenericFactory/GenericFactory.sol";
 
 import {EulerSwap} from "./EulerSwap.sol";
+import {ProtocolFee} from "./utils/ProtocolFee.sol";
 import {MetaProxyDeployer} from "./MetaProxyDeployer.sol";
 
 /// @title EulerSwapFactory contract
 /// @custom:security-contact [email protected]
 /// @author Euler Labs (https://www.eulerlabs.com/)
-contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
+contract EulerSwapFactory is IEulerSwapFactory, EVCUtil, ProtocolFee {
     /// @dev An array to store all pools addresses.
     address[] private allPools;
     /// @dev Vaults must be deployed by this factory
@@ -33,7 +34,10 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     error InvalidVaultImplementation();
     error SliceOutOfBounds();
 
-    constructor(address evc, address evkFactory_, address eulerSwapImpl_) EVCUtil(evc) {
+    constructor(address evc, address evkFactory_, address eulerSwapImpl_, address feeOwner_)
+        EVCUtil(evc)
+        ProtocolFee(feeOwner_)
+    {
         evkFactory = evkFactory_;
         eulerSwapImpl = eulerSwapImpl_;
     }
@@ -51,6 +55,10 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
 
         uninstall(params.eulerAccount);
 
+        // set protocol fee
+        params.protocolFee = protocolFee;
+        params.protocolFeeRecipient = protocolFeeRecipient;
+
         EulerSwap pool = EulerSwap(
             MetaProxyDeployer.deployMetaProxy(
                 eulerSwapImpl, abi.encode(params), keccak256(abi.encode(params.eulerAccount, salt))

src/utils/ProtocolFee.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.27;
+
+import {Owned} from "solmate/src/auth/Owned.sol";
+
+abstract contract ProtocolFee is Owned {
+    uint256 public protocolFee;
+    address public protocolFeeRecipient;
+
+    error InvalidFee();
+
+    constructor(address _feeOwner) Owned(_feeOwner) {}
+
+    /// @notice Set the protocol fee, expressed as a percentage of LP fee
+    /// @param newFee The new protocol fee, in WAD units (0.10e18 = 10%)
+    function setProtocolFee(uint256 newFee) external onlyOwner {
+        require(newFee < 1e18, InvalidFee());
+        protocolFee = newFee;
+    }
+
+    function setProtocolFeeRecipient(address newRecipient) external onlyOwner {
+        protocolFeeRecipient = newRecipient;
+    }
+}

test/Ctx.t.sol

@@ -14,7 +14,7 @@ contract CtxTest is EulerSwapTestBase {
     }
 
     function test_staticParamSize() public view {
-        IEulerSwap.Params memory params = getEulerSwapParams(1e18, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 0);
+        IEulerSwap.Params memory params = getEulerSwapParams(1e18, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 0, 0, address(0));
         assertEq(abi.encode(params).length, 384);
     }
 }

test/EulerSwapTestBase.t.sol

@@ -47,7 +47,7 @@ contract EulerSwapTestBase is EVaultTestBase {
         );
 
         eulerSwapImpl = address(new EulerSwap{salt: salt}(address(evc), poolManager_));
-        eulerSwapFactory = new EulerSwapFactory(address(evc), address(factory), eulerSwapImpl);
+        eulerSwapFactory = new EulerSwapFactory(address(evc), address(factory), eulerSwapImpl, address(this));
         periphery = new EulerSwapPeriphery();
     }
 
@@ -138,10 +138,25 @@ contract EulerSwapTestBase is EVaultTestBase {
         uint256 py,
         uint256 cx,
         uint256 cy
+    ) internal returns (EulerSwap) {
+        return createEulerSwapFull(reserve0, reserve1, fee, px, py, cx, cy, 0, address(0));
+    }
+
+    function createEulerSwapFull(
+        uint112 reserve0,
+        uint112 reserve1,
+        uint256 fee,
+        uint256 px,
+        uint256 py,
+        uint256 cx,
+        uint256 cy,
+        uint256 protocolFee,
+        address protcoolFeeRecipient
     ) internal returns (EulerSwap) {
         removeInstalledOperator();
 
-        IEulerSwap.Params memory params = getEulerSwapParams(reserve0, reserve1, px, py, cx, cy, fee);
+        IEulerSwap.Params memory params =
+            getEulerSwapParams(reserve0, reserve1, px, py, cx, cy, fee, protocolFee, protcoolFeeRecipient);
         IEulerSwap.InitialState memory initialState =
             IEulerSwap.InitialState({currReserve0: reserve0, currReserve1: reserve1});
 
@@ -167,10 +182,25 @@ contract EulerSwapTestBase is EVaultTestBase {
         uint256 py,
         uint256 cx,
         uint256 cy
+    ) internal returns (EulerSwap) {
+        return createEulerSwapHookFull(reserve0, reserve1, fee, px, py, cx, cy, 0, address(0));
+    }
+
+    function createEulerSwapHookFull(
+        uint112 reserve0,
+        uint112 reserve1,
+        uint256 fee,
+        uint256 px,
+        uint256 py,
+        uint256 cx,
+        uint256 cy,
+        uint256 protocolFee,
+        address protocolFeeRecipient
     ) internal returns (EulerSwap) {
         removeInstalledOperator();
 
-        IEulerSwap.Params memory params = getEulerSwapParams(reserve0, reserve1, px, py, cx, cy, fee);
+        IEulerSwap.Params memory params =
+            getEulerSwapParams(reserve0, reserve1, px, py, cx, cy, fee, protocolFee, protocolFeeRecipient);
         IEulerSwap.InitialState memory initialState =
             IEulerSwap.InitialState({currReserve0: reserve0, currReserve1: reserve1});
 
@@ -244,7 +274,9 @@ contract EulerSwapTestBase is EVaultTestBase {
         uint256 py,
         uint256 cx,
         uint256 cy,
-        uint256 fee
+        uint256 fee,
+        uint256 protocolFee,
+        address protocolFeeRecipient
     ) internal view returns (EulerSwap.Params memory) {
         return IEulerSwap.Params({
             vault0: address(eTST),
@@ -257,8 +289,8 @@ contract EulerSwapTestBase is EVaultTestBase {
             concentrationX: cx,
             concentrationY: cy,
             fee: fee,
-            protocolFee: 0,
-            protocolFeeRecipient: address(0)
+            protocolFee: protocolFee,
+            protocolFeeRecipient: protocolFeeRecipient
         });
     }
 

test/FactoryTest.t.sol

@@ -28,7 +28,7 @@ contract FactoryTest is EulerSwapTestBase {
         view
         returns (IEulerSwap.Params memory poolParams, IEulerSwap.InitialState memory initialState)
     {
-        poolParams = getEulerSwapParams(1e18, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 0);
+        poolParams = getEulerSwapParams(1e18, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 0, 0, address(0));
         initialState = IEulerSwap.InitialState({currReserve0: 1e18, currReserve1: 1e18});
     }
 

test/HookFees.t.sol

@@ -17,6 +17,8 @@ import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 contract HookFeesTest is EulerSwapTestBase {
     using StateLibrary for IPoolManager;
 
+    address protocolFeeRecipient = makeAddr("protocolFeeRecipient");
+
     EulerSwap public eulerSwap;
 
     IPoolManager public poolManager;
@@ -120,4 +122,56 @@ contract HookFeesTest is EulerSwapTestBase {
 
         assertGt(getHolderNAV(), origNav + int256(amountIn - amountInWithoutFee));
     }
+
+    function test_protocolFee() public {
+        // set protocol fee to 10% of the LP fee
+        uint256 protocolFee = 0.1e18;
+
+        eulerSwapFactory.setProtocolFee(protocolFee);
+        eulerSwapFactory.setProtocolFeeRecipient(protocolFeeRecipient);
+
+        // set swap fee to 10 bips and activate the pool
+        eulerSwap = createEulerSwapHookFull(
+            60e18, 60e18, 0.001e18, 1e18, 1e18, 0.4e18, 0.85e18, protocolFee, protocolFeeRecipient
+        );
+
+        int256 origNav = getHolderNAV();
+        (uint112 r0, uint112 r1,) = eulerSwap.getReserves();
+
+        uint256 amountIn = 1e18;
+        uint256 amountInWithoutFee = amountIn - (amountIn * eulerSwap.getParams().fee / 1e18);
+        uint256 amountOut =
+            periphery.quoteExactInput(address(eulerSwap), address(assetTST), address(assetTST2), amountIn);
+
+        assetTST.mint(anyone, amountIn);
+
+        vm.startPrank(anyone);
+        assetTST.approve(address(minimalRouter), amountIn);
+
+        bool zeroForOne = address(assetTST) < address(assetTST2);
+        BalanceDelta result = minimalRouter.swap(eulerSwap.poolKey(), zeroForOne, amountIn, 0, "");
+        vm.stopPrank();
+
+        assertEq(assetTST.balanceOf(anyone), 0);
+        assertEq(assetTST2.balanceOf(anyone), amountOut);
+
+        assertEq(zeroForOne ? uint256(-int256(result.amount0())) : uint256(-int256(result.amount1())), amountIn);
+        assertEq(zeroForOne ? uint256(int256(result.amount1())) : uint256(int256(result.amount0())), amountOut);
+
+        // assert fees were not added to the reserves
+        (uint112 r0New, uint112 r1New,) = eulerSwap.getReserves();
+        if (zeroForOne) {
+            assertEq(r0New, r0 + amountInWithoutFee);
+            assertEq(r1New, r1 - amountOut);
+        } else {
+            // oneForZero, so the curve received asset1
+            assertEq(r0New, r0 - amountOut);
+            assertEq(r1New, r1 + amountInWithoutFee);
+        }
+
+        uint256 protocolFeeCollected = assetTST.balanceOf(protocolFeeRecipient);
+        assertGt(protocolFeeCollected, 0);
+
+        assertGt(getHolderNAV(), origNav + int256(amountIn - amountInWithoutFee) - int256(protocolFeeCollected));
+    }
 }