Merge remote-tracking branch 'origin/eulerswap2-updates-fixes' into eulerswap2

Author: hoytech

docs/developer-guide.md

@@ -120,7 +120,7 @@ In order to challenge a pool to retrieve the validity bond, a challenger invokes
 * The swap is actually performed by taking the input tokens from the challenger. The challenger must've given appropriate token approval to the registry. In all cases, the funds will be returned to the challenger, meaning they can be sourced with a flash loan.
   * If this swap succeeds, the entire transaction is reverted (including the swap) and the challenge is rejected.
   * If the swap failed for any reason other than `E_AccountLiquidity()` or `HookError()` then the challenge is rejected. This check is necessary because some vaults can fail for other expected reasons, such as unpopulated pull oracles.
-* At this point, the challenge has succeeded. The validity bond is sent to the `recipient` address provided by the challenger, and the pool is unregistered.
+* At this point, the challenge has succeeded. The validity bond is sent to the `recipient` address provided by the challenger, and the pool is unregistered. The challenger should ensure `recipent` is an address that can access native tokens.
 
 
 

src/EulerSwap.sol

@@ -18,29 +18,15 @@ contract EulerSwap is IEulerSwap, UniswapHook {
 
     error AmountTooBig();
 
-    /// @notice Emitted upon EulerSwap instance creation or reconfiguration.
-    event EulerSwapConfigured(DynamicParams dParams, InitialState initialState);
-    /// @notice Emitted upon EulerSwap instance creation or reconfiguration.
-    event EulerSwapManagerSet(address indexed manager, bool installed);
-
     constructor(address evc_, address protocolFeeConfig_, address poolManager_, address managementImpl_)
         UniswapHook(evc_, protocolFeeConfig_, poolManager_)
     {
         managementImpl = managementImpl_;
     }
 
-    function delegateToManagementImpl() internal {
-        (bool success, bytes memory result) = managementImpl.delegatecall(msg.data);
-        if (!success) {
-            assembly {
-                revert(add(32, result), mload(result))
-            }
-        }
-    }
-
     /// @inheritdoc IEulerSwap
     function activate(DynamicParams calldata, InitialState calldata) external {
-        delegateToManagementImpl();
+        _delegateToManagementImpl();
 
         // Uniswap hook activation
 
@@ -49,12 +35,12 @@ contract EulerSwap is IEulerSwap, UniswapHook {
 
     /// @inheritdoc IEulerSwap
     function setManager(address, bool) external {
-        delegateToManagementImpl();
+        _delegateToManagementImpl();
     }
 
     /// @inheritdoc IEulerSwap
     function reconfigure(DynamicParams calldata, InitialState calldata) external {
-        delegateToManagementImpl();
+        _delegateToManagementImpl();
     }
 
     /// @inheritdoc IEulerSwap
@@ -165,4 +151,13 @@ contract EulerSwap is IEulerSwap, UniswapHook {
 
         SwapLib.finish(ctx);
     }
+
+    function _delegateToManagementImpl() internal {
+        (bool success, bytes memory result) = managementImpl.delegatecall(msg.data);
+        if (!success) {
+            assembly {
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
 }

src/EulerSwapManagement.sol

@@ -1,9 +1,6 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity ^0.8.27;
 
-import {IERC20} from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";
-
-import {IEulerSwapCallee} from "./interfaces/IEulerSwapCallee.sol";
 import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault} from "evk/EVault/IEVault.sol";
 
@@ -14,14 +11,17 @@ import {FundsLib} from "./libraries/FundsLib.sol";
 import {CurveLib} from "./libraries/CurveLib.sol";
 import {SwapLib} from "./libraries/SwapLib.sol";
 
+/// @title EulerSwapManagement contract
+/// @custom:security-contact security@euler.xyz
+/// @author Euler Labs (https://www.eulerlabs.com/)
 contract EulerSwapManagement is EulerSwapBase {
     error Unauthorized();
     error AlreadyActivated();
     error BadStaticParam();
     error BadDynamicParam();
-    error AmountTooBig();
     error AssetsOutOfOrderOrEqual();
     error InvalidAssets();
+    error BadFeeRecipient();
 
     /// @notice Emitted upon EulerSwap instance creation or reconfiguration.
     event EulerSwapConfigured(IEulerSwap.DynamicParams dParams, IEulerSwap.InitialState initialState);
@@ -65,7 +65,7 @@ contract EulerSwapManagement is EulerSwapBase {
         IEulerSwap.StaticParams memory sParams = CtxLib.getStaticParams();
 
         require(s.status == 0, AlreadyActivated());
-        s.status = 1;
+        s.status = 2; // Keep pool locked during activation
 
         // Static parameters
 
@@ -88,6 +88,11 @@ contract EulerSwapManagement is EulerSwapBase {
 
         require(sParams.eulerAccount != sParams.feeRecipient, BadStaticParam()); // set feeRecipient to 0 instead
 
+        if (sParams.feeRecipient != address(0)) {
+            address owner = evc.getAccountOwner(sParams.feeRecipient);
+            require(owner == sParams.feeRecipient || owner == address(0), BadFeeRecipient());
+        }
+
         // Dynamic parameters
 
         if (initialState.reserve0 != 0) {
@@ -127,6 +132,8 @@ contract EulerSwapManagement is EulerSwapBase {
         ) {
             IEVC(evc).enableCollateral(sParams.eulerAccount, sParams.supplyVault1);
         }
+
+        s.status = 1; // unlock pool
     }
 
     function setManager(address manager, bool installed) external nonReentrant {

src/EulerSwapProtocolFeeConfig.sol

@@ -29,9 +29,24 @@ contract EulerSwapProtocolFeeConfig is IEulerSwapProtocolFeeConfig, EVCUtil {
     mapping(address pool => Override) public overrides;
 
     error Unauthorized();
+    error InvalidAdminAddress();
     error InvalidProtocolFee();
+    error InvalidProtocolFeeRecipient();
+
+    /// @notice Emitted when admin is set/changed
+    event AdminUpdated(address indexed oldAdmin, address indexed newAdmin);
+    /// @notice Emitted when the default configuration is changed
+    event DefaultUpdated(address indexed oldRecipient, address indexed newRecipient, uint64 oldFee, uint64 newFee);
+    /// @notice Emitted when a per-pool override is created or changed
+    event OverrideSet(address indexed pool, address indexed recipient, uint64 fee);
+    /// @notice Emitted when a per-pool override is removed (and thus falls back to the default)
+    event OverrideRemoved(address indexed pool);
 
     constructor(address evc, address admin_) EVCUtil(evc) {
+        _validateAdminAddress(admin_);
+
+        emit AdminUpdated(address(0), admin_);
+
         admin = admin_;
     }
 
@@ -46,12 +61,19 @@ contract EulerSwapProtocolFeeConfig is IEulerSwapProtocolFeeConfig, EVCUtil {
 
     /// @inheritdoc IEulerSwapProtocolFeeConfig
     function setAdmin(address newAdmin) external onlyAdmin {
+        _validateAdminAddress(newAdmin);
+
+        emit AdminUpdated(admin, newAdmin);
+
         admin = newAdmin;
     }
 
     /// @inheritdoc IEulerSwapProtocolFeeConfig
     function setDefault(address recipient, uint64 fee) external onlyAdmin {
         require(fee <= MAX_PROTOCOL_FEE, InvalidProtocolFee());
+        require(fee == 0 || recipient != address(0), InvalidProtocolFeeRecipient());
+
+        emit DefaultUpdated(defaultRecipient, recipient, defaultFee, fee);
 
         defaultRecipient = recipient;
         defaultFee = fee;
@@ -61,11 +83,15 @@ contract EulerSwapProtocolFeeConfig is IEulerSwapProtocolFeeConfig, EVCUtil {
     function setOverride(address pool, address recipient, uint64 fee) external onlyAdmin {
         require(fee <= MAX_PROTOCOL_FEE, InvalidProtocolFee());
 
+        emit OverrideSet(pool, recipient, fee);
+
         overrides[pool] = Override({exists: true, recipient: recipient, fee: fee});
     }
 
     /// @inheritdoc IEulerSwapProtocolFeeConfig
     function removeOverride(address pool) external onlyAdmin {
+        emit OverrideRemoved(pool);
+
         delete overrides[pool];
     }
 
@@ -83,4 +109,10 @@ contract EulerSwapProtocolFeeConfig is IEulerSwapProtocolFeeConfig, EVCUtil {
             fee = defaultFee;
         }
     }
+
+    /// @dev Ensures the admin is not a known sub-account, since they are not allowed
+    function _validateAdminAddress(address addr) internal view {
+        address owner = evc.getAccountOwner(addr);
+        require(owner == addr || owner == address(0), InvalidAdminAddress());
+    }
 }

src/UniswapHook.sol

@@ -16,10 +16,7 @@ import {IEVault} from "evk/EVault/IEVault.sol";
 
 import {EulerSwapBase} from "./EulerSwapBase.sol";
 import {IEulerSwap} from "./interfaces/IEulerSwap.sol";
-import {CtxLib} from "./libraries/CtxLib.sol";
 import {QuoteLib} from "./libraries/QuoteLib.sol";
-import {CurveLib} from "./libraries/CurveLib.sol";
-import {FundsLib} from "./libraries/FundsLib.sol";
 import {SwapLib} from "./libraries/SwapLib.sol";
 
 abstract contract UniswapHook is EulerSwapBase, BaseHook {

src/interfaces/IEulerSwapCallee.sol

@@ -6,5 +6,9 @@ interface IEulerSwapCallee {
     /// is invoked on the `to` address, allowing flash-swaps (withdrawing output before
     /// sending input.
     /// @dev This callback mechanism is designed to be as similar as possible to Uniswap2.
+    /// @param sender The address that originated the swap
+    /// @param amount0 The requested output amount of token0
+    /// @param amount1 The requested output amount of token1
+    /// @param data Opaque callback data passed by swapper
     function eulerSwapCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external;
 }

src/libraries/FundsLib.sol

@@ -7,8 +7,6 @@ import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol"
 import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault, IBorrowing, IERC4626, IRiskManager} from "evk/EVault/IEVault.sol";
 
-import {IEulerSwap} from "../interfaces/IEulerSwap.sol";
-
 library FundsLib {
     using SafeERC20 for IERC20;
 
@@ -74,7 +72,7 @@ library FundsLib {
     /// @param amount The total amount to deposit
     /// @return The amount of assets successfully deposited (may be less than requested)
     /// @dev This function attempts to deposit assets into the specified vault.
-    /// @dev If the deposit fails with E_ZeroShares error, it safely returns 0 (this happens with very small amounts).
+    /// @dev If the deposit fails with E_ZeroShares or ZeroShares error, it safely returns 0 (this happens with very small amounts).
     /// @dev After successful deposit, if the user has any outstanding controller-enabled debt, it attempts to repay it.
     /// @dev If all debt is repaid, the controller is automatically disabled to reduce gas costs in future operations.
     function depositAssets(address evc, address eulerAccount, address supplyVault, address borrowVault, uint256 amount)

test/EulerSwapTestBase.t.sol

@@ -42,6 +42,7 @@ contract EulerSwapTestBase is EVaultTestBase {
     address installedOperator;
     bool expectInsufficientValidityBondRevert = false;
     bool expectAccountLiquidityRevert = false;
+    bool expectBadFeeRecipient = false;
 
     error E_AccountLiquidity();
 
@@ -172,13 +173,14 @@ contract EulerSwapTestBase is EVaultTestBase {
 
         vm.prank(holder);
         if (expectAccountLiquidityRevert) vm.expectRevert(E_AccountLiquidity.selector);
+        if (expectBadFeeRecipient) vm.expectRevert(EulerSwapManagement.BadFeeRecipient.selector);
         bytes memory result = IEVC(evc).call(
             address(eulerSwapFactory),
             sParams.eulerAccount,
             0,
             abi.encodeCall(EulerSwapFactory.deployPool, (sParams, dParams, initialState, salt))
         );
-        if (expectAccountLiquidityRevert) return EulerSwap(address(0)); // Just to return to test
+        if (expectAccountLiquidityRevert || expectBadFeeRecipient) return EulerSwap(address(0)); // Just to return to test
         EulerSwap eulerSwap = EulerSwap(abi.decode(result, (address)));
 
         vm.prank(holder);

test/Fees.t.sol

@@ -163,6 +163,23 @@ contract FeesTest is EulerSwapTestBase {
         assertEq(assetTST.balanceOf(address(54321)), amountIn - amountInNoFees);
     }
 
+    function test_altFeeRecipient_subAccount() public {
+        address recipient = makeAddr("feeRecipient");
+
+        // Register owner with EVC
+        vm.prank(recipient);
+        evc.enableCollateral(recipient, address(0));
+
+        address subAccount = address(uint160(recipient) ^ 1);
+
+        (IEulerSwap.StaticParams memory sParams, IEulerSwap.DynamicParams memory dParams) =
+            getEulerSwapParams(60e18, 60e18, 1e18, 1e18, 0.9e18, 0.9e18, 0.01e18, subAccount);
+        IEulerSwap.InitialState memory initialState = IEulerSwap.InitialState({reserve0: 60e18, reserve1: 60e18});
+
+        expectBadFeeRecipient = true;
+        eulerSwap = createEulerSwapFull(sParams, dParams, initialState);
+    }
+
     function test_fees_protocolFees_swap() public {
         uint256 fee = 0.05e18;
         uint256 protocolFee = 0.1e18;
@@ -221,6 +238,10 @@ contract FeesTest is EulerSwapTestBase {
         vm.expectRevert(EulerSwapProtocolFeeConfig.InvalidProtocolFee.selector);
         protocolFeeConfig.setDefault(address(8888), 0.15000001e18);
 
+        vm.prank(protocolFeeAdmin);
+        vm.expectRevert(EulerSwapProtocolFeeConfig.InvalidProtocolFeeRecipient.selector);
+        protocolFeeConfig.setDefault(address(0), 0.1e18);
+
         // Set a default
 
         vm.prank(protocolFeeAdmin);
@@ -234,6 +255,8 @@ contract FeesTest is EulerSwapTestBase {
 
         // Override
 
+        vm.expectEmit(true, true, true, true);
+        emit EulerSwapProtocolFeeConfig.OverrideSet(address(eulerSwap), address(9999), 0.07e18);
         vm.prank(protocolFeeAdmin);
         protocolFeeConfig.setOverride(address(eulerSwap), address(9999), 0.07e18);
 
@@ -267,6 +290,8 @@ contract FeesTest is EulerSwapTestBase {
 
         // Remove override
 
+        vm.expectEmit(true, true, true, true);
+        emit EulerSwapProtocolFeeConfig.OverrideRemoved(address(eulerSwap));
         vm.prank(protocolFeeAdmin);
         protocolFeeConfig.removeOverride(address(eulerSwap));
 
@@ -275,20 +300,50 @@ contract FeesTest is EulerSwapTestBase {
             assertEq(recipient, address(7777));
             assertEq(fee, 0.12e18);
         }
+
+        // Change override back to 0s
+
+        vm.prank(protocolFeeAdmin);
+        protocolFeeConfig.setDefault(address(0), 0);
+
+        {
+            (address recipient, uint64 fee) = protocolFeeConfig.getProtocolFee(address(eulerSwap));
+            assertEq(recipient, address(0));
+            assertEq(fee, 0);
+        }
     }
 
     function test_fees_protocolFees_setAdmin() public {
-        assertEq(protocolFeeConfig.admin(), protocolFeeAdmin);
+        // Register owner with EVC
+        evc.enableCollateral(address(this), address(0));
+
+        address origAdmin = protocolFeeConfig.admin();
+        assertEq(origAdmin, protocolFeeAdmin);
 
         vm.expectRevert(EulerSwapProtocolFeeConfig.Unauthorized.selector);
         protocolFeeConfig.setDefault(address(8888), 0.1e18);
 
+        // Can't set a subaccount
+        vm.expectRevert(EulerSwapProtocolFeeConfig.InvalidAdminAddress.selector);
+        vm.prank(protocolFeeAdmin);
+        protocolFeeConfig.setAdmin(address(uint160(address(this)) ^ 1));
+
+        vm.expectEmit(true, true, true, true);
+        emit EulerSwapProtocolFeeConfig.AdminUpdated(origAdmin, address(this));
         vm.prank(protocolFeeAdmin);
         protocolFeeConfig.setAdmin(address(this));
 
         assertEq(protocolFeeConfig.admin(), address(this));
+    }
 
-        protocolFeeConfig.setDefault(address(8888), 0.1e18);
+    function test_fees_protocolFees_defaults() public {
+        address origFefaultRecipient = protocolFeeConfig.defaultRecipient();
+        uint64 origDefaultFee = protocolFeeConfig.defaultFee();
+
+        vm.expectEmit(true, true, true, true);
+        emit EulerSwapProtocolFeeConfig.DefaultUpdated(origFefaultRecipient, address(7654), origDefaultFee, 0.071e18);
+        vm.prank(protocolFeeAdmin);
+        protocolFeeConfig.setDefault(address(7654), 0.071e18);
     }
 
     function test_fuzzFeeRounding(uint256 amount, uint256 fee) public pure {