Merge branch 'master' into v4-exploration

Author: hoytech

script/DeployPool.s.sol

@@ -57,7 +57,7 @@ contract DeployPool is ScriptUtil {
         evc.batch(items);
         vm.stopBroadcast();
 
-        address pool = factory.eulerAccountToPool(eulerAccount);
+        address pool = factory.poolByEulerAccount(eulerAccount);
 
         string memory outputScriptFileName = "DeployPool_output.json";
 

src/EulerSwap.sol

@@ -23,7 +23,9 @@ contract EulerSwap is IEulerSwap, EVCUtil {
     address public immutable eulerAccount;
     uint112 public immutable equilibriumReserve0;
     uint112 public immutable equilibriumReserve1;
-    uint256 public immutable feeMultiplier;
+    uint256 public immutable fee;
+    uint256 public immutable protocolFee;
+    address public immutable protocolFeeRecipient;
 
     uint256 public immutable priceX;
     uint256 public immutable priceY;
@@ -83,7 +85,9 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         equilibriumReserve1 = params.equilibriumReserve1;
         reserve0 = params.currReserve0;
         reserve1 = params.currReserve1;
-        feeMultiplier = 1e18 - params.fee;
+        fee = params.fee;
+        protocolFee = 0.1e18;
+        protocolFeeRecipient = address(0);
 
         // Curve params
 
@@ -120,11 +124,8 @@ contract EulerSwap is IEulerSwap, EVCUtil {
 
         // Deposit all available funds, adjust received amounts downward to collect fees
 
-        uint256 amount0In = IERC20(asset0).balanceOf(address(this));
-        if (amount0In > 0) amount0In = depositAssets(vault0, amount0In) * feeMultiplier / 1e18;
-
-        uint256 amount1In = IERC20(asset1).balanceOf(address(this));
-        if (amount1In > 0) amount1In = depositAssets(vault1, amount1In) * feeMultiplier / 1e18;
+        uint256 amount0In = depositAssets(asset0, vault0);
+        uint256 amount1In = depositAssets(asset1, vault1);
 
         // Verify curve invariant is satisfied
 
@@ -211,14 +212,29 @@ contract EulerSwap is IEulerSwap, EVCUtil {
     }
 
     /// @notice Deposits assets into a vault and automatically repays any outstanding debt
+    /// @param asset The address of the underlying asset
     /// @param vault The address of the vault to deposit into
-    /// @param amount The amount of assets to deposit
     /// @return The amount of assets successfully deposited
     /// @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 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 vault, uint256 amount) internal returns (uint256) {
+    function depositAssets(address asset, address vault) internal returns (uint256) {
+        uint256 amount = IERC20(asset).balanceOf(address(this));
+        if (amount == 0) return 0;
+
+        uint256 feeAmount = amount * fee / 1e18;
+
+        {
+            uint256 protocolFeeAmount = feeAmount * protocolFee / 1e18;
+
+            if (protocolFeeAmount != 0) {
+                IERC20(asset).transfer(protocolFeeRecipient, protocolFeeAmount);
+                amount -= protocolFeeAmount;
+                feeAmount -= protocolFeeAmount;
+            }
+        }
+
         uint256 deposited;
 
         if (IEVC(evc).isControllerEnabled(eulerAccount, vault)) {
@@ -238,13 +254,13 @@ contract EulerSwap is IEulerSwap, EVCUtil {
             try IEVault(vault).deposit(amount, eulerAccount) {}
             catch (bytes memory reason) {
                 require(bytes4(reason) == EVKErrors.E_ZeroShares.selector, DepositFailure(reason));
-                return deposited;
+                amount = 0;
             }
 
             deposited += amount;
         }
 
-        return deposited;
+        return deposited > feeAmount ? deposited - feeAmount : 0;
     }
 
     /// @notice Approves tokens for a given vault, supporting both standard approvals and permit2

src/EulerSwapFactory.sol

@@ -12,11 +12,12 @@ import {GenericFactory} from "evk/GenericFactory/GenericFactory.sol";
 /// @author Euler Labs (https://www.eulerlabs.com/)
 contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     /// @dev An array to store all pools addresses.
-    address[] public allPools;
-    /// @dev Mapping between euler account and deployed pool that is currently set as operator
-    mapping(address eulerAccount => address operator) public eulerAccountToPool;
+    address[] private allPools;
     /// @dev Vaults must be deployed by this factory
     address public immutable evkFactory;
+    /// @dev Mapping between euler account and EulerAccountState
+    mapping(address eulerAccount => EulerAccountState state) private eulerAccountState;
+    mapping(address asset0 => mapping(address asset1 => address[])) private poolMap;
 
     IPoolManager immutable poolManager;
 
@@ -25,7 +26,7 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         address indexed asset1,
         address vault0,
         address vault1,
-        uint256 indexed feeMultiplier,
+        uint256 indexed fee,
         address eulerAccount,
         uint256 reserve0,
         uint256 reserve1,
@@ -35,12 +36,14 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         uint256 concentrationY,
         address pool
     );
+    event PoolUninstalled(address indexed asset0, address indexed asset1, address indexed eulerAccount, address pool);
 
     error InvalidQuery();
     error Unauthorized();
     error OldOperatorStillInstalled();
     error OperatorNotInstalled();
     error InvalidVaultImplementation();
+    error SliceOutOfBounds();
 
     constructor(IPoolManager _manager, address evc, address evkFactory_) EVCUtil(evc) {
         poolManager = _manager;
@@ -58,12 +61,12 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
             InvalidVaultImplementation()
         );
 
+        uninstall(params.eulerAccount);
+
         EulerSwapHook pool =
             new EulerSwapHook{salt: keccak256(abi.encode(params.eulerAccount, salt))}(poolManager, params, curveParams);
 
-        checkEulerAccountOperators(params.eulerAccount, address(pool));
-
-        allPools.push(address(pool));
+        updateEulerAccountState(params.eulerAccount, address(pool));
 
         pool.activate();
 
@@ -72,7 +75,7 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
             pool.asset1(),
             params.vault0,
             params.vault1,
-            pool.feeMultiplier(),
+            pool.fee(),
             params.eulerAccount,
             params.currReserve0,
             params.currReserve1,
@@ -86,6 +89,11 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         return address(pool);
     }
 
+    /// @inheritdoc IEulerSwapFactory
+    function uninstallPool() external {
+        uninstall(_msgSender());
+    }
+
     /// @inheritdoc IEulerSwapFactory
     function computePoolAddress(
         IEulerSwap.Params memory poolParams,
@@ -112,43 +120,127 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         );
     }
 
+    /// @inheritdoc IEulerSwapFactory
     function EVC() external view override(EVCUtil, IEulerSwapFactory) returns (address) {
         return address(evc);
     }
 
     /// @inheritdoc IEulerSwapFactory
-    function allPoolsLength() external view returns (uint256) {
+    function poolByEulerAccount(address eulerAccount) external view returns (address) {
+        return eulerAccountState[eulerAccount].pool;
+    }
+
+    /// @inheritdoc IEulerSwapFactory
+    function poolsLength() external view returns (uint256) {
         return allPools.length;
     }
 
     /// @inheritdoc IEulerSwapFactory
-    function getAllPoolsListSlice(uint256 _start, uint256 _end) external view returns (address[] memory) {
-        uint256 length = allPools.length;
-        if (_end == type(uint256).max) _end = length;
-        if (_end < _start || _end > length) revert InvalidQuery();
-
-        address[] memory allPoolsList = new address[](_end - _start);
-        for (uint256 i; i < _end - _start; ++i) {
-            allPoolsList[i] = allPools[_start + i];
-        }
+    function poolsSlice(uint256 start, uint256 end) external view returns (address[] memory) {
+        return _getSlice(allPools, start, end);
+    }
+
+    /// @inheritdoc IEulerSwapFactory
+    function pools() external view returns (address[] memory) {
+        return _getSlice(allPools, 0, type(uint256).max);
+    }
+
+    /// @inheritdoc IEulerSwapFactory
+    function poolsByPairLength(address asset0, address asset1) external view returns (uint256) {
+        return poolMap[asset0][asset1].length;
+    }
+
+    /// @inheritdoc IEulerSwapFactory
+    function poolsByPairSlice(address asset0, address asset1, uint256 start, uint256 end)
+        external
+        view
+        returns (address[] memory)
+    {
+        return _getSlice(poolMap[asset0][asset1], start, end);
+    }
 
-        return allPoolsList;
+    /// @inheritdoc IEulerSwapFactory
+    function poolsByPair(address asset0, address asset1) external view returns (address[] memory) {
+        return _getSlice(poolMap[asset0][asset1], 0, type(uint256).max);
     }
 
-    /// @notice Validates operator authorization for euler account. First checks if the account has an existing operator
-    /// and ensures it is deauthorized. Then verifies the new pool is authorized as an operator. Finally, updates the
-    /// mapping to track the new pool as the account's operator.
+    /// @notice Validates operator authorization for euler account and update the relevant EulerAccountState.
     /// @param eulerAccount The address of the euler account.
-    /// @param newPool The address of the new pool.
-    function checkEulerAccountOperators(address eulerAccount, address newPool) internal {
-        address operator = eulerAccountToPool[eulerAccount];
+    /// @param newOperator The address of the new pool.
+    function updateEulerAccountState(address eulerAccount, address newOperator) internal {
+        require(evc.isAccountOperatorAuthorized(eulerAccount, newOperator), OperatorNotInstalled());
 
-        if (operator != address(0)) {
-            require(!evc.isAccountOperatorAuthorized(eulerAccount, operator), OldOperatorStillInstalled());
-        }
+        (address asset0, address asset1) = _getAssets(newOperator);
+
+        address[] storage poolMapArray = poolMap[asset0][asset1];
+
+        eulerAccountState[eulerAccount] = EulerAccountState({
+            pool: newOperator,
+            allPoolsIndex: uint48(allPools.length),
+            poolMapIndex: uint48(poolMapArray.length)
+        });
+
+        allPools.push(newOperator);
+        poolMapArray.push(newOperator);
+    }
+
+    /// @notice Uninstalls the pool associated with the given Euler account
+    /// @dev This function removes the pool from the factory's tracking and emits a PoolUninstalled event
+    /// @dev The function checks if the operator is still installed and reverts if it is
+    /// @dev If no pool exists for the account, the function returns without any action
+    /// @param eulerAccount The address of the Euler account whose pool should be uninstalled
+    function uninstall(address eulerAccount) internal {
+        address pool = eulerAccountState[eulerAccount].pool;
+
+        if (pool == address(0)) return;
+
+        require(!evc.isAccountOperatorAuthorized(eulerAccount, pool), OldOperatorStillInstalled());
+
+        (address asset0, address asset1) = _getAssets(pool);
 
-        require(evc.isAccountOperatorAuthorized(eulerAccount, newPool), OperatorNotInstalled());
+        address[] storage poolMapArr = poolMap[asset0][asset1];
+
+        swapAndPop(allPools, eulerAccountState[eulerAccount].allPoolsIndex);
+        swapAndPop(poolMapArr, eulerAccountState[eulerAccount].poolMapIndex);
+
+        delete eulerAccountState[eulerAccount];
+
+        emit PoolUninstalled(asset0, asset1, eulerAccount, pool);
+    }
+
+    /// @notice Swaps the element at the given index with the last element and removes the last element
+    /// @param arr The storage array to modify
+    /// @param index The index of the element to remove
+    function swapAndPop(address[] storage arr, uint256 index) internal {
+        arr[index] = arr[arr.length - 1];
+        arr.pop();
+    }
+
+    /// @notice Retrieves the asset addresses for a given pool
+    /// @dev Calls the pool contract to get its asset0 and asset1 addresses
+    /// @param pool The address of the pool to query
+    /// @return The addresses of asset0 and asset1 in the pool
+    function _getAssets(address pool) internal view returns (address, address) {
+        return (EulerSwap(pool).asset0(), EulerSwap(pool).asset1());
+    }
+
+    /// @notice Returns a slice of an array of addresses
+    /// @dev Creates a new memory array containing elements from start to end index
+    ///      If end is type(uint256).max, it will return all elements from start to the end of the array
+    /// @param arr The storage array to slice
+    /// @param start The starting index of the slice (inclusive)
+    /// @param end The ending index of the slice (exclusive)
+    /// @return A new memory array containing the requested slice of addresses
+    function _getSlice(address[] storage arr, uint256 start, uint256 end) internal view returns (address[] memory) {
+        uint256 length = arr.length;
+        if (end == type(uint256).max) end = length;
+        if (end < start || end > length) revert SliceOutOfBounds();
+
+        address[] memory slice = new address[](end - start);
+        for (uint256 i; i < end - start; ++i) {
+            slice[i] = arr[start + i];
+        }
 
-        eulerAccountToPool[eulerAccount] = newPool;
+        return slice;
     }
 }

src/EulerSwapPeriphery.sol

@@ -105,11 +105,11 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         );
         require(amount <= type(uint112).max, SwapLimitExceeded());
 
-        uint256 feeMultiplier = eulerSwap.feeMultiplier();
+        uint256 fee = eulerSwap.fee();
         (uint112 reserve0, uint112 reserve1,) = eulerSwap.getReserves();
 
-        // exactIn: decrease received amountIn, rounding down
-        if (exactIn) amount = amount * feeMultiplier / 1e18;
+        // exactIn: decrease effective amountIn
+        if (exactIn) amount = amount - (amount * fee / 1e18);
 
         bool asset0IsInput = checkTokens(eulerSwap, tokenIn, tokenOut);
         (uint256 inLimit, uint256 outLimit) = calcLimits(eulerSwap, asset0IsInput);
@@ -124,8 +124,8 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
             require(amount <= outLimit && quote <= inLimit, SwapLimitExceeded());
         }
 
-        // exactOut: increase required quote(amountIn), rounding up
-        if (!exactIn) quote = (quote * 1e18 + (feeMultiplier - 1)) / feeMultiplier;
+        // exactOut: inflate required amountIn
+        if (!exactIn) quote = (quote * 1e18) / (1e18 - fee);
 
         return quote;
     }

src/interfaces/IEulerSwap.sol

@@ -50,7 +50,9 @@ interface IEulerSwap {
     function eulerAccount() external view returns (address);
     function equilibriumReserve0() external view returns (uint112);
     function equilibriumReserve1() external view returns (uint112);
-    function feeMultiplier() external view returns (uint256);
+    function fee() external view returns (uint256);
+    function protocolFee() external view returns (uint256);
+    function protocolFeeRecipient() external view returns (address);
     /// @notice Returns the current reserves of the pool
     /// @return reserve0 The amount of asset0 in the pool
     /// @return reserve1 The amount of asset1 in the pool