update

Author: haythemsellami

script/DeployPool.s.sol

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

src/EulerSwapFactory.sol

@@ -57,9 +57,11 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
             InvalidVaultImplementation()
         );
 
+        uninstall(params.eulerAccount);
+
         EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.eulerAccount, salt))}(params, curveParams);
 
-        checkAndUpdateEulerAccountState(params.eulerAccount, address(pool));
+        updateEulerAccountState(params.eulerAccount, address(pool));
 
         EulerSwap(pool).activate();
 
@@ -82,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,
@@ -112,7 +119,7 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     }
 
     /// @inheritdoc IEulerSwapFactory
-    function poolByHolder(address who) external view returns (address) {
+    function poolByEulerAccount(address who) external view returns (address) {
         return eulerAccountState[who].pool;
     }
 
@@ -153,73 +160,51 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     /// @notice Validates operator authorization for euler account and update the relevant EulerAccountState.
     /// @param eulerAccount The address of the euler account.
     /// @param newOperator The address of the new pool.
-    function checkAndUpdateEulerAccountState(address eulerAccount, address newOperator) internal {
+    function updateEulerAccountState(address eulerAccount, address newOperator) internal {
         require(evc.isAccountOperatorAuthorized(eulerAccount, newOperator), OperatorNotInstalled());
 
-        (address newOpAsset0, address newOpAsset1) = _getAssets(newOperator);
-        address oldOperator = eulerAccountState[eulerAccount].pool;
-
-        if (oldOperator != address(0)) {
-            require(!evc.isAccountOperatorAuthorized(eulerAccount, oldOperator), OldOperatorStillInstalled());
+        (address asset0, address asset1) = _getAssets(newOperator);
 
-            // replace pool address in allPools array
-            _updateInArray(allPools, eulerAccountState[eulerAccount].allPoolsIndex, newOperator);
+        address[] storage poolMapArray = poolMap[asset0][asset1];
 
-            eulerAccountState[eulerAccount].pool = newOperator;
+        eulerAccountState[eulerAccount] = EulerAccountState({
+            pool: newOperator,
+            allPoolsIndex: uint48(allPools.length),
+            poolMapIndex: uint48(poolMapArray.length)
+        });
 
-            (address oldOpAsset0, address oldOpAsset1) = _getAssets(oldOperator);
+        allPools.push(newOperator);
+        poolMapArray.push(newOperator);
+    }
 
-            // if deploying new pool for same assets pair, just update poolMap without pop()
-            // else, we need to go the traditional path, reduce the array size, update eulerAccount poolMapIndex and push new one
-            if (oldOpAsset0 == newOpAsset0 && oldOpAsset1 == newOpAsset1) {
-                _updateInArray(
-                    poolMap[newOpAsset0][newOpAsset1], eulerAccountState[eulerAccount].poolMapIndex, newOperator
-                );
-            } else {
-                _removeFromArray(poolMap[oldOpAsset0][oldOpAsset1], eulerAccountState[eulerAccount].poolMapIndex);
+    /// @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;
 
-                eulerAccountState[eulerAccount].poolMapIndex = uint48(poolMap[newOpAsset0][newOpAsset1].length);
+        if (pool == address(0)) return;
 
-                _pushInArray(poolMap[newOpAsset0][newOpAsset1], newOperator);
-            }
+        require(!evc.isAccountOperatorAuthorized(eulerAccount, pool), OldOperatorStillInstalled());
 
-            emit PoolUninstalled(oldOpAsset0, oldOpAsset1, eulerAccount, oldOperator);
-        } else {
-            address[] storage poolMapArray = poolMap[newOpAsset0][newOpAsset1];
+        (address asset0, address asset1) = _getAssets(pool);
 
-            eulerAccountState[eulerAccount] = EulerAccountState({
-                pool: newOperator,
-                allPoolsIndex: uint48(allPools.length),
-                poolMapIndex: uint48(poolMapArray.length)
-            });
+        address[] storage poolMapArr = poolMap[asset0][asset1];
 
-            _pushInArray(allPools, newOperator);
-            _pushInArray(poolMapArray, newOperator);
-        }
-    }
+        swapAndPop(allPools, eulerAccountState[eulerAccount].allPoolsIndex);
+        swapAndPop(poolMapArr, eulerAccountState[eulerAccount].poolMapIndex);
 
-    /// @notice Updates an element at a specific index in an array
-    /// @dev Directly modifies the array element at the given index with a new value
-    /// @param arr The storage array to update
-    /// @param index The index of the element to update
-    /// @param _newValue The new value to set at the specified index
-    function _updateInArray(address[] storage arr, uint256 index, address _newValue) internal {
-        arr[index] = _newValue;
-    }
+        delete eulerAccountState[eulerAccount];
 
-    /// @notice Adds a new element to the end of an array
-    /// @dev Uses the push operation to append a new value to the array
-    /// @param arr The storage array to append to
-    /// @param _newValue The new value to append to the array
-    function _pushInArray(address[] storage arr, address _newValue) internal {
-        arr.push(_newValue);
+        emit PoolUninstalled(asset0, asset1, eulerAccount, pool);
     }
 
-    /// @notice Removes an element from an array at a specific index
-    /// @dev Uses the swap-and-pop pattern to remove an element while maintaining array order
-    /// @param arr The storage array to remove from
+    /// @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 _removeFromArray(address[] storage arr, uint256 index) internal {
+    function swapAndPop(address[] storage arr, uint256 index) internal {
         arr[index] = arr[arr.length - 1];
         arr.pop();
     }

src/interfaces/IEulerSwapFactory.sol

@@ -22,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
@@ -82,7 +88,7 @@ interface IEulerSwapFactory {
     /// @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 poolByHolder(address who) external view returns (address);
+    function poolByEulerAccount(address who) external view returns (address);
 
     /// @notice Returns the total number of deployed pools
     /// @dev Returns the length of the allPools array

test/EulerSwapFactoryTest.t.sol

@@ -63,7 +63,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         vm.prank(holder);
         evc.batch(items);
 
-        address eulerSwap = eulerSwapFactory.poolByHolder(holder);
+        address eulerSwap = eulerSwapFactory.poolByEulerAccount(holder);
 
         uint256 allPoolsLengthAfter = eulerSwapFactory.poolsLength();
         assertEq(allPoolsLengthAfter - allPoolsLengthBefore, 1);
@@ -95,7 +95,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         evc.batch(items);
 
         // test deploying new pool for same assets pair as old one
-        address oldPool = eulerSwapFactory.poolByHolder(holder);
+        address oldPool = eulerSwapFactory.poolByEulerAccount(holder);
         salt = bytes32(uint256(123456));
         predictedAddress = predictPoolAddress(address(eulerSwapFactory), poolParams, curveParams, salt);
 
@@ -122,11 +122,11 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         vm.prank(holder);
         evc.batch(items);
 
-        address pool = eulerSwapFactory.poolByHolder(holder);
+        address pool = eulerSwapFactory.poolByEulerAccount(holder);
         assertEq(pool, predictedAddress);
 
         // test deploying new pool for different assets pair as old one
-        oldPool = eulerSwapFactory.poolByHolder(holder);
+        oldPool = eulerSwapFactory.poolByEulerAccount(holder);
         poolParams = IEulerSwap.Params(address(eTST), address(eTST3), holder, 1e18, 1e18, 1e18, 1e18, 0);
 
         salt = bytes32(uint256(1234567));
@@ -155,7 +155,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         vm.prank(holder);
         evc.batch(items);
 
-        pool = eulerSwapFactory.poolByHolder(holder);
+        pool = eulerSwapFactory.poolByEulerAccount(holder);
         assertEq(pool, predictedAddress);
     }
 
@@ -241,7 +241,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         evc.batch(items);
 
         // Get the deployed pool and its assets
-        address pool = eulerSwapFactory.poolByHolder(holder);
+        address pool = eulerSwapFactory.poolByEulerAccount(holder);
         address asset0 = EulerSwap(pool).asset0();
         address asset1 = EulerSwap(pool).asset1();