Instadapp/aave-protocol-v2
1
0
Fork 0
mirror of https://github.com/Instadapp/aave-protocol-v2.git synced 2024-07-29 21:47:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'fix/53-borrowing-mask' into 'master'

Browse Source 
Fixes #53

Closes #53

See merge request aave-tech/protocol-v2!63
This commit is contained in:
The-3D 2020-10-08 08:55:35 +00:00
commit 5ddd98c529
2 changed files with 325 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
contracts/libraries/configuration/ReserveConfiguration.sol
View File

@ -15,45 +15,38 @@ import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol';
library ReserveConfiguration {
uint256 constant LTV_MASK = 0xFFFFFFFFFFFFFFFF0000;
uint256 constant LIQUIDATION_THRESHOLD_MASK = 0xFFFFFFFFFFFF0000FFFF;
uint256 constant LIQUIDATION_BONUS_MASK = 0xFFFFFFF0000FFFFFFFF;
uint256 constant LIQUIDATION_BONUS_MASK = 0xFFFFFFFF0000FFFFFFFF;
uint256 constant DECIMALS_MASK = 0xFFFFFF00FFFFFFFFFFFF;
uint256 constant ACTIVE_MASK = 0xFFFFFEFFFFFFFFFFFFFF;
uint256 constant FROZEN_MASK = 0xFFFFFDFFFFFFFFFFFFFF;
uint256 constant BORROWING_MASK = 0xFFFFFBFFFFFFFFFFFFFF;
uint256 constant STABLE_BORROWING_MASK = 0xFFFF07FFFFFFFFFFFFFF;
uint256 constant STABLE_BORROWING_MASK = 0xFFFFF7FFFFFFFFFFFFFF;
uint256 constant RESERVE_FACTOR_MASK = 0xFFFFFFFFFFFFFFFF;
/// @dev For the LTV, the start bit is 0 (up to 15), but we don't declare it as for 0 no bit movement is needed
uint256 constant LIQUIDATION_THRESHOLD_START_BIT_POSITION = 16;
uint256 constant LIQUIDATION_BONUS_START_BIT_POSITION = 32;
uint256 constant RESERVE_DECIMALS_START_BIT_POSITION = 48;
uint256 constant IS_ACTIVE_START_BIT_POSITION = 56;
uint256 constant IS_FROZEN_START_BIT_POSITION = 57;
uint256 constant BORROWING_ENABLED_START_BIT_POSITION = 58;
uint256 constant STABLE_BORROWING_ENABLED_START_BIT_POSITION = 59;
uint256 constant RESERVE_FACTOR_START_BIT_POSITION = 64;
struct Map {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: Reserve is active
//bit 57: reserve is freezed
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60-63: reserved
//bit 64-79: reserve factor
uint256 data;
}
/**
* @dev sets the reserve factor of the reserve
* @param self the reserve configuration
* @param reserveFactor the reserve factor
**/
function setReserveFactor(ReserveConfiguration.Map memory self, uint256 reserveFactor) internal pure {
self.data = (self.data & RESERVE_FACTOR_MASK) | reserveFactor << 64;
}
/**
* @dev gets the reserve factor of the reserve
* @param self the reserve configuration
* @return the reserve factor
**/
function getReserveFactor(ReserveConfiguration.Map storage self) internal view returns (uint256) {
return (self.data & ~RESERVE_FACTOR_MASK) >> 64;
}
/**
* @dev sets the Loan to Value of the reserve
* @param self the reserve configuration
@ -81,7 +74,9 @@ library ReserveConfiguration {
internal
pure
{
self.data = (self.data & LIQUIDATION_THRESHOLD_MASK) | (threshold << 16);
self.data =
(self.data & LIQUIDATION_THRESHOLD_MASK) |
(threshold << LIQUIDATION_THRESHOLD_START_BIT_POSITION);
}
/**
@ -94,7 +89,7 @@ library ReserveConfiguration {
view
returns (uint256)
{
return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> 16;
return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION;
}
/**
@ -103,7 +98,9 @@ library ReserveConfiguration {
* @param bonus the new liquidation bonus
**/
function setLiquidationBonus(ReserveConfiguration.Map memory self, uint256 bonus) internal pure {
self.data = (self.data & LIQUIDATION_BONUS_MASK) | (bonus << 32);
self.data =
(self.data & LIQUIDATION_BONUS_MASK) |
(bonus << LIQUIDATION_BONUS_START_BIT_POSITION);
}
/**
@ -116,7 +113,7 @@ library ReserveConfiguration {
view
returns (uint256)
{
return (self.data & ~LIQUIDATION_BONUS_MASK) >> 32;
return (self.data & ~LIQUIDATION_BONUS_MASK) >> LIQUIDATION_BONUS_START_BIT_POSITION;
}
/**
@ -125,7 +122,7 @@ library ReserveConfiguration {
* @param decimals the decimals
**/
function setDecimals(ReserveConfiguration.Map memory self, uint256 decimals) internal pure {
self.data = (self.data & DECIMALS_MASK) | (decimals << 48);
self.data = (self.data & DECIMALS_MASK) | (decimals << RESERVE_DECIMALS_START_BIT_POSITION);
}
/**
@ -134,7 +131,7 @@ library ReserveConfiguration {
* @return the decimals of the asset
**/
function getDecimals(ReserveConfiguration.Map storage self) internal view returns (uint256) {
return (self.data & ~DECIMALS_MASK) >> 48;
return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION;
}
/**
@ -143,7 +140,9 @@ library ReserveConfiguration {
* @param active the active state
**/
function setActive(ReserveConfiguration.Map memory self, bool active) internal pure {
self.data = (self.data & ACTIVE_MASK) | (uint256(active ? 1 : 0) << 56);
self.data =
(self.data & ACTIVE_MASK) |
(uint256(active ? 1 : 0) << IS_ACTIVE_START_BIT_POSITION);
}
/**
@ -152,7 +151,7 @@ library ReserveConfiguration {
* @return the active state
**/
function getActive(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~ACTIVE_MASK) >> 56) != 0;
return ((self.data & ~ACTIVE_MASK) >> IS_ACTIVE_START_BIT_POSITION) != 0;
}
/**
@ -161,7 +160,9 @@ library ReserveConfiguration {
* @param frozen the frozen state
**/
function setFrozen(ReserveConfiguration.Map memory self, bool frozen) internal pure {
self.data = (self.data & FROZEN_MASK) | (uint256(frozen ? 1 : 0) << 57);
self.data =
(self.data & FROZEN_MASK) |
(uint256(frozen ? 1 : 0) << IS_FROZEN_START_BIT_POSITION);
}
/**
@ -170,7 +171,7 @@ library ReserveConfiguration {
* @return the frozen state
**/
function getFrozen(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~FROZEN_MASK) >> 57) != 0;
return ((self.data & ~FROZEN_MASK) >> IS_FROZEN_START_BIT_POSITION) != 0;
}
/**
@ -179,7 +180,9 @@ library ReserveConfiguration {
* @param enabled true if the borrowing needs to be enabled, false otherwise
**/
function setBorrowingEnabled(ReserveConfiguration.Map memory self, bool enabled) internal pure {
self.data = (self.data & BORROWING_MASK) | (uint256(enabled ? 1 : 0) << 58);
self.data =
(self.data & BORROWING_MASK) |
(uint256(enabled ? 1 : 0) << BORROWING_ENABLED_START_BIT_POSITION);
}
/**
@ -188,7 +191,7 @@ library ReserveConfiguration {
* @return the borrowing state
**/
function getBorrowingEnabled(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~BORROWING_MASK) >> 58) != 0;
return ((self.data & ~BORROWING_MASK) >> BORROWING_ENABLED_START_BIT_POSITION) != 0;
}
/**
@ -197,9 +200,12 @@ library ReserveConfiguration {
* @param enabled true if the stable rate borrowing needs to be enabled, false otherwise
**/
function setStableRateBorrowingEnabled(ReserveConfiguration.Map memory self, bool enabled)
internal pure
internal
pure
{
self.data = (self.data & STABLE_BORROWING_MASK) | (uint256(enabled ? 1 : 0) << 59);
self.data =
(self.data & STABLE_BORROWING_MASK) |
(uint256(enabled ? 1 : 0) << STABLE_BORROWING_ENABLED_START_BIT_POSITION);
}
/**
@ -212,7 +218,31 @@ library ReserveConfiguration {
view
returns (bool)
{
return ((self.data & ~STABLE_BORROWING_MASK) >> 59) != 0;
return
((self.data & ~STABLE_BORROWING_MASK) >> STABLE_BORROWING_ENABLED_START_BIT_POSITION) != 0;
}
/**
* @dev sets the reserve factor of the reserve
* @param self the reserve configuration
* @param reserveFactor the reserve factor
**/
function setReserveFactor(ReserveConfiguration.Map memory self, uint256 reserveFactor)
internal
pure
{
self.data =
(self.data & RESERVE_FACTOR_MASK) |
(reserveFactor << RESERVE_FACTOR_START_BIT_POSITION);
}
/**
* @dev gets the reserve factor of the reserve
* @param self the reserve configuration
* @return the reserve factor
**/
function getReserveFactor(ReserveConfiguration.Map storage self) internal view returns (uint256) {
return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION;
}
/**
@ -233,10 +263,10 @@ library ReserveConfiguration {
uint256 dataLocal = self.data;
return (
(dataLocal & ~ACTIVE_MASK) >> 56 != 0,
(dataLocal & ~FROZEN_MASK) >> 57 != 0,
(dataLocal & ~BORROWING_MASK) >> 58 != 0,
(dataLocal & ~STABLE_BORROWING_MASK) >> 59 != 0
(dataLocal & ~ACTIVE_MASK) >> IS_ACTIVE_START_BIT_POSITION != 0,
(dataLocal & ~FROZEN_MASK) >> IS_FROZEN_START_BIT_POSITION != 0,
(dataLocal & ~BORROWING_MASK) >> BORROWING_ENABLED_START_BIT_POSITION != 0,
(dataLocal & ~STABLE_BORROWING_MASK) >> STABLE_BORROWING_ENABLED_START_BIT_POSITION != 0
);
}
@ -259,9 +289,9 @@ library ReserveConfiguration {
return (
dataLocal & ~LTV_MASK,
(dataLocal & ~LIQUIDATION_THRESHOLD_MASK) >> 16,
(dataLocal & ~LIQUIDATION_BONUS_MASK) >> 32,
(dataLocal & ~DECIMALS_MASK) >> 48
(dataLocal & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION,
(dataLocal & ~LIQUIDATION_BONUS_MASK) >> LIQUIDATION_BONUS_START_BIT_POSITION,
(dataLocal & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION
);
}
}

282
test/configurator.spec.ts
View File

@ -42,16 +42,54 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Freezes the ETH reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.freezeReserve(weth.address);
const {isFreezed} = await pool.getReserveConfigurationData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(true);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Unfreezes the ETH reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.unfreezeReserve(weth.address);
const {isFreezed} = await pool.getReserveConfigurationData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Check the onlyAaveAdmin on freezeReserve ', async () => {
@ -73,16 +111,56 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Deactivates the ETH reserve for borrowing', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.disableBorrowingOnReserve(weth.address);
const {borrowingEnabled} = await pool.getReserveConfigurationData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(false);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Activates the ETH reserve for borrowing', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.enableBorrowingOnReserve(weth.address, true);
const {borrowingEnabled} = await pool.getReserveConfigurationData(weth.address);
const {variableBorrowIndex} = await pool.getReserveData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
expect(variableBorrowIndex.toString()).to.be.equal(RAY);
});
@ -105,16 +183,54 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Deactivates the ETH reserve as collateral', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.disableReserveAsCollateral(weth.address);
const {usageAsCollateralEnabled} = await pool.getReserveConfigurationData(weth.address);
expect(usageAsCollateralEnabled).to.be.equal(false);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(0);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Activates the ETH reserve as collateral', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.enableReserveAsCollateral(weth.address, '75', '80', '105');
await configurator.enableReserveAsCollateral(weth.address, '7500', '8000', '10500');
const {usageAsCollateralEnabled} = await pool.getReserveConfigurationData(weth.address);
expect(usageAsCollateralEnabled).to.be.equal(true);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Check the onlyAaveAdmin on disableReserveAsCollateral ', async () => {
@ -138,15 +254,53 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Disable stable borrow rate on the ETH reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.disableReserveStableRate(weth.address);
const {stableBorrowRateEnabled} = await pool.getReserveConfigurationData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(false);
expect(reserveFactor).to.be.equal(0);
});
it('Enables stable borrow rate on the ETH reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.enableReserveStableRate(weth.address);
const {stableBorrowRateEnabled} = await pool.getReserveConfigurationData(weth.address);
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(7500);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Check the onlyAaveAdmin on disableReserveStableRate', async () => {
@ -167,9 +321,28 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Changes LTV of the reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.setLtv(weth.address, '60');
const {ltv} = await pool.getReserveConfigurationData(weth.address);
expect(ltv.toString()).to.be.bignumber.equal('60', 'Invalid LTV');
await configurator.setLtv(weth.address, '6000');
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(6000);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(0);
});
it('Check the onlyAaveAdmin on setLtv', async () => {
@ -180,12 +353,30 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
).to.be.revertedWith(CALLER_NOT_AAVE_ADMIN);
});
it('Changes the reserve factor of the reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.setReserveFactor(weth.address, '1000');
const {reserveFactor} = await pool.getReserveConfigurationData(weth.address);
expect(reserveFactor.toString()).to.be.bignumber.equal('1000', 'Invalid reserve factor');
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(6000);
expect(liquidationThreshold).to.be.equal(8000);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(1000);
});
it('Check the onlyLendingPoolManager on setReserveFactor', async () => {
@ -196,15 +387,30 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
).to.be.revertedWith(CALLER_NOT_AAVE_ADMIN);
});
it('Changes liquidation threshold of the reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.setLiquidationThreshold(weth.address, '75');
const {liquidationThreshold} = await pool.getReserveConfigurationData(weth.address);
expect(liquidationThreshold.toString()).to.be.bignumber.equal(
'75',
'Invalid Liquidation threshold'
);
await configurator.setLiquidationThreshold(weth.address, '7500');
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(6000);
expect(liquidationThreshold).to.be.equal(7500);
expect(liquidationBonus).to.be.equal(10500);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(1000);
});
it('Check the onlyAaveAdmin on setLiquidationThreshold', async () => {
@ -217,12 +423,28 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
it('Changes liquidation bonus of the reserve', async () => {
const {configurator, pool, weth} = testEnv;
await configurator.setLiquidationBonus(weth.address, '110');
const {liquidationBonus} = await pool.getReserveConfigurationData(weth.address);
expect(liquidationBonus.toString()).to.be.bignumber.equal(
'110',
'Invalid Liquidation discount'
);
await configurator.setLiquidationBonus(weth.address, '11000');
const {
decimals,
ltv,
liquidationBonus,
liquidationThreshold,
reserveFactor,
stableBorrowRateEnabled,
borrowingEnabled,
isActive,
isFreezed,
} = await pool.getReserveConfigurationData(weth.address);
expect(borrowingEnabled).to.be.equal(true);
expect(isActive).to.be.equal(true);
expect(isFreezed).to.be.equal(false);
expect(decimals).to.be.equal(18);
expect(ltv).to.be.equal(6000);
expect(liquidationThreshold).to.be.equal(7500);
expect(liquidationBonus).to.be.equal(11000);
expect(stableBorrowRateEnabled).to.be.equal(true);
expect(reserveFactor).to.be.equal(1000);
});
it('Check the onlyAaveAdmin on setLiquidationBonus', async () => {