feat: use create2 & check operator

Author: haythemsellami

src/EulerSwapFactory.sol

@@ -3,15 +3,16 @@ pragma solidity ^0.8.27;
 
 import {IEulerSwapFactory} from "./interfaces/IEulerSwapFactory.sol";
 import {IEulerSwap, EulerSwap} from "./EulerSwap.sol";
+import {EVCUtil} from "ethereum-vault-connector/utils/EVCUtil.sol";
 
 /// @title EulerSwapFactory contract
 /// @custom:security-contact [email protected]
 /// @author Euler Labs (https://www.eulerlabs.com/)
-contract EulerSwapFactory is IEulerSwapFactory {
+contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     /// @dev An array to store all pools addresses.
     address[] public allPools;
-    /// @dev Mapping to store pool addresses
-    mapping(bytes32 poolKey => address pool) public getPool;
+    /// @dev Mapping between a swap account and deployed pool that is currently set as operator
+    mapping(address swapAccount => address operator) public swapAccountToPool;
 
     event PoolDeployed(
         address indexed asset0,
@@ -28,11 +29,17 @@ contract EulerSwapFactory is IEulerSwapFactory {
     );
 
     error InvalidQuery();
-    error AlreadyDeployed();
+    error Unauthorized();
+    error OldOperatorStillInstalled();
+    error OperatorNotInstalled();
+
+    constructor(address evc) EVCUtil(evc) {}
 
     /// @notice Deploy EulerSwap pool.
-    function deployPool(DeployParams memory params) external returns (address) {
-        EulerSwap pool = new EulerSwap(
+    function deployPool(DeployParams memory params, bytes32 salt) external returns (address) {
+        require(_msgSender() == params.swapAccount, Unauthorized());
+
+        EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.swapAccount, salt))}(
             IEulerSwap.Params({
                 vault0: params.vault0,
                 vault1: params.vault1,
@@ -49,38 +56,18 @@ contract EulerSwapFactory is IEulerSwapFactory {
             })
         );
 
-        address poolAsset0 = pool.asset0();
-        address poolAsset1 = pool.asset1();
-        uint256 feeMultiplier = pool.feeMultiplier();
-
-        {
-            bytes32 poolKey = keccak256(
-                abi.encode(
-                    poolAsset0,
-                    poolAsset1,
-                    params.vault0,
-                    params.vault1,
-                    params.swapAccount,
-                    feeMultiplier,
-                    params.priceX,
-                    params.priceY,
-                    params.concentrationX,
-                    params.concentrationY
-                )
-            );
-
-            require(getPool[poolKey] == address(0), AlreadyDeployed());
-
-            getPool[poolKey] = address(pool);
-            allPools.push(address(pool));
-        }
+        checkSwapAccountOperators(params.swapAccount, address(pool));
+
+        EulerSwap(pool).activate();
+
+        allPools.push(address(pool));
 
         emit PoolDeployed(
-            poolAsset0,
-            poolAsset1,
+            pool.asset0(),
+            pool.asset1(),
             params.vault0,
             params.vault1,
-            feeMultiplier,
+            pool.feeMultiplier(),
             params.swapAccount,
             params.priceX,
             params.priceY,
@@ -114,4 +101,16 @@ contract EulerSwapFactory is IEulerSwapFactory {
 
         return allPoolsList;
     }
+
+    function checkSwapAccountOperators(address swapAccount, address newPool) internal {
+        address operator = swapAccountToPool[swapAccount];
+
+        if (operator != address(0)) {
+            require(!evc.isAccountOperatorAuthorized(swapAccount, operator), OldOperatorStillInstalled());
+        }
+
+        require(evc.isAccountOperatorAuthorized(swapAccount, newPool), OperatorNotInstalled());
+
+        swapAccountToPool[swapAccount] = newPool;
+    }
 }

src/interfaces/IEulerSwapFactory.sol

@@ -15,10 +15,9 @@ interface IEulerSwapFactory {
         uint112 debtLimit1;
     }
 
-    function deployPool(DeployParams memory params) external returns (address);
+    function deployPool(DeployParams memory params, bytes32 salt) external returns (address);
 
     function allPools(uint256 index) external view returns (address);
-    function getPool(bytes32 poolKey) external view returns (address);
     function allPoolsLength() external view returns (uint256);
     function getAllPoolsListSlice(uint256 start, uint256 end) external view returns (address[] memory);
 }

test/EulerSwapFactoryTest.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.24;
 
-import {EulerSwapTestBase, EulerSwap} from "./EulerSwapTestBase.t.sol";
+import {EulerSwapTestBase, IEulerSwap, IEVC, EulerSwap} from "./EulerSwapTestBase.t.sol";
 import {EulerSwapFactory, IEulerSwapFactory} from "../src/EulerSwapFactory.sol";
 
 contract EulerSwapFactoryTest is EulerSwapTestBase {
@@ -13,53 +13,58 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         super.setUp();
 
         vm.prank(creator);
-        eulerSwapFactory = new EulerSwapFactory();
+        eulerSwapFactory = new EulerSwapFactory(address(evc));
     }
 
     function testDeployPool() public {
         uint256 allPoolsLengthBefore = eulerSwapFactory.allPoolsLength();
 
-        vm.prank(creator);
-        EulerSwap eulerSwap = EulerSwap(
-            eulerSwapFactory.deployPool(
-                IEulerSwapFactory.DeployParams(
-                    address(eTST), address(eTST2), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
-                )
-            )
+        IEulerSwapFactory.DeployParams memory deployParams = IEulerSwapFactory.DeployParams(
+            address(eTST), address(eTST2), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
         );
+        bytes32 salt = bytes32(uint256(1234));
 
-        uint256 allPoolsLengthAfter = eulerSwapFactory.allPoolsLength();
-        bytes32 poolKey = keccak256(
-            abi.encode(
-                eulerSwap.asset0(),
-                eulerSwap.asset1(),
-                eulerSwap.vault0(),
-                eulerSwap.vault1(),
-                eulerSwap.myAccount(),
-                eulerSwap.feeMultiplier(),
-                eulerSwap.priceX(),
-                eulerSwap.priceY(),
-                eulerSwap.concentrationX(),
-                eulerSwap.concentrationY()
-            )
-        );
+        address predictedAddress = predictPoolAddress(address(eulerSwapFactory), deployParams, salt);
+
+        IEVC.BatchItem[] memory items = new IEVC.BatchItem[](2);
 
+        items[0] = IEVC.BatchItem({
+            onBehalfOfAccount: address(0),
+            targetContract: address(evc),
+            value: 0,
+            data: abi.encodeCall(evc.setAccountOperator, (holder, predictedAddress, true))
+        });
+        items[1] = IEVC.BatchItem({
+            onBehalfOfAccount: holder,
+            targetContract: address(eulerSwapFactory),
+            value: 0,
+            data: abi.encodeCall(EulerSwapFactory.deployPool, (deployParams, salt))
+        });
+
+        vm.prank(holder);
+        evc.batch(items);
+
+        EulerSwap eulerSwap = EulerSwap(eulerSwapFactory.swapAccountToPool(holder));
+
+        uint256 allPoolsLengthAfter = eulerSwapFactory.allPoolsLength();
         assertEq(allPoolsLengthAfter - allPoolsLengthBefore, 1);
-        assertEq(eulerSwapFactory.getPool(poolKey), address(eulerSwap));
-        assertEq(eulerSwapFactory.getPool(poolKey), address(eulerSwap));
 
         address[] memory poolsList = eulerSwapFactory.getAllPoolsListSlice(0, type(uint256).max);
         assertEq(poolsList.length, 1);
         assertEq(poolsList[0], address(eulerSwap));
         assertEq(eulerSwapFactory.allPools(0), address(eulerSwap));
 
-        vm.prank(creator);
-        vm.expectRevert(EulerSwapFactory.AlreadyDeployed.selector);
-        eulerSwapFactory.deployPool(
-            IEulerSwapFactory.DeployParams(
-                address(eTST), address(eTST2), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
-            )
-        );
+        items = new IEVC.BatchItem[](1);
+        items[0] = IEVC.BatchItem({
+            onBehalfOfAccount: holder,
+            targetContract: address(eulerSwapFactory),
+            value: 0,
+            data: abi.encodeCall(EulerSwapFactory.deployPool, (deployParams, bytes32(uint256(12345))))
+        });
+
+        vm.prank(holder);
+        vm.expectRevert(EulerSwapFactory.OldOperatorStillInstalled.selector);
+        evc.batch(items);   
     }
 
     function testInvalidGetAllPoolsListSliceQuery() public {
@@ -68,21 +73,68 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
     }
 
     function testDeployWithAssetsOutOfOrderOrEqual() public {
-        vm.prank(creator);
+        bytes32 salt = bytes32(uint256(1234));
+
+        vm.prank(holder);
         vm.expectRevert(EulerSwap.AssetsOutOfOrderOrEqual.selector);
         eulerSwapFactory.deployPool(
             IEulerSwapFactory.DeployParams(
                 address(eTST), address(eTST), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
-            )
+            ),
+            salt
         );
     }
 
     function testDeployWithBadFee() public {
-        vm.prank(creator);
+        bytes32 salt = bytes32(uint256(1234));
+
+        vm.prank(holder);
         vm.expectRevert(EulerSwap.BadFee.selector);
         eulerSwapFactory.deployPool(
             IEulerSwapFactory.DeployParams(
                 address(eTST), address(eTST2), holder, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
+            ),
+            salt
+        );
+    }
+
+    function predictPoolAddress(address factoryAddress, IEulerSwapFactory.DeployParams memory params, bytes32 salt)
+        internal
+        pure
+        returns (address)
+    {
+        return address(
+            uint160(
+                uint256(
+                    keccak256(
+                        abi.encodePacked(
+                            bytes1(0xff),
+                            factoryAddress,
+                            keccak256(abi.encode(address(params.swapAccount), salt)),
+                            keccak256(
+                                abi.encodePacked(
+                                    type(EulerSwap).creationCode,
+                                    abi.encode(
+                                        IEulerSwap.Params({
+                                            vault0: params.vault0,
+                                            vault1: params.vault1,
+                                            myAccount: params.swapAccount,
+                                            debtLimit0: params.debtLimit0,
+                                            debtLimit1: params.debtLimit1,
+                                            fee: params.fee
+                                        }),
+                                        IEulerSwap.CurveParams({
+                                            priceX: params.priceX,
+                                            priceY: params.priceY,
+                                            concentrationX: params.concentrationX,
+                                            concentrationY: params.concentrationY
+                                        })
+                                    )
+                                )
+                            )
+                        )
+                    )
+                )
             )
         );
     }

test/EulerSwapTestBase.t.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.24;
 import {Test, console} from "forge-std/Test.sol";
 import {EVaultTestBase, TestERC20} from "evk-test/unit/evault/EVaultTestBase.t.sol";
 import {IEVault} from "evk/EVault/IEVault.sol";
-import {IEulerSwap, EulerSwap} from "../src/EulerSwap.sol";
+import {IEulerSwap, IEVC, EulerSwap} from "../src/EulerSwap.sol";
 import {EulerSwapPeriphery} from "../src/EulerSwapPeriphery.sol";
 
 contract EulerSwapTestBase is EVaultTestBase {