Merge pull request #32 from euler-xyz/chore-rename_to_eulerAccount

Chore: rename to eulerAccount

Author: leemount96

docs/interfaces.md

@@ -42,7 +42,7 @@ The `IEulerSwap` interface defines the core functionality for executing token sw
 
 - **description**: Returns the address of asset 1.
 
-#### `myAccount() external view returns (address);`
+#### `eulerAccount() external view returns (address);`
 
 - **description**: Returns the address of the account managing EulerSwap.
 

src/EulerSwap.sol

@@ -20,7 +20,7 @@ contract EulerSwap is IEulerSwap, EVCUtil {
     address public immutable vault1;
     address public immutable asset0;
     address public immutable asset1;
-    address public immutable myAccount;
+    address public immutable eulerAccount;
     uint112 public immutable debtLimit0;
     uint112 public immutable debtLimit1;
     uint112 public immutable initialReserve0;
@@ -82,7 +82,7 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         vault1 = params.vault1;
         asset0 = asset0Addr;
         asset1 = asset1Addr;
-        myAccount = params.myAccount;
+        eulerAccount = params.eulerAccount;
         debtLimit0 = params.debtLimit0;
         debtLimit1 = params.debtLimit1;
         initialReserve0 = reserve0 = offsetReserve(params.debtLimit0, params.vault0);
@@ -178,8 +178,8 @@ contract EulerSwap is IEulerSwap, EVCUtil {
             IAllowanceTransfer(permit2).approve(asset1, vault1, type(uint160).max, type(uint48).max);
         }
 
-        IEVC(evc).enableCollateral(myAccount, vault0);
-        IEVC(evc).enableCollateral(myAccount, vault1);
+        IEVC(evc).enableCollateral(eulerAccount, vault0);
+        IEVC(evc).enableCollateral(eulerAccount, vault1);
     }
 
     /// @inheritdoc IEulerSwap
@@ -198,42 +198,42 @@ contract EulerSwap is IEulerSwap, EVCUtil {
 
         if (balance > 0) {
             uint256 avail = amount < balance ? amount : balance;
-            IEVC(evc).call(vault, myAccount, 0, abi.encodeCall(IERC4626.withdraw, (avail, to, myAccount)));
+            IEVC(evc).call(vault, eulerAccount, 0, abi.encodeCall(IERC4626.withdraw, (avail, to, eulerAccount)));
             amount -= avail;
         }
 
         if (amount > 0) {
-            IEVC(evc).enableController(myAccount, vault);
-            IEVC(evc).call(vault, myAccount, 0, abi.encodeCall(IBorrowing.borrow, (amount, to)));
+            IEVC(evc).enableController(eulerAccount, vault);
+            IEVC(evc).call(vault, eulerAccount, 0, abi.encodeCall(IBorrowing.borrow, (amount, to)));
         }
     }
 
     function depositAssets(address vault, uint256 amount) internal returns (uint256) {
-        try IEVault(vault).deposit(amount, myAccount) {}
+        try IEVault(vault).deposit(amount, eulerAccount) {}
         catch (bytes memory reason) {
             require(bytes4(reason) == EVKErrors.E_ZeroShares.selector, DepositFailure(reason));
             return 0;
         }
 
-        if (IEVC(evc).isControllerEnabled(myAccount, vault)) {
+        if (IEVC(evc).isControllerEnabled(eulerAccount, vault)) {
             IEVC(evc).call(
-                vault, myAccount, 0, abi.encodeCall(IBorrowing.repayWithShares, (type(uint256).max, myAccount))
+                vault, eulerAccount, 0, abi.encodeCall(IBorrowing.repayWithShares, (type(uint256).max, eulerAccount))
             );
 
             if (myDebt(vault) == 0) {
-                IEVC(evc).call(vault, myAccount, 0, abi.encodeCall(IRiskManager.disableController, ()));
+                IEVC(evc).call(vault, eulerAccount, 0, abi.encodeCall(IRiskManager.disableController, ()));
             }
         }
 
         return amount;
     }
 
     function myDebt(address vault) internal view returns (uint256) {
-        return IEVault(vault).debtOf(myAccount);
+        return IEVault(vault).debtOf(eulerAccount);
     }
 
     function myBalance(address vault) internal view returns (uint256) {
-        uint256 shares = IEVault(vault).balanceOf(myAccount);
+        uint256 shares = IEVault(vault).balanceOf(eulerAccount);
         return shares == 0 ? 0 : IEVault(vault).convertToAssets(shares);
     }
 

src/EulerSwapFactory.sol

@@ -11,16 +11,16 @@ import {EVCUtil} from "ethereum-vault-connector/utils/EVCUtil.sol";
 contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
     /// @dev An array to store all pools addresses.
     address[] public allPools;
-    /// @dev Mapping between a swap account and deployed pool that is currently set as operator
-    mapping(address swapAccount => address operator) public swapAccountToPool;
+    /// @dev Mapping between euler account and deployed pool that is currently set as operator
+    mapping(address eulerAccount => address operator) public eulerAccountToPool;
 
     event PoolDeployed(
         address indexed asset0,
         address indexed asset1,
         address vault0,
         address vault1,
         uint256 indexed feeMultiplier,
-        address swapAccount,
+        address eulerAccount,
         uint256 priceX,
         uint256 priceY,
         uint256 concentrationX,
@@ -37,7 +37,7 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
 
     /// @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 swap account address and provided salt parameter. This allows the pool address to be
+    ///      the euler account address and provided salt parameter. This allows the pool address to be
     ///      predicted before deployment.
     /// @param params Core pool parameters including vaults, account, and fee settings
     /// @param curveParams Parameters defining the curve shape including prices and concentrations
@@ -47,11 +47,11 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         external
         returns (address)
     {
-        require(_msgSender() == params.myAccount, Unauthorized());
+        require(_msgSender() == params.eulerAccount, Unauthorized());
 
-        EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.myAccount, salt))}(params, curveParams);
+        EulerSwap pool = new EulerSwap{salt: keccak256(abi.encode(params.eulerAccount, salt))}(params, curveParams);
 
-        checkSwapAccountOperators(params.myAccount, address(pool));
+        checkEulerAccountOperators(params.eulerAccount, address(pool));
 
         allPools.push(address(pool));
 
@@ -63,7 +63,7 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
             params.vault0,
             params.vault1,
             pool.feeMultiplier(),
-            params.myAccount,
+            params.eulerAccount,
             curveParams.priceX,
             curveParams.priceY,
             curveParams.concentrationX,
@@ -97,20 +97,20 @@ contract EulerSwapFactory is IEulerSwapFactory, EVCUtil {
         return allPoolsList;
     }
 
-    /// @notice Validates operator authorization for a swap account. First checks if the account has an existing operator
+    /// @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.
-    /// @param swapAccount The address of the swap account.
+    /// @param eulerAccount The address of the euler account.
     /// @param newPool The address of the new pool.
-    function checkSwapAccountOperators(address swapAccount, address newPool) internal {
-        address operator = swapAccountToPool[swapAccount];
+    function checkEulerAccountOperators(address eulerAccount, address newPool) internal {
+        address operator = eulerAccountToPool[eulerAccount];
 
         if (operator != address(0)) {
-            require(!evc.isAccountOperatorAuthorized(swapAccount, operator), OldOperatorStillInstalled());
+            require(!evc.isAccountOperatorAuthorized(eulerAccount, operator), OldOperatorStillInstalled());
         }
 
-        require(evc.isAccountOperatorAuthorized(swapAccount, newPool), OperatorNotInstalled());
+        require(evc.isAccountOperatorAuthorized(eulerAccount, newPool), OperatorNotInstalled());
 
-        swapAccountToPool[swapAccount] = newPool;
+        eulerAccountToPool[eulerAccount] = newPool;
     }
 }

src/EulerSwapPeriphery.sol

@@ -89,7 +89,7 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         returns (uint256)
     {
         require(
-            IEVC(eulerSwap.EVC()).isAccountOperatorAuthorized(eulerSwap.myAccount(), address(eulerSwap)),
+            IEVC(eulerSwap.EVC()).isAccountOperatorAuthorized(eulerSwap.eulerAccount(), address(eulerSwap)),
             OperatorNotInstalled()
         );
 

src/interfaces/IEulerSwap.sol

@@ -5,7 +5,7 @@ interface IEulerSwap {
     struct Params {
         address vault0;
         address vault1;
-        address myAccount;
+        address eulerAccount;
         uint112 debtLimit0;
         uint112 debtLimit1;
         uint256 fee;
@@ -45,7 +45,7 @@ interface IEulerSwap {
     function vault1() external view returns (address);
     function asset0() external view returns (address);
     function asset1() external view returns (address);
-    function myAccount() external view returns (address);
+    function eulerAccount() external view returns (address);
     function initialReserve0() external view returns (uint112);
     function initialReserve1() external view returns (uint112);
     function feeMultiplier() external view returns (uint256);

test/EulerSwapFactoryTest.t.sol

@@ -43,7 +43,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
         vm.prank(holder);
         evc.batch(items);
 
-        EulerSwap eulerSwap = EulerSwap(eulerSwapFactory.swapAccountToPool(holder));
+        EulerSwap eulerSwap = EulerSwap(eulerSwapFactory.eulerAccountToPool(holder));
 
         uint256 allPoolsLengthAfter = eulerSwapFactory.allPoolsLength();
         assertEq(allPoolsLengthAfter - allPoolsLengthBefore, 1);
@@ -104,7 +104,7 @@ contract EulerSwapFactoryTest is EulerSwapTestBase {
                         abi.encodePacked(
                             bytes1(0xff),
                             factoryAddress,
-                            keccak256(abi.encode(address(poolParams.myAccount), salt)),
+                            keccak256(abi.encode(address(poolParams.eulerAccount), salt)),
                             keccak256(
                                 abi.encodePacked(type(EulerSwap).creationCode, abi.encode(poolParams, curveParams))
                             )

test/EulerSwapTestBase.t.sol

@@ -149,7 +149,7 @@ contract EulerSwapTestBase is EVaultTestBase {
         return IEulerSwap.Params({
             vault0: address(eTST),
             vault1: address(eTST2),
-            myAccount: holder,
+            eulerAccount: holder,
             debtLimit0: debtLimitA,
             debtLimit1: debtLimitB,
             fee: fee