Merge pull request #534 from aave/fix/387-emode-pricefeed-liquidations

Use eMode price oracle if set when liquidating

Author: The-3D

contracts/protocol/libraries/helpers/Errors.sol

@@ -97,4 +97,4 @@ library Errors {
   string public constant STABLE_BORROWING_ENABLED = '88'; // 'Stable borrowing is enabled'
   string public constant SILOED_BORROWING_VIOLATION = '89'; // 'User is trying to borrow multiple assets including a siloed one'
   string public constant RESERVE_DEBT_NOT_ZERO = '90'; // the total debt of the reserve needs to be 0
-}
+}

contracts/protocol/libraries/logic/LiquidationLogic.sol

@@ -10,8 +10,8 @@ import {DataTypes} from '../../libraries/types/DataTypes.sol';
 import {ReserveLogic} from './ReserveLogic.sol';
 import {ValidationLogic} from './ValidationLogic.sol';
 import {GenericLogic} from './GenericLogic.sol';
-import {EModeLogic} from './EModeLogic.sol';
 import {IsolationModeLogic} from './IsolationModeLogic.sol';
+import {EModeLogic} from './EModeLogic.sol';
 import {UserConfiguration} from '../../libraries/configuration/UserConfiguration.sol';
 import {ReserveConfiguration} from '../../libraries/configuration/ReserveConfiguration.sol';
 import {IAToken} from '../../../interfaces/IAToken.sol';
@@ -81,6 +81,8 @@ library LiquidationLogic {
     uint256 healthFactor;
     uint256 liquidationProtocolFeeAmount;
     uint256 closeFactor;
+    address collateralPriceSource;
+    address debtPriceSource;
     IAToken collateralAToken;
     IPriceOracleGetter oracle;
     DataTypes.ReserveCache debtReserveCache;
@@ -156,12 +158,31 @@ library LiquidationLogic {
       ? vars.maxLiquidatableDebt
       : params.debtToCover;
 
-    vars.liquidationBonus = EModeLogic.isInEModeCategory(
-      params.userEModeCategory,
-      collateralReserve.configuration.getEModeCategory()
-    )
-      ? eModeCategories[params.userEModeCategory].liquidationBonus
-      : collateralReserve.configuration.getLiquidationBonus();
+    vars.collateralPriceSource = params.collateralAsset;
+    vars.debtPriceSource = params.debtAsset;
+    vars.liquidationBonus = collateralReserve.configuration.getLiquidationBonus();
+
+    if (params.userEModeCategory != 0) {
+      address eModePriceSource = eModeCategories[params.userEModeCategory].priceSource;
+
+      if (
+        EModeLogic.isInEModeCategory(
+          params.userEModeCategory,
+          collateralReserve.configuration.getEModeCategory()
+        )
+      ) {
+        vars.liquidationBonus = eModeCategories[params.userEModeCategory].liquidationBonus;
+
+        if (eModePriceSource != address(0)) {
+          vars.collateralPriceSource = eModePriceSource;
+        }
+      }
+
+      // when in eMode, debt will always be in the same eMode category, can skip matching category check
+      if (eModePriceSource != address(0)) {
+        vars.debtPriceSource = eModePriceSource;
+      }
+    }
 
     (
       vars.maxCollateralToLiquidate,
@@ -170,8 +191,8 @@ library LiquidationLogic {
     ) = _calculateAvailableCollateralToLiquidate(
       collateralReserve,
       vars.debtReserveCache,
-      params.collateralAsset,
-      params.debtAsset,
+      vars.collateralPriceSource,
+      vars.debtPriceSource,
       vars.actualDebtToLiquidate,
       vars.userCollateralBalance,
       vars.liquidationBonus,

contracts/protocol/pool/PoolConfigurator.sol

@@ -265,8 +265,12 @@ contract PoolConfigurator is VersionedInitializable, IPoolConfigurator {
   }
 
   /// @inheritdoc IPoolConfigurator
-  function setSiloedBorrowing(address asset, bool newSiloed) external override onlyRiskOrPoolAdmins {
-    if(newSiloed) {
+  function setSiloedBorrowing(address asset, bool newSiloed)
+    external
+    override
+    onlyRiskOrPoolAdmins
+  {
+    if (newSiloed) {
       _checkNoBorrowers(asset);
     }
     DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
@@ -481,9 +485,10 @@ contract PoolConfigurator is VersionedInitializable, IPoolConfigurator {
     require(totalATokens == 0, Errors.RESERVE_LIQUIDITY_NOT_ZERO);
   }
 
-    function _checkNoBorrowers(address asset) internal view {
-    uint256 totalDebt = IPoolDataProvider(_addressesProvider.getPoolDataProvider())
-      .getTotalDebt(asset);
+  function _checkNoBorrowers(address asset) internal view {
+    uint256 totalDebt = IPoolDataProvider(_addressesProvider.getPoolDataProvider()).getTotalDebt(
+      asset
+    );
     require(totalDebt == 0, Errors.RESERVE_DEBT_NOT_ZERO);
   }
 

test-suites/configurator.spec.ts

@@ -85,7 +85,8 @@ const getReserveData = async (helpersContract: AaveProtocolDataProvider, asset:
 
 makeSuite('PoolConfigurator', (testEnv: TestEnv) => {
   let baseConfigValues: ReserveConfigurationValues;
-  const { RESERVE_LIQUIDITY_NOT_ZERO, INVALID_DEBT_CEILING, RESERVE_DEBT_NOT_ZERO } = ProtocolErrors;
+  const { RESERVE_LIQUIDITY_NOT_ZERO, INVALID_DEBT_CEILING, RESERVE_DEBT_NOT_ZERO } =
+    ProtocolErrors;
 
   before(() => {
     const {
@@ -922,7 +923,7 @@ makeSuite('PoolConfigurator', (testEnv: TestEnv) => {
 
   it('Resets the siloed borrowing mode. Tries to set siloed borrowing after the asset has been borrowed (revert expected)', async () => {
     const snap = await evmSnapshot();
-  
+
     const {
       configurator,
       weth,
@@ -957,7 +958,6 @@ makeSuite('PoolConfigurator', (testEnv: TestEnv) => {
     );
 
     await evmRevert(snap);
-
   });
 
   it('Sets a debt ceiling through the pool admin', async () => {

test-suites/liquidation-emode.spec.ts

@@ -476,8 +476,8 @@ makeSuite('Pool Liquidation: Liquidates borrows in eMode with price change', (te
 
     const balanceAfter = await aDai.balanceOf(user1.address);
 
-    const debtPrice = await oracle.getAssetPrice(usdc.address);
-    const collateralPrice = await oracle.getAssetPrice(dai.address);
+    const debtPrice = await oracle.getAssetPrice(EMODE_ORACLE_ADDRESS);
+    const collateralPrice = await oracle.getAssetPrice(EMODE_ORACLE_ADDRESS);
 
     const expectedCollateralLiquidated = debtPrice
       .mul(toBorrow.div(2))
@@ -489,4 +489,133 @@ makeSuite('Pool Liquidation: Liquidates borrows in eMode with price change', (te
 
     expect(collateralLiquidated).to.be.closeTo(expectedCollateralLiquidated, 2);
   });
+
+  it('Liquidation of non-eMode collateral with eMode debt in eMode with custom price feed', async () => {
+    await evmRevert(snap);
+    snap = await evmSnapshot();
+
+    const {
+      helpersContract,
+      oracle,
+      configurator,
+      pool,
+      poolAdmin,
+      dai,
+      usdc,
+      weth,
+      aWETH,
+      users: [user1, user2],
+    } = testEnv;
+
+    // We need an extra oracle for prices. USe user address as asset in price oracle
+    const EMODE_ORACLE_ADDRESS = user1.address;
+    await oracle.setAssetPrice(EMODE_ORACLE_ADDRESS, utils.parseUnits('1', 8));
+    await oracle.setAssetPrice(dai.address, utils.parseUnits('0.99', 8));
+    await oracle.setAssetPrice(usdc.address, utils.parseUnits('1.01', 8));
+    await oracle.setAssetPrice(weth.address, utils.parseUnits('4000', 8));
+
+    // Create category
+    expect(
+      await configurator
+        .connect(poolAdmin.signer)
+        .setEModeCategory(
+          1,
+          CATEGORY.ltv,
+          CATEGORY.lt,
+          CATEGORY.lb,
+          EMODE_ORACLE_ADDRESS,
+          CATEGORY.label
+        )
+    );
+
+    const categoryData = await pool.getEModeCategoryData(CATEGORY.id);
+
+    expect(categoryData.ltv).to.be.equal(CATEGORY.ltv, 'invalid eMode category ltv');
+    expect(categoryData.liquidationThreshold).to.be.equal(
+      CATEGORY.lt,
+      'invalid eMode category liq threshold'
+    );
+    expect(categoryData.liquidationBonus).to.be.equal(
+      CATEGORY.lb,
+      'invalid eMode category liq bonus'
+    );
+    expect(categoryData.priceSource).to.be.equal(
+      EMODE_ORACLE_ADDRESS,
+      'invalid eMode category price source'
+    );
+
+    // Add Dai and USDC to category
+    await configurator.connect(poolAdmin.signer).setAssetEModeCategory(dai.address, CATEGORY.id);
+    await configurator.connect(poolAdmin.signer).setAssetEModeCategory(usdc.address, CATEGORY.id);
+    expect(await helpersContract.getReserveEModeCategory(dai.address)).to.be.eq(CATEGORY.id);
+    expect(await helpersContract.getReserveEModeCategory(usdc.address)).to.be.eq(CATEGORY.id);
+
+    // User 1 supply 1 dai + 1 eth, user 2 supply 10000 usdc
+    const wethSupplyAmount = utils.parseUnits('1', 18);
+    const daiSupplyAmount = utils.parseUnits('1', 18);
+    const usdcSupplyAmount = utils.parseUnits('10000', 6);
+
+    expect(await dai.connect(user1.signer)['mint(uint256)'](daiSupplyAmount));
+    expect(await weth.connect(user1.signer)['mint(uint256)'](wethSupplyAmount));
+    expect(await usdc.connect(user2.signer)['mint(uint256)'](usdcSupplyAmount.mul(2)));
+
+    expect(await dai.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT));
+    expect(await weth.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT));
+    expect(await usdc.connect(user2.signer).approve(pool.address, MAX_UINT_AMOUNT));
+
+    expect(await pool.connect(user1.signer).supply(dai.address, daiSupplyAmount, user1.address, 0));
+    expect(
+      await pool.connect(user1.signer).supply(weth.address, wethSupplyAmount, user1.address, 0)
+    );
+    expect(
+      await pool.connect(user2.signer).supply(usdc.address, usdcSupplyAmount, user2.address, 0)
+    );
+
+    // Activate emode
+    expect(await pool.connect(user1.signer).setUserEMode(CATEGORY.id));
+
+    // Borrow a as much usdc as possible
+    const userData = await pool.getUserAccountData(user1.address);
+    const toBorrow = userData.availableBorrowsBase.div(100);
+
+    expect(
+      await pool
+        .connect(user1.signer)
+        .borrow(usdc.address, toBorrow, RateMode.Variable, 0, user1.address)
+    );
+
+    // Drop weth price
+    const oraclePrice = await oracle.getAssetPrice(EMODE_ORACLE_ADDRESS);
+
+    const userGlobalDataBefore = await pool.getUserAccountData(user1.address);
+    expect(userGlobalDataBefore.healthFactor).to.be.gt(utils.parseUnits('1', 18));
+
+    await oracle.setAssetPrice(EMODE_ORACLE_ADDRESS, oraclePrice.mul(2));
+
+    const userGlobalDataAfter = await pool.getUserAccountData(user1.address);
+    expect(userGlobalDataAfter.healthFactor).to.be.lt(utils.parseUnits('1', 18), INVALID_HF);
+
+    const balanceBefore = await aWETH.balanceOf(user1.address);
+
+    // Liquidate
+    await pool
+      .connect(user2.signer)
+      .liquidationCall(weth.address, usdc.address, user1.address, toBorrow.div(2), false);
+
+    const balanceAfter = await aWETH.balanceOf(user1.address);
+
+    const debtPrice = await oracle.getAssetPrice(EMODE_ORACLE_ADDRESS);
+    const collateralPrice = await oracle.getAssetPrice(weth.address);
+
+    const wethConfig = await helpersContract.getReserveConfigurationData(weth.address);
+
+    const expectedCollateralLiquidated = debtPrice
+      .mul(toBorrow.div(2))
+      .percentMul(wethConfig.liquidationBonus)
+      .mul(BigNumber.from(10).pow(18))
+      .div(collateralPrice.mul(BigNumber.from(10).pow(6)));
+
+    const collateralLiquidated = balanceBefore.sub(balanceAfter);
+    expect(collateralLiquidated).to.be.closeTo(expectedCollateralLiquidated, 2);
+  });
 });

test-suites/siloed-borrowing.spec.ts

@@ -31,15 +31,19 @@ makeSuite('Siloed borrowing', (testEnv: TestEnv) => {
     const wethSupplyAmount = utils.parseEther('1');
     const daiBorrowAmount = utils.parseEther('10');
     const daiSupplyAmount = utils.parseEther('1000');
-    const usdcSupplyAmount = utils.parseUnits('1000',6);
+    const usdcSupplyAmount = utils.parseUnits('1000', 6);
 
     await dai.connect(users[0].signer)['mint(address,uint256)'](users[0].address, daiSupplyAmount);
     await dai.connect(users[0].signer).approve(pool.address, MAX_UINT_AMOUNT);
     await pool.connect(users[0].signer).supply(dai.address, daiSupplyAmount, users[0].address, '0');
 
-    await usdc.connect(users[1].signer)['mint(address,uint256)'](users[1].address, usdcSupplyAmount);
+    await usdc
+      .connect(users[1].signer)
+      ['mint(address,uint256)'](users[1].address, usdcSupplyAmount);
     await usdc.connect(users[1].signer).approve(pool.address, MAX_UINT_AMOUNT);
-    await pool.connect(users[1].signer).supply(usdc.address, usdcSupplyAmount, users[1].address, '0');
+    await pool
+      .connect(users[1].signer)
+      .supply(usdc.address, usdcSupplyAmount, users[1].address, '0');
 
     await weth
       .connect(users[1].signer)