Remove Address in naming

src/aave-v2/ExitPositionsManager.sol

@@ -239,15 +239,15 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
             _getUserBorrowBalanceInOf(_poolTokenBorrowed, _borrower).percentMul(vars.closeFactor) // Max liquidatable debt.
         );
 
-        address tokenBorrowedAddress = borrowMarket.underlyingToken;
-        address tokenCollateralAddress = market[_poolTokenCollateral].underlyingToken;
+        address tokenBorrowed = borrowMarket.underlyingToken;
+        address tokenCollateral = market[_poolTokenCollateral].underlyingToken;
 
         ILendingPool poolMem = pool;
         (, , vars.liquidationBonus, vars.collateralReserveDecimals, ) = poolMem
-        .getConfiguration(tokenCollateralAddress)
+        .getConfiguration(tokenCollateral)
         .getParamsMemory();
         (, , , vars.borrowedReserveDecimals, ) = poolMem
-        .getConfiguration(tokenBorrowedAddress)
+        .getConfiguration(tokenBorrowed)
         .getParamsMemory();
 
         unchecked {
@@ -256,8 +256,8 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
         }
 
         IPriceOracleGetter oracle = IPriceOracleGetter(addressesProvider.getPriceOracle());
-        vars.borrowedTokenPrice = oracle.getAssetPrice(tokenBorrowedAddress);
-        vars.collateralPrice = oracle.getAssetPrice(tokenCollateralAddress);
+        vars.borrowedTokenPrice = oracle.getAssetPrice(tokenBorrowed);
+        vars.collateralPrice = oracle.getAssetPrice(tokenCollateral);
         vars.amountToSeize = ((vars.amountToLiquidate *
             vars.borrowedTokenPrice *
             vars.collateralTokenUnit) / (vars.borrowedTokenUnit * vars.collateralPrice))

src/aave-v2/MatchingEngine.sol

@@ -338,15 +338,15 @@ abstract contract MatchingEngine is MorphoUtils {
         marketBorrowersInP2P.update(_user, formerValueInP2P, inP2P, maxSortedUsers);
 
         if (formerValueOnPool != onPool && address(rewardsManager) != address(0)) {
-            address variableDebtTokenAddress = pool
+            address variableDebtToken = pool
             .getReserveData(market[_poolToken].underlyingToken)
             .variableDebtTokenAddress;
             rewardsManager.updateUserAssetAndAccruedRewards(
                 aaveIncentivesController,
                 _user,
-                variableDebtTokenAddress,
+                variableDebtToken,
                 formerValueOnPool,
-                IScaledBalanceToken(variableDebtTokenAddress).scaledTotalSupply()
+                IScaledBalanceToken(variableDebtToken).scaledTotalSupply()
             );
         }
     }

src/compound/RewardsManager.sol

@@ -60,97 +60,97 @@ contract RewardsManager is IRewardsManager, Initializable {
     /// EXTERNAL ///
 
     /// @notice Returns the local COMP supply state.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @return The local COMP supply state.
-    function getLocalCompSupplyState(address _cTokenAddress)
+    function getLocalCompSupplyState(address _poolToken)
         external
         view
         returns (IComptroller.CompMarketState memory)
     {
-        return localCompSupplyState[_cTokenAddress];
+        return localCompSupplyState[_poolToken];
     }
 
     /// @notice Returns the local COMP borrow state.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @return The local COMP borrow state.
-    function getLocalCompBorrowState(address _cTokenAddress)
+    function getLocalCompBorrowState(address _poolToken)
         external
         view
         returns (IComptroller.CompMarketState memory)
     {
-        return localCompBorrowState[_cTokenAddress];
+        return localCompBorrowState[_poolToken];
     }
 
     /// @notice Accrues unclaimed COMP rewards for the given cToken addresses and returns the total COMP unclaimed rewards.
     /// @dev This function is called by the `morpho` to accrue COMP rewards and reset them to 0.
     /// @dev The transfer of tokens is done in the `morpho`.
-    /// @param _cTokenAddresses The cToken addresses for which to claim rewards.
+    /// @param _poolTokens The cToken addresses for which to claim rewards.
     /// @param _user The address of the user.
-    function claimRewards(address[] calldata _cTokenAddresses, address _user)
+    function claimRewards(address[] calldata _poolTokens, address _user)
         external
         onlyMorpho
         returns (uint256 totalUnclaimedRewards)
     {
-        totalUnclaimedRewards = _accrueUserUnclaimedRewards(_cTokenAddresses, _user);
+        totalUnclaimedRewards = _accrueUserUnclaimedRewards(_poolTokens, _user);
         if (totalUnclaimedRewards > 0) userUnclaimedCompRewards[_user] = 0;
     }
 
     /// @notice Updates the unclaimed COMP rewards of the user.
     /// @param _user The address of the user.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @param _userBalance The user balance of tokens in the distribution.
     function accrueUserSupplyUnclaimedRewards(
         address _user,
-        address _cTokenAddress,
+        address _poolToken,
         uint256 _userBalance
     ) external onlyMorpho {
-        _updateSupplyIndex(_cTokenAddress);
-        userUnclaimedCompRewards[_user] += _accrueSupplierComp(_user, _cTokenAddress, _userBalance);
+        _updateSupplyIndex(_poolToken);
+        userUnclaimedCompRewards[_user] += _accrueSupplierComp(_user, _poolToken, _userBalance);
     }
 
     /// @notice Updates the unclaimed COMP rewards of the user.
     /// @param _user The address of the user.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @param _userBalance The user balance of tokens in the distribution.
     function accrueUserBorrowUnclaimedRewards(
         address _user,
-        address _cTokenAddress,
+        address _poolToken,
         uint256 _userBalance
     ) external onlyMorpho {
-        _updateBorrowIndex(_cTokenAddress);
-        userUnclaimedCompRewards[_user] += _accrueBorrowerComp(_user, _cTokenAddress, _userBalance);
+        _updateBorrowIndex(_poolToken);
+        userUnclaimedCompRewards[_user] += _accrueBorrowerComp(_user, _poolToken, _userBalance);
     }
 
     /// INTERNAL ///
 
     /// @notice Accrues unclaimed COMP rewards for the cToken addresses and returns the total unclaimed COMP rewards.
-    /// @param _cTokenAddresses The cToken addresses for which to accrue rewards.
+    /// @param _poolTokens The cToken addresses for which to accrue rewards.
     /// @param _user The address of the user.
     /// @return unclaimedRewards The user unclaimed rewards.
-    function _accrueUserUnclaimedRewards(address[] calldata _cTokenAddresses, address _user)
+    function _accrueUserUnclaimedRewards(address[] calldata _poolTokens, address _user)
         internal
         returns (uint256 unclaimedRewards)
     {
         unclaimedRewards = userUnclaimedCompRewards[_user];
 
-        for (uint256 i; i < _cTokenAddresses.length; ) {
-            address cTokenAddress = _cTokenAddresses[i];
+        for (uint256 i; i < _poolTokens.length; ) {
+            address poolToken = _poolTokens[i];
 
-            (bool isListed, , ) = comptroller.markets(cTokenAddress);
+            (bool isListed, , ) = comptroller.markets(poolToken);
             if (!isListed) revert InvalidCToken();
 
-            _updateSupplyIndex(cTokenAddress);
+            _updateSupplyIndex(poolToken);
             unclaimedRewards += _accrueSupplierComp(
                 _user,
-                cTokenAddress,
-                morpho.supplyBalanceInOf(cTokenAddress, _user).onPool
+                poolToken,
+                morpho.supplyBalanceInOf(poolToken, _user).onPool
             );
 
-            _updateBorrowIndex(cTokenAddress);
+            _updateBorrowIndex(poolToken);
             unclaimedRewards += _accrueBorrowerComp(
                 _user,
-                cTokenAddress,
-                morpho.borrowBalanceInOf(cTokenAddress, _user).onPool
+                poolToken,
+                morpho.borrowBalanceInOf(poolToken, _user).onPool
             );
 
             unchecked {
@@ -163,91 +163,87 @@ contract RewardsManager is IRewardsManager, Initializable {
 
     /// @notice Updates supplier index and returns the accrued COMP rewards of the supplier since the last update.
     /// @param _supplier The address of the supplier.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @param _balance The user balance of tokens in the distribution.
     /// @return The accrued COMP rewards.
     function _accrueSupplierComp(
         address _supplier,
-        address _cTokenAddress,
+        address _poolToken,
         uint256 _balance
     ) internal returns (uint256) {
-        uint256 supplyIndex = localCompSupplyState[_cTokenAddress].index;
-        uint256 supplierIndex = compSupplierIndex[_cTokenAddress][_supplier];
-        compSupplierIndex[_cTokenAddress][_supplier] = supplyIndex;
+        uint256 supplyIndex = localCompSupplyState[_poolToken].index;
+        uint256 supplierIndex = compSupplierIndex[_poolToken][_supplier];
+        compSupplierIndex[_poolToken][_supplier] = supplyIndex;
 
         if (supplierIndex == 0) return 0;
         return (_balance * (supplyIndex - supplierIndex)) / 1e36;
     }
 
     /// @notice Updates borrower index and returns the accrued COMP rewards of the borrower since the last update.
     /// @param _borrower The address of the borrower.
-    /// @param _cTokenAddress The cToken address.
+    /// @param _poolToken The cToken address.
     /// @param _balance The user balance of tokens in the distribution.
     /// @return The accrued COMP rewards.
     function _accrueBorrowerComp(
         address _borrower,
-        address _cTokenAddress,
+        address _poolToken,
         uint256 _balance
     ) internal returns (uint256) {
-        uint256 borrowIndex = localCompBorrowState[_cTokenAddress].index;
-        uint256 borrowerIndex = compBorrowerIndex[_cTokenAddress][_borrower];
-        compBorrowerIndex[_cTokenAddress][_borrower] = borrowIndex;
+        uint256 borrowIndex = localCompBorrowState[_poolToken].index;
+        uint256 borrowerIndex = compBorrowerIndex[_poolToken][_borrower];
+        compBorrowerIndex[_poolToken][_borrower] = borrowIndex;
 
         if (borrowerIndex == 0) return 0;
         return (_balance * (borrowIndex - borrowerIndex)) / 1e36;
     }
 
     /// @notice Updates the COMP supply index.
-    /// @param _cTokenAddress The cToken address.
-    function _updateSupplyIndex(address _cTokenAddress) internal {
-        IComptroller.CompMarketState storage localSupplyState = localCompSupplyState[
-            _cTokenAddress
-        ];
+    /// @param _poolToken The cToken address.
+    function _updateSupplyIndex(address _poolToken) internal {
+        IComptroller.CompMarketState storage localSupplyState = localCompSupplyState[_poolToken];
 
         if (localSupplyState.block == block.number) return;
         else {
             IComptroller.CompMarketState memory supplyState = comptroller.compSupplyState(
-                _cTokenAddress
+                _poolToken
             );
 
             uint256 deltaBlocks = block.number - supplyState.block;
-            uint256 supplySpeed = comptroller.compSupplySpeeds(_cTokenAddress);
+            uint256 supplySpeed = comptroller.compSupplySpeeds(_poolToken);
 
             uint224 newCompSupplyIndex;
             if (deltaBlocks > 0 && supplySpeed > 0) {
-                uint256 supplyTokens = ICToken(_cTokenAddress).totalSupply();
+                uint256 supplyTokens = ICToken(_poolToken).totalSupply();
                 uint256 compAccrued = deltaBlocks * supplySpeed;
                 uint256 ratio = supplyTokens > 0 ? (compAccrued * 1e36) / supplyTokens : 0;
 
                 newCompSupplyIndex = uint224(supplyState.index + ratio);
             } else newCompSupplyIndex = supplyState.index;
 
-            localCompSupplyState[_cTokenAddress] = IComptroller.CompMarketState({
+            localCompSupplyState[_poolToken] = IComptroller.CompMarketState({
                 index: newCompSupplyIndex,
                 block: CompoundMath.safe32(block.number)
             });
         }
     }
 
     /// @notice Updates the COMP borrow index.
-    /// @param _cTokenAddress The cToken address.
-    function _updateBorrowIndex(address _cTokenAddress) internal {
-        IComptroller.CompMarketState storage localBorrowState = localCompBorrowState[
-            _cTokenAddress
-        ];
+    /// @param _poolToken The cToken address.
+    function _updateBorrowIndex(address _poolToken) internal {
+        IComptroller.CompMarketState storage localBorrowState = localCompBorrowState[_poolToken];
 
         if (localBorrowState.block == block.number) return;
         else {
             IComptroller.CompMarketState memory borrowState = comptroller.compBorrowState(
-                _cTokenAddress
+                _poolToken
             );
 
             uint256 deltaBlocks = block.number - borrowState.block;
-            uint256 borrowSpeed = comptroller.compBorrowSpeeds(_cTokenAddress);
+            uint256 borrowSpeed = comptroller.compBorrowSpeeds(_poolToken);
 
             uint224 newCompBorrowIndex;
             if (deltaBlocks > 0 && borrowSpeed > 0) {
-                ICToken cToken = ICToken(_cTokenAddress);
+                ICToken cToken = ICToken(_poolToken);
 
                 uint256 borrowAmount = cToken.totalBorrows().div(cToken.borrowIndex());
                 uint256 compAccrued = deltaBlocks * borrowSpeed;
@@ -256,7 +252,7 @@ contract RewardsManager is IRewardsManager, Initializable {
                 newCompBorrowIndex = uint224(borrowState.index + ratio);
             } else newCompBorrowIndex = borrowState.index;
 
-            localCompBorrowState[_cTokenAddress] = IComptroller.CompMarketState({
+            localCompBorrowState[_poolToken] = IComptroller.CompMarketState({
                 index: newCompBorrowIndex,
                 block: CompoundMath.safe32(block.number)
             });

src/compound/lens/RewardsLens.sol

@@ -28,20 +28,20 @@ abstract contract RewardsLens is MarketsLens {
         unclaimedRewards = rewardsManager.userUnclaimedCompRewards(_user);
 
         for (uint256 i; i < _poolTokens.length; ) {
-            address cTokenAddress = _poolTokens[i];
+            address poolToken = _poolTokens[i];
 
-            (bool isListed, , ) = comptroller.markets(cTokenAddress);
+            (bool isListed, , ) = comptroller.markets(poolToken);
             if (!isListed) revert InvalidPoolToken();
 
             unclaimedRewards += getAccruedSupplierComp(
                 _user,
-                cTokenAddress,
-                morpho.supplyBalanceInOf(cTokenAddress, _user).onPool
+                poolToken,
+                morpho.supplyBalanceInOf(poolToken, _user).onPool
             );
             unclaimedRewards += getAccruedBorrowerComp(
                 _user,
-                cTokenAddress,
-                morpho.borrowBalanceInOf(cTokenAddress, _user).onPool
+                poolToken,
+                morpho.borrowBalanceInOf(poolToken, _user).onPool
             );
 
             unchecked {

test/aave-v2/helpers/FlashLoan.sol

@@ -14,7 +14,7 @@ contract FlashLoan {
     }
 
     function callFlashLoan(address _asset, uint256 _amount) public {
-        address receiverAddress = address(this);
+        address receiver = address(this);
         address[] memory assets = new address[](1);
         assets[0] = _asset;
         uint256[] memory amounts = new uint256[](1);
@@ -25,7 +25,7 @@ contract FlashLoan {
         address onBehalfOf = address(this);
         bytes memory params = "";
         uint16 referralCode = 0;
-        pool.flashLoan(receiverAddress, assets, amounts, modes, onBehalfOf, params, referralCode);
+        pool.flashLoan(receiver, assets, amounts, modes, onBehalfOf, params, referralCode);
     }
 
     function executeOperation(

test/aave-v2/helpers/User.sol

@@ -113,13 +113,13 @@ contract User {
         morpho.repay(_poolToken, _onBehalf, _amount);
     }
 
-    function aaveSupply(address _underlyingTokenAddress, uint256 _amount) external {
-        ERC20(_underlyingTokenAddress).safeApprove(address(pool), type(uint256).max);
-        pool.deposit(_underlyingTokenAddress, _amount, address(this), 0); // 0 : no refferal code
+    function aaveSupply(address _underlyingToken, uint256 _amount) external {
+        ERC20(_underlyingToken).safeApprove(address(pool), type(uint256).max);
+        pool.deposit(_underlyingToken, _amount, address(this), 0); // 0 : no refferal code
     }
 
-    function aaveBorrow(address _underlyingTokenAddress, uint256 _amount) external {
-        pool.borrow(_underlyingTokenAddress, _amount, 2, 0, address(this)); // 2 : variable rate | 0 : no refferal code
+    function aaveBorrow(address _underlyingToken, uint256 _amount) external {
+        pool.borrow(_underlyingToken, _amount, 2, 0, address(this)); // 2 : variable rate | 0 : no refferal code
     }
 
     function aaveClaimRewards(address[] memory assets) external {