update factory

Author: haythemsellami

foundry.toml

@@ -3,5 +3,8 @@ src = "src"
 out = "out"
 libs = ["lib"]
 solc = "0.8.27"
+optimizer = true
+optimizer_runs = 800
+gas_reports = ["*"]
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

src/MaglevEulerSwapFactory.sol

@@ -18,7 +18,7 @@ contract MaglevEulerSwapFactory is IMaglevEulerSwapFactory, Ownable {
     /// @dev An array to store all pools addresses.
     address[] public allPools;
     /// @dev Mapping from asset0/asset1/fee => pool address.
-    mapping(address => mapping(address => mapping(uint256 => address))) public getPool;
+    mapping(bytes32 => address) public getPool;
 
     constructor(address evcAddr) Ownable(msg.sender) {
         evc = evcAddr;
@@ -29,13 +29,13 @@ contract MaglevEulerSwapFactory is IMaglevEulerSwapFactory, Ownable {
         address vault0,
         address vault1,
         address holder,
-        uint112 debtLimit0,
-        uint112 debtLimit1,
         uint256 fee,
         uint256 priceX,
         uint256 priceY,
         uint256 concentrationX,
-        uint256 concentrationY
+        uint256 concentrationY,
+        uint112 debtLimit0,
+        uint112 debtLimit1
     ) external onlyOwner returns (address) {
         Maglev pool = new Maglev(
             MaglevBase.BaseParams({
@@ -58,11 +58,18 @@ contract MaglevEulerSwapFactory is IMaglevEulerSwapFactory, Ownable {
         address poolAsset0 = pool.asset0();
         address poolAsset1 = pool.asset1();
         uint256 feeMultiplier = pool.feeMultiplier();
+        address myAccount = pool.myAccount();
+        uint256 priceX = pool.priceX();
+        uint256 priceY = pool.priceY();
+        uint256 concentrationX = pool.concentrationX();
+        uint256 concentrationY = pool.concentrationY();
 
-        getPool[poolAsset0][poolAsset1][feeMultiplier] = address(pool);
-        // populate mapping in the reverse direction, deliberate choice to avoid the cost of comparing addresses
-        getPool[poolAsset1][poolAsset0][feeMultiplier] = address(pool);
 
+        bytes32 poolKey = keccak256(
+            abi.encode(poolAsset0, poolAsset1, feeMultiplier, myAccount, priceX, priceY, concentrationX, concentrationY)
+        );
+
+        getPool[poolKey] = address(pool);
         allPools.push(address(pool));
 
         emit PoolDeployed(poolAsset0, poolAsset1, feeMultiplier, address(pool));

src/interfaces/IMaglevEulerSwapFactory.sol

@@ -6,18 +6,18 @@ interface IMaglevEulerSwapFactory {
         address vault0,
         address vault1,
         address holder,
-        uint112 debtLimit0,
-        uint112 debtLimit1,
         uint256 fee,
         uint256 priceX,
         uint256 priceY,
         uint256 concentrationX,
-        uint256 concentrationY
+        uint256 concentrationY,
+        uint112 debtLimit0,
+        uint112 debtLimit1
     ) external returns (address);
 
     function evc() external view returns (address);
     function allPools(uint256 index) external view returns (address);
-    function getPool(address assetA, address assetB, uint256 fee) 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/MaglevEulerSwapFactoryTest.t.sol

@@ -26,15 +26,27 @@ contract MaglevEulerSwapFactoryTest is MaglevTestBase {
         vm.prank(creator);
         Maglev maglev = Maglev(
             eulerSwapFactory.deployPool(
-                address(eTST), address(eTST2), holder, 50e18, 50e18, 0, 1e18, 1e18, 0.4e18, 0.85e18
+                address(eTST), address(eTST2), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
             )
         );
 
         uint256 allPoolsLengthAfter = eulerSwapFactory.allPoolsLength();
+        bytes32 poolKey = keccak256(
+            abi.encode(
+                maglev.asset0(),
+                maglev.asset1(),
+                maglev.feeMultiplier(),
+                maglev.myAccount(),
+                maglev.priceX(),
+                maglev.priceY(),
+                maglev.concentrationX(),
+                maglev.concentrationY()
+            )
+        );
 
         assertEq(allPoolsLengthAfter - allPoolsLengthBefore, 1);
-        assertEq(eulerSwapFactory.getPool(maglev.asset0(), maglev.asset1(), maglev.feeMultiplier()), address(maglev));
-        assertEq(eulerSwapFactory.getPool(maglev.asset1(), maglev.asset0(), maglev.feeMultiplier()), address(maglev));
+        assertEq(eulerSwapFactory.getPool(poolKey), address(maglev));
+        assertEq(eulerSwapFactory.getPool(poolKey), address(maglev));
 
         address[] memory poolsList = eulerSwapFactory.getAllPoolsListSlice(0, type(uint256).max);
         assertEq(poolsList.length, 1);
@@ -50,14 +62,14 @@ contract MaglevEulerSwapFactoryTest is MaglevTestBase {
     function testDeployWithUnsupportedPair() public {
         vm.prank(creator);
         vm.expectRevert(MaglevBase.UnsupportedPair.selector);
-        eulerSwapFactory.deployPool(address(eTST), address(eTST), holder, 50e18, 50e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
+        eulerSwapFactory.deployPool(address(eTST), address(eTST), holder, 0, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18);
     }
 
     function testDeployWithBadFee() public {
         vm.prank(creator);
         vm.expectRevert(MaglevBase.BadFee.selector);
         eulerSwapFactory.deployPool(
-            address(eTST), address(eTST2), holder, 50e18, 50e18, 1e18, 1e18, 1e18, 0.4e18, 0.85e18
+            address(eTST), address(eTST2), holder, 1e18, 1e18, 1e18, 0.4e18, 0.85e18, 50e18, 50e18
         );
     }
 }