AaveV3LeverageStrategyExtension audit feedback

contracts/adapters/AaveLeverageStrategyExtension.sol

@@ -189,7 +189,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
     /**
      * Throws if rebalance is currently in TWAP`
      */
-    modifier noRebalanceInProgress() {
+    modifier noRebalanceInProgress() virtual {
         require(twapLeverageRatio == 0, "Rebalance is currently in progress");
         _;
     }
@@ -886,7 +886,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
      *
      * return ActionInfo                Struct containing data used by internal lever and delever functions
      */
-    function _createActionInfo() internal view returns(ActionInfo memory) {
+    function _createActionInfo() internal view virtual returns(ActionInfo memory) {
         ActionInfo memory rebalanceInfo;
 
         // Calculate prices from chainlink. Chainlink returns prices with 8 decimal places, but we need 36 - underlyingDecimals decimal places.
@@ -915,6 +915,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
         IncentiveSettings memory _incentive
     )
         internal
+        virtual
         pure
     {
         require (
@@ -1060,6 +1061,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
     )
         internal
         view
+        virtual
         returns (uint256, uint256)
     {
         // Calculate absolute value of difference between new and current leverage ratio
@@ -1092,7 +1094,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
      *
      * return uint256          Max borrow notional denominated in collateral asset
      */
-    function _calculateMaxBorrowCollateral(ActionInfo memory _actionInfo, bool _isLever) internal view returns(uint256) {
+    function _calculateMaxBorrowCollateral(ActionInfo memory _actionInfo, bool _isLever) internal virtual view returns(uint256) {
 
         // Retrieve collateral factor and liquidation threshold for the collateral asset in precise units (1e16 = 1%)
         ( , uint256 maxLtvRaw, uint256 liquidationThresholdRaw, , , , , , ,) = strategy.aaveProtocolDataProvider.getReserveConfigurationData(address(strategy.collateralAsset));
@@ -1144,7 +1146,7 @@ contract AaveLeverageStrategyExtension is BaseExtension {
      *
      * return uint256           Min position units to repay in borrow asset
      */
-    function _calculateMinRepayUnits(uint256 _collateralRebalanceUnits, uint256 _slippageTolerance, ActionInfo memory _actionInfo) internal pure returns (uint256) {
+    function _calculateMinRepayUnits(uint256 _collateralRebalanceUnits, uint256 _slippageTolerance, ActionInfo memory _actionInfo) internal virtual pure returns (uint256) {
         return _collateralRebalanceUnits
             .preciseMul(_actionInfo.collateralPrice)
             .preciseDiv(_actionInfo.borrowPrice)
@@ -1271,4 +1273,4 @@ contract AaveLeverageStrategyExtension is BaseExtension {
 
         return (enabledExchanges, shouldRebalanceEnums);
     }
-}
+}

contracts/adapters/AaveV3LeverageStrategyExtension.sol

@@ -19,9 +19,15 @@
 pragma solidity 0.6.10;
 pragma experimental ABIEncoderV2;
 
-import {AaveLeverageStrategyExtension} from "./AaveLeverageStrategyExtension.sol";
+import { Math } from "@openzeppelin/contracts/math/Math.sol";
 
+import {AaveLeverageStrategyExtension} from "./AaveLeverageStrategyExtension.sol";
 import {IBaseManager} from "../interfaces/IBaseManager.sol";
+import { IChainlinkAggregatorV3 } from "../interfaces/IChainlinkAggregatorV3.sol";
+import {IPool} from "../interfaces/IPool.sol";
+import {IPoolAddressesProvider} from "../interfaces/IPoolAddressesProvider.sol";
+import { DataTypes } from "../interfaces/Datatypes.sol";
+import { PreciseUnitMath } from "../lib/PreciseUnitMath.sol";
 
 /**
  * @title AaveV3LeverageStrategyExtension
@@ -31,14 +37,22 @@ import {IBaseManager} from "../interfaces/IBaseManager.sol";
  *
  */
 contract AaveV3LeverageStrategyExtension is AaveLeverageStrategyExtension {
+
+    uint8 public currentEModeCategoryId;
+    IPoolAddressesProvider public lendingPoolAddressesProvider;
+    uint256 public maxOraclePriceAge;
+    bool public overrideNoRebalanceInProgress;
+
     constructor(
         IBaseManager _manager,
         ContractSettings memory _strategy,
         MethodologySettings memory _methodology,
         ExecutionSettings memory _execution,
         IncentiveSettings memory _incentive,
         string[] memory _exchangeNames,
-        ExchangeSettings[] memory _exchangeSettings
+        ExchangeSettings[] memory _exchangeSettings,
+        IPoolAddressesProvider _lendingPoolAddressesProvider,
+        uint256 _maxOraclePriceAge
     )
         public
         AaveLeverageStrategyExtension(
@@ -50,14 +64,40 @@ contract AaveV3LeverageStrategyExtension is AaveLeverageStrategyExtension {
             _exchangeNames,
             _exchangeSettings
         )
-    {}
+    {
+        lendingPoolAddressesProvider = _lendingPoolAddressesProvider;
+        maxOraclePriceAge = _maxOraclePriceAge;
+    }
+
+    /* ============ Modifiers ============ */
+
+    /**
+     * Throws if rebalance is currently in TWAP` can be overriden by the operator
+     */
+    modifier noRebalanceInProgress() override {
+        if(!overrideNoRebalanceInProgress) {
+            require(twapLeverageRatio == 0, "Rebalance is currently in progress");
+        }
+        _;
+    }
+
+
+    /**
+     * OPERATOR ONLY: Enable/Disable override of noRebalanceInProgress modifier
+     *
+     * @param _overrideNoRebalanceInProgress  Boolean indicating wether to enable / disable override
+     */
+    function setOverrideNoRebalanceInProgress(bool _overrideNoRebalanceInProgress) external onlyOperator {
+        overrideNoRebalanceInProgress = _overrideNoRebalanceInProgress;
+    }
 
     /**
      * OPERATOR ONLY: Set eMode categoryId to new value
      *
      * @param _categoryId    eMode categoryId as defined on aaveV3
      */
     function setEModeCategory(uint8 _categoryId) external onlyOperator {
+        currentEModeCategoryId = _categoryId;
         _setEModeCategory(_categoryId);
     }
 
@@ -66,4 +106,116 @@ contract AaveV3LeverageStrategyExtension is AaveLeverageStrategyExtension {
             abi.encodeWithSignature("setEModeCategory(address,uint8)", address(strategy.setToken), _categoryId);
         invokeManager(address(strategy.leverageModule), setEmodeCallData);
     }
+
+    function _calculateMaxBorrowCollateral(ActionInfo memory _actionInfo, bool _isLever) internal override view returns(uint256) {
+
+        (uint256 maxLtvRaw, uint256 liquidationThresholdRaw) = _getLtvAndLiquidationThreshold();
+
+        // Normalize LTV and liquidation threshold to precise units. LTV is measured in 4 decimals in Aave which is why we must multiply by 1e14
+        // for example ETH has an LTV value of 8000 which represents 80%
+        if (_isLever) {
+            uint256 netBorrowLimit = _actionInfo.collateralValue
+                .preciseMul(maxLtvRaw.mul(10 ** 14))
+                .preciseMul(PreciseUnitMath.preciseUnit().sub(execution.unutilizedLeveragePercentage));
+
+            return netBorrowLimit
+                .sub(_actionInfo.borrowValue)
+                .preciseDiv(_actionInfo.collateralPrice);
+        } else {
+            uint256 netRepayLimit = _actionInfo.collateralValue
+                .preciseMul(liquidationThresholdRaw.mul(10 ** 14));
+
+            return _actionInfo.collateralBalance
+                .preciseMul(netRepayLimit.sub(_actionInfo.borrowValue))
+                .preciseDiv(netRepayLimit);
+        }
+    }
+
+    function _getLtvAndLiquidationThreshold() internal view returns(uint256, uint256) {
+        if(currentEModeCategoryId != 0 ) {
+            // Retrieve collateral factor and liquidation threshold for the collateral asset in precise units (1e16 = 1%)
+            DataTypes.EModeCategory memory emodeData = IPool(lendingPoolAddressesProvider.getPool()).getEModeCategoryData(currentEModeCategoryId);
+            return (emodeData.ltv, emodeData.liquidationThreshold);
+        } else {
+            ( , uint256 maxLtvRaw, uint256 liquidationThresholdRaw, , , , , , ,) = strategy.aaveProtocolDataProvider.getReserveConfigurationData(address(strategy.collateralAsset));
+            return (maxLtvRaw, liquidationThresholdRaw);
+        }
+
+    }
+
+    function _validateNonExchangeSettings(
+        MethodologySettings memory _methodology,
+        ExecutionSettings memory _execution,
+        IncentiveSettings memory _incentive
+    )
+        internal
+        override
+        pure
+    {
+        super._validateNonExchangeSettings(_methodology, _execution, _incentive);
+        require(_methodology.targetLeverageRatio >= 1 ether, "Target leverage ratio must be >= 1e18");
+    }
+
+    function _calculateMinRepayUnits(uint256 _collateralRebalanceUnits, uint256 _slippageTolerance, ActionInfo memory _actionInfo) internal override pure returns (uint256) {
+        return _collateralRebalanceUnits
+            .preciseMul(_actionInfo.collateralPrice)
+            .preciseMul(PreciseUnitMath.preciseUnit().sub(_slippageTolerance)) // Changed order of mul / div here
+            .preciseDiv(_actionInfo.borrowPrice);
+    }
+
+    function _calculateChunkRebalanceNotional(
+        LeverageInfo memory _leverageInfo,
+        uint256 _newLeverageRatio,
+        bool _isLever
+    )
+        internal
+        view
+        override
+        returns (uint256, uint256)
+    {
+        // Calculate absolute value of difference between new and current leverage ratio
+        uint256 leverageRatioDifference = _isLever ? _newLeverageRatio.sub(_leverageInfo.currentLeverageRatio) : _leverageInfo.currentLeverageRatio.sub(_newLeverageRatio);
+
+        uint256 totalRebalanceNotional = leverageRatioDifference
+            .preciseMul(_leverageInfo.action.collateralBalance) // Changed order of mul / div here
+            .preciseDiv(_leverageInfo.currentLeverageRatio);
+
+        uint256 maxBorrow = _calculateMaxBorrowCollateral(_leverageInfo.action, _isLever);
+
+        uint256 chunkRebalanceNotional = Math.min(Math.min(maxBorrow, totalRebalanceNotional), _leverageInfo.twapMaxTradeSize);
+
+        return (chunkRebalanceNotional, totalRebalanceNotional);
+    }
+
+        /**
+     * Create the action info struct to be used in internal functions
+     *
+     * return ActionInfo                Struct containing data used by internal lever and delever functions
+     */
+    function _createActionInfo() internal view override returns(ActionInfo memory) {
+        ActionInfo memory rebalanceInfo;
+
+        // Calculate prices from chainlink. Chainlink returns prices with 8 decimal places, but we need 36 - underlyingDecimals decimal places.
+        // This is so that when the underlying amount is multiplied by the received price, the collateral valuation is normalized to 36 decimals. 
+        // To perform this adjustment, we multiply by 10^(36 - 8 - underlyingDecimals)
+        rebalanceInfo.collateralPrice = _getAssetPrice(strategy.collateralPriceOracle, strategy.collateralDecimalAdjustment);
+        rebalanceInfo.borrowPrice = _getAssetPrice(strategy.borrowPriceOracle, strategy.borrowDecimalAdjustment);
+
+        rebalanceInfo.collateralBalance = strategy.targetCollateralAToken.balanceOf(address(strategy.setToken));
+        rebalanceInfo.borrowBalance = strategy.targetBorrowDebtToken.balanceOf(address(strategy.setToken));
+        rebalanceInfo.collateralValue = rebalanceInfo.collateralPrice.preciseMul(rebalanceInfo.collateralBalance);
+        rebalanceInfo.borrowValue = rebalanceInfo.borrowPrice.preciseMul(rebalanceInfo.borrowBalance);
+        rebalanceInfo.setTotalSupply = strategy.setToken.totalSupply();
+
+        return rebalanceInfo;
+    }
+
+    function _getAssetPrice(IChainlinkAggregatorV3 _priceOracle, uint256 _decimalAdjustment) internal view returns (uint256) {
+        (,int256 rawPrice,, uint256 updatedAt,) = _priceOracle.latestRoundData();
+        if(maxOraclePriceAge > 0) {
+            require(updatedAt > block.timestamp.sub(maxOraclePriceAge), "Price data is stale");
+        }
+        return rawPrice.toUint256().mul(10 ** _decimalAdjustment);
+    }
+
 }

contracts/interfaces/IAToken.sol

@@ -1,10 +1,67 @@
-// SPDX-License-Identifier: agpl-3.0
 pragma solidity 0.6.10;
 
-
 interface IAToken {
-  /**
-   * @dev Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
-   **/
-  function UNDERLYING_ASSET_ADDRESS() external view returns (address);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event BalanceTransfer(address indexed from, address indexed to, uint256 value, uint256 index);
+    event Burn(address indexed from, address indexed target, uint256 value, uint256 balanceIncrease, uint256 index);
+    event Initialized(
+        address indexed underlyingAsset,
+        address indexed pool,
+        address treasury,
+        address incentivesController,
+        uint8 aTokenDecimals,
+        string aTokenName,
+        string aTokenSymbol,
+        bytes params
+    );
+    event Mint(
+        address indexed caller, address indexed onBehalfOf, uint256 value, uint256 balanceIncrease, uint256 index
+    );
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function ATOKEN_REVISION() external view returns (uint256);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function EIP712_REVISION() external view returns (bytes memory);
+    function PERMIT_TYPEHASH() external view returns (bytes32);
+    function POOL() external view returns (address);
+    function RESERVE_TREASURY_ADDRESS() external view returns (address);
+    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address user) external view returns (uint256);
+    function burn(address from, address receiverOfUnderlying, uint256 amount, uint256 index) external;
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function getIncentivesController() external view returns (address);
+    function getPreviousIndex(address user) external view returns (uint256);
+    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
+    function handleRepayment(address user, address onBehalfOf, uint256 amount) external;
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function initialize(
+        address initializingPool,
+        address treasury,
+        address underlyingAsset,
+        address incentivesController,
+        uint8 aTokenDecimals,
+        string memory aTokenName,
+        string memory aTokenSymbol,
+        bytes memory params
+    ) external;
+    function mint(address caller, address onBehalfOf, uint256 amount, uint256 index) external returns (bool);
+    function mintToTreasury(uint256 amount, uint256 index) external;
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
+        external;
+    function rescueTokens(address token, address to, uint256 amount) external;
+    function scaledBalanceOf(address user) external view returns (uint256);
+    function scaledTotalSupply() external view returns (uint256);
+    function setIncentivesController(address controller) external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    function transferOnLiquidation(address from, address to, uint256 value) external;
+    function transferUnderlyingTo(address target, uint256 amount) external;
 }
+

contracts/interfaces/IChainlinkAggregatorV3.sol

@@ -3,4 +3,11 @@ pragma solidity 0.6.10;
 
 interface IChainlinkAggregatorV3 {
     function latestAnswer() external view returns (int256);
-}
+    function latestRoundData() external view returns (
+        uint80 roundId,
+        int256 answer,
+        uint256 startedAt,
+        uint256 updatedAt,
+        uint80 answeredInRound
+    );
+}

contracts/mocks/ChainlinkAggregatorV3Mock.sol

@@ -5,6 +5,7 @@ pragma solidity 0.6.10;
 contract ChainlinkAggregatorV3Mock {
 
     int256 private latestPrice;
+    uint256 private priceAge;
 
     constructor() public {
         latestPrice = 0;
@@ -17,4 +18,20 @@ contract ChainlinkAggregatorV3Mock {
     function latestAnswer() external view returns (int256) {
         return latestPrice;
     }
-}
+
+    function setPriceAge(uint256 _priceAge) external {
+        priceAge = _priceAge;
+    }
+
+    function latestRoundData() external view returns (
+        uint80 roundId,
+        int256 answer,
+        uint256 startedAt,
+        uint256 updatedAt,
+        uint80 answeredInRound
+    ) {
+        answer = latestPrice;
+        updatedAt = block.timestamp - priceAge;
+        startedAt = updatedAt - 1;
+    }
+}