Merge pull request #57 from euler-xyz/merge-hub

Port over cool stuff from hub

Author: haythemsellami

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/EulerSwapFactory.sol

@@ -11,11 +11,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;
 
     event PoolDeployed(
         address indexed asset0,
@@ -32,12 +33,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(address evc, address evkFactory_) EVCUtil(evc) {
         evkFactory = evkFactory_;
@@ -54,11 +57,11 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
             InvalidVaultImplementation()
         );
 
-        EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.eulerAccount, salt))}(params, curveParams);
+        uninstall(params.eulerAccount);
 
-        checkEulerAccountOperators(params.eulerAccount, address(pool));
+        EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.eulerAccount, salt))}(params, curveParams);
 
-        allPools.push(address(pool));
+        updateEulerAccountState(params.eulerAccount, address(pool));
 
         EulerSwap(pool).activate();
 
@@ -81,6 +84,11 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         return address(pool);
     }
 
+    /// @inheritdoc IEulerSwapFactory
+    function uninstallPool() external {
+        uninstall(_msgSender());
+    }
+
     /// @inheritdoc IEulerSwapFactory
     function computePoolAddress(
         IEulerSwap.Params memory poolParams,
@@ -105,43 +113,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/interfaces/IEulerSwapFactory.sol

@@ -4,6 +4,12 @@ pragma solidity >=0.8.0;
 import {IEulerSwap} from "./IEulerSwap.sol";
 
 interface IEulerSwapFactory {
+    struct EulerAccountState {
+        address pool;
+        uint48 allPoolsIndex;
+        uint48 poolMapIndex;
+    }
+
     /// @notice Deploy a new EulerSwap pool with the given parameters
     /// @dev The pool address is deterministically generated using CREATE2 with a salt derived from
     ///      the euler account address and provided salt parameter. This allows the pool address to be
@@ -16,6 +22,12 @@ interface IEulerSwapFactory {
         external
         returns (address);
 
+    /// @notice Uninstalls the pool associated with the Euler account
+    /// @dev This function removes the pool from the factory's tracking and emits a PoolUninstalled event
+    /// @dev The function can only be called by the Euler account that owns the pool
+    /// @dev If no pool is installed for the caller, the function returns without any action
+    function uninstallPool() external;
+
     /// @notice Compute the address of a new EulerSwap pool with the given parameters
     /// @dev The pool address is deterministically generated using CREATE2 with a salt derived from
     ///      the euler account address and provided salt parameter. This allows the pool address to be
@@ -29,17 +41,57 @@ interface IEulerSwapFactory {
         IEulerSwap.CurveParams memory curveParams,
         bytes32 salt
     ) external view returns (address);
+
+    /// @notice Returns the address of the Ethereum Vault Connector (EVC) contract
+    /// @return The address of the EVC contract
     function EVC() external view returns (address);
-    /// @notice Get the length of `allPools` array.
-    /// @return `allPools` length.
-    function allPoolsLength() external view returns (uint256);
-    /// @notice Get the address of the pool at the given index in the `allPools` array.
-    /// @param index The index of the pool to retrieve.
-    /// @return The address of the pool at the given index.
-    function allPools(uint256 index) external view returns (address);
-    /// @notice Get a slice of the deployed pools array.
-    /// @param start Start index of the slice.
-    /// @param end End index of the slice.
-    /// @return An array containing the slice of the deployed pools.
-    function getAllPoolsListSlice(uint256 start, uint256 end) external view returns (address[] memory);
+
+    /// @notice Returns a slice of all deployed pools
+    /// @dev Returns a subset of the pools array from start to end index
+    /// @param start The starting index of the slice (inclusive)
+    /// @param end The ending index of the slice (exclusive)
+    /// @return An array containing the requested slice of pool addresses
+    function poolsSlice(uint256 start, uint256 end) external view returns (address[] memory);
+
+    /// @notice Returns all deployed pools
+    /// @dev Returns the complete array of all pool addresses
+    /// @return An array containing all pool addresses
+    function pools() external view returns (address[] memory);
+
+    /// @notice Returns the number of pools for a specific asset pair
+    /// @dev Returns the length of the pool array for the given asset pair
+    /// @param asset0 The address of the first asset
+    /// @param asset1 The address of the second asset
+    /// @return The number of pools for the specified asset pair
+    function poolsByPairLength(address asset0, address asset1) external view returns (uint256);
+
+    /// @notice Returns a slice of pools for a specific asset pair
+    /// @dev Returns a subset of the pools array for the given asset pair from start to end index
+    /// @param asset0 The address of the first asset
+    /// @param asset1 The address of the second asset
+    /// @param start The starting index of the slice (inclusive)
+    /// @param end The ending index of the slice (exclusive)
+    /// @return An array containing the requested slice of pool addresses for the asset pair
+    function poolsByPairSlice(address asset0, address asset1, uint256 start, uint256 end)
+        external
+        view
+        returns (address[] memory);
+
+    /// @notice Returns all pools for a specific asset pair
+    /// @dev Returns the complete array of pool addresses for the given asset pair
+    /// @param asset0 The address of the first asset
+    /// @param asset1 The address of the second asset
+    /// @return An array containing all pool addresses for the specified asset pair
+    function poolsByPair(address asset0, address asset1) external view returns (address[] memory);
+
+    /// @notice Returns the pool address associated with a specific holder
+    /// @dev Returns the pool address from the EulerAccountState mapping for the given holder
+    /// @param who The address of the holder to query
+    /// @return The address of the pool associated with the holder
+    function poolByEulerAccount(address who) external view returns (address);
+
+    /// @notice Returns the total number of deployed pools
+    /// @dev Returns the length of the allPools array
+    /// @return The total number of pools deployed through the factory
+    function poolsLength() external view returns (uint256);
 }