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 pull request #24 from aave/feat/light-deployments-update

Browse Source 
Feat/light deployments update
This commit is contained in:
Ernesto Boado 2021-02-06 10:48:35 +01:00 committed by GitHub
commit 2a042ab82d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
75 changed files with 4002 additions and 4064 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
.gitlab-ci.yml
View File

@ -1,5 +1,22 @@
stages:
- checks
- prepare
- publish
variables:
IMAGE: ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}
lint:
stage: checks
tags:
- aave-build-runner
before_script:
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml build
script:
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml run contracts-env npm run prettier:check
after_script:
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml run contracts-env npm run ci:clean
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml down
test:
stage: checks
@ -12,7 +29,9 @@ test:
after_script:
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml run contracts-env npm run ci:clean
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml down
only:
- master
- merge_requests
deploy-mainnet-fork:
tags:
- aave-build-runner
@ -24,6 +43,9 @@ deploy-mainnet-fork:
after_script:
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml run contracts-env npm run ci:clean
- docker-compose -p ${CI_JOB_ID} -f docker-compose.test.yml down
only:
- master
- merge_requests
certora-test:
stage: checks
@ -40,3 +62,31 @@ certora-test:
- certoraRun specs/harness/StableDebtTokenHarness.sol:StableDebtTokenHarness --solc_args "['--optimize']" --verify StableDebtTokenHarness:specs/StableDebtToken.spec --settings -assumeUnwindCond,-b=4 --cache StableDebtToken --cloud
- certoraRun specs/harness/UserConfigurationHarness.sol --verify UserConfigurationHarness:specs/UserConfiguration.spec --solc_args "['--optimize']" --settings -useBitVectorTheory --cache UserConfiguration --cloud
- certoraRun contracts/protocol/tokenization/VariableDebtToken.sol:VariableDebtToken specs/harness/LendingPoolHarnessForVariableDebtToken.sol --solc_args "['--optimize']" --link VariableDebtToken:POOL=LendingPoolHarnessForVariableDebtToken --verify VariableDebtToken:specs/VariableDebtToken.spec --settings -assumeUnwindCond,-useNonLinearArithmetic,-b=4 --cache VariableDebtToken --cloud
only:
- master
- merge_requests
prepare:
stage: prepare
tags:
- docker-builder
script:
- docker build -t ${IMAGE} .
- docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN $CI_REGISTRY
- docker push ${IMAGE}
only:
- master
publish:
image: ${IMAGE}
tags:
- docker
stage: publish
script:
- npm ci
- echo //registry.npmjs.org/:_authToken=${NPM_V2_PACKAGES_TOKEN} > .npmrc
- npm run compile
- ${VERSION}
- npm publish --access public
only:
- master

32
README.md
View File

@ -34,11 +34,43 @@ A more detailed and technical description of the protocol can be found in this r
- CertiK (28/09/2020 - 02/12/2020): [report](./audits/Certik-aave-v2-03-12-2020.pdf)
- Consensys Diligence (09/09/2020 - 09/10/2020): [report](https://consensys.net/diligence/audits/2020/09/aave-protocol-v2/)
- Certora, formal verification (02/08/2020 - 29/10/2020): [report](./audits/Certora-FV-aave-v2-03-12-2020.pdf)
- SigmaPrime (January 2021): [report](./audits/SigmaPrime-aave-v2-01-2021.pdf)
## Connect with the community
You can join at the [Discord](http://aave.com/discord) channel or at the [Governance Forum](https://governance.aave.com/) for asking questions about the protocol or talk about Aave with other peers.
## Getting Started
You can install `@aave/protocol-v2` as an NPM package in your Hardhat, Buidler or Truffle project to import the contracts and interfaces:
`npm install @aave/protocol-v2`
Import at Solidity files:
```
import {ILendingPool} from "@aave/protocol-v2/contracts/interfaces/ILendingPool.sol";
contract Misc {
function deposit(address pool, address token, address user, uint256 amount) {
ILendingPool(pool).deposit(token, amount, user, '0');
{...}
}
}
```
The JSON artifacts with the ABI and Bytecode are also included into the bundled NPM package at `artifacts/` directory.
Import JSON file via Node JS `require`:
```
const LendingPoolV2Artifact = require('@aave/protocol-v2/artifacts/contracts/protocol/lendingpool/LendingPool.sol/LendingPool.json');
// Log the ABI into console
console.log(LendingPoolV2Artifact.abi)
```
## Setup
The repository uses Docker Compose to manage sensitive keys and load the configuration. Prior any action like test or deploy, you must run `docker-compose up` to start the `contracts-env` container, and then connect to the container console via `docker-compose exec contracts-env bash`.

BIN
audits/SigmaPrime-aave-v2-01-2021.pdf Normal file
View File

Binary file not shown.

33
contracts/adapters/BaseUniswapAdapter.sol
View File

@ -346,6 +346,21 @@ abstract contract BaseUniswapAdapter is FlashLoanReceiverBase, IBaseUniswapAdapt
// Subtract flash loan fee
uint256 finalAmountIn = amountIn.sub(amountIn.mul(FLASHLOAN_PREMIUM_TOTAL).div(10000));
if (reserveIn == reserveOut) {
uint256 reserveDecimals = _getDecimals(reserveIn);
address[] memory path = new address[](1);
path[0] = reserveIn;
return
AmountCalc(
finalAmountIn,
finalAmountIn.mul(10**18).div(amountIn),
_calcUsdValue(reserveIn, amountIn, reserveDecimals),
_calcUsdValue(reserveIn, finalAmountIn, reserveDecimals),
path
);
}
address[] memory simplePath = new address[](2);
simplePath[0] = reserveIn;
simplePath[1] = reserveOut;
@ -371,6 +386,7 @@ abstract contract BaseUniswapAdapter is FlashLoanReceiverBase, IBaseUniswapAdapt
}
uint256 bestAmountOut;
try UNISWAP_ROUTER.getAmountsOut(finalAmountIn, simplePath) returns (
uint256[] memory resultAmounts
) {
@ -420,6 +436,23 @@ abstract contract BaseUniswapAdapter is FlashLoanReceiverBase, IBaseUniswapAdapt
address reserveOut,
uint256 amountOut
) internal view returns (AmountCalc memory) {
if (reserveIn == reserveOut) {
// Add flash loan fee
uint256 amountIn = amountOut.add(amountOut.mul(FLASHLOAN_PREMIUM_TOTAL).div(10000));
uint256 reserveDecimals = _getDecimals(reserveIn);
address[] memory path = new address[](1);
path[0] = reserveIn;
return
AmountCalc(
amountIn,
amountOut.mul(10**18).div(amountIn),
_calcUsdValue(reserveIn, amountIn, reserveDecimals),
_calcUsdValue(reserveIn, amountOut, reserveDecimals),
path
);
}
(uint256[] memory amounts, address[] memory path) =
_getAmountsInAndPath(reserveIn, reserveOut, amountOut);

184
contracts/adapters/FlashLiquidationAdapter.sol Normal file
View File

@ -0,0 +1,184 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import {BaseUniswapAdapter} from './BaseUniswapAdapter.sol';
import {ILendingPoolAddressesProvider} from '../interfaces/ILendingPoolAddressesProvider.sol';
import {IUniswapV2Router02} from '../interfaces/IUniswapV2Router02.sol';
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {DataTypes} from '../protocol/libraries/types/DataTypes.sol';
import {Helpers} from '../protocol/libraries/helpers/Helpers.sol';
import {IPriceOracleGetter} from '../interfaces/IPriceOracleGetter.sol';
import {IAToken} from '../interfaces/IAToken.sol';
import {ReserveConfiguration} from '../protocol/libraries/configuration/ReserveConfiguration.sol';
/**
* @title UniswapLiquiditySwapAdapter
* @notice Uniswap V2 Adapter to swap liquidity.
* @author Aave
**/
contract FlashLiquidationAdapter is BaseUniswapAdapter {
using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
uint256 internal constant LIQUIDATION_CLOSE_FACTOR_PERCENT = 5000;
struct LiquidationParams {
address collateralAsset;
address borrowedAsset;
address user;
uint256 debtToCover;
bool useEthPath;
}
struct LiquidationCallLocalVars {
uint256 initFlashBorrowedBalance;
uint256 diffFlashBorrowedBalance;
uint256 initCollateralBalance;
uint256 diffCollateralBalance;
uint256 flashLoanDebt;
uint256 soldAmount;
uint256 remainingTokens;
uint256 borrowedAssetLeftovers;
}
constructor(
ILendingPoolAddressesProvider addressesProvider,
IUniswapV2Router02 uniswapRouter,
address wethAddress
) public BaseUniswapAdapter(addressesProvider, uniswapRouter, wethAddress) {}
/**
* @dev Liquidate a non-healthy position collateral-wise, with a Health Factor below 1, using Flash Loan and Uniswap to repay flash loan premium.
* - The caller (liquidator) with a flash loan covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk minus the flash loan premium.
* @param assets Address of asset to be swapped
* @param amounts Amount of the asset to be swapped
* @param premiums Fee of the flash loan
* @param initiator Address of the caller
* @param params Additional variadic field to include extra params. Expected parameters:
* address collateralAsset The collateral asset to release and will be exchanged to pay the flash loan premium
* address borrowedAsset The asset that must be covered
* address user The user address with a Health Factor below 1
* uint256 debtToCover The amount of debt to cover
* bool useEthPath Use WETH as connector path between the collateralAsset and borrowedAsset at Uniswap
*/
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override returns (bool) {
require(msg.sender == address(LENDING_POOL), 'CALLER_MUST_BE_LENDING_POOL');
LiquidationParams memory decodedParams = _decodeParams(params);
require(assets.length == 1 && assets[0] == decodedParams.borrowedAsset, 'INCONSISTENT_PARAMS');
_liquidateAndSwap(
decodedParams.collateralAsset,
decodedParams.borrowedAsset,
decodedParams.user,
decodedParams.debtToCover,
decodedParams.useEthPath,
amounts[0],
premiums[0],
initiator
);
return true;
}
/**
* @dev
* @param collateralAsset The collateral asset to release and will be exchanged to pay the flash loan premium
* @param borrowedAsset The asset that must be covered
* @param user The user address with a Health Factor below 1
* @param debtToCover The amount of debt to coverage, can be max(-1) to liquidate all possible debt
* @param useEthPath true if the swap needs to occur using ETH in the routing, false otherwise
* @param flashBorrowedAmount Amount of asset requested at the flash loan to liquidate the user position
* @param premium Fee of the requested flash loan
* @param initiator Address of the caller
*/
function _liquidateAndSwap(
address collateralAsset,
address borrowedAsset,
address user,
uint256 debtToCover,
bool useEthPath,
uint256 flashBorrowedAmount,
uint256 premium,
address initiator
) internal {
LiquidationCallLocalVars memory vars;
vars.initCollateralBalance = IERC20(collateralAsset).balanceOf(address(this));
if (collateralAsset != borrowedAsset) {
vars.initFlashBorrowedBalance = IERC20(borrowedAsset).balanceOf(address(this));
// Track leftover balance to rescue funds in case of external transfers into this contract
vars.borrowedAssetLeftovers = vars.initFlashBorrowedBalance.sub(flashBorrowedAmount);
}
vars.flashLoanDebt = flashBorrowedAmount.add(premium);
// Approve LendingPool to use debt token for liquidation
IERC20(borrowedAsset).approve(address(LENDING_POOL), debtToCover);
// Liquidate the user position and release the underlying collateral
LENDING_POOL.liquidationCall(collateralAsset, borrowedAsset, user, debtToCover, false);
// Discover the liquidated tokens
uint256 collateralBalanceAfter = IERC20(collateralAsset).balanceOf(address(this));
// Track only collateral released, not current asset balance of the contract
vars.diffCollateralBalance = collateralBalanceAfter.sub(vars.initCollateralBalance);
if (collateralAsset != borrowedAsset) {
// Discover flash loan balance after the liquidation
uint256 flashBorrowedAssetAfter = IERC20(borrowedAsset).balanceOf(address(this));
// Use only flash loan borrowed assets, not current asset balance of the contract
vars.diffFlashBorrowedBalance = flashBorrowedAssetAfter.sub(vars.borrowedAssetLeftovers);
// Swap released collateral into the debt asset, to repay the flash loan
vars.soldAmount = _swapTokensForExactTokens(
collateralAsset,
borrowedAsset,
vars.diffCollateralBalance,
vars.flashLoanDebt.sub(vars.diffFlashBorrowedBalance),
useEthPath
);
vars.remainingTokens = vars.diffCollateralBalance.sub(vars.soldAmount);
} else {
vars.remainingTokens = vars.diffCollateralBalance.sub(premium);
}
// Allow repay of flash loan
IERC20(borrowedAsset).approve(address(LENDING_POOL), vars.flashLoanDebt);
// Transfer remaining tokens to initiator
if (vars.remainingTokens > 0) {
IERC20(collateralAsset).transfer(initiator, vars.remainingTokens);
}
}
/**
* @dev Decodes the information encoded in the flash loan params
* @param params Additional variadic field to include extra params. Expected parameters:
* address collateralAsset The collateral asset to claim
* address borrowedAsset The asset that must be covered and will be exchanged to pay the flash loan premium
* address user The user address with a Health Factor below 1
* uint256 debtToCover The amount of debt to cover
* bool useEthPath Use WETH as connector path between the collateralAsset and borrowedAsset at Uniswap
* @return LiquidationParams struct containing decoded params
*/
function _decodeParams(bytes memory params) internal pure returns (LiquidationParams memory) {
(
address collateralAsset,
address borrowedAsset,
address user,
uint256 debtToCover,
bool useEthPath
) = abi.decode(params, (address, address, address, uint256, bool));
return LiquidationParams(collateralAsset, borrowedAsset, user, debtToCover, useEthPath);
}
}

37
contracts/adapters/UniswapLiquiditySwapAdapter.sol
View File

@ -187,16 +187,16 @@ contract UniswapLiquiditySwapAdapter is BaseUniswapAdapter {
* @param permitSignature List of struct containing the permit signature
* @param useEthPath true if the swap needs to occur using ETH in the routing, false otherwise
*/
struct SwapLiquidityLocalVars {
address aToken;
uint256 aTokenInitiatorBalance;
uint256 amountToSwap;
uint256 receivedAmount;
uint256 flashLoanDebt;
uint256 amountToPull;
address aToken;
uint256 aTokenInitiatorBalance;
uint256 amountToSwap;
uint256 receivedAmount;
uint256 flashLoanDebt;
uint256 amountToPull;
}
function _swapLiquidity(
address assetFrom,
address assetTo,
@ -208,19 +208,22 @@ contract UniswapLiquiditySwapAdapter is BaseUniswapAdapter {
PermitSignature memory permitSignature,
bool useEthPath
) internal {
SwapLiquidityLocalVars memory vars;
vars.aToken = _getReserveData(assetFrom).aTokenAddress;
vars.aTokenInitiatorBalance = IERC20(vars.aToken).balanceOf(initiator);
vars.amountToSwap =
swapAllBalance && vars.aTokenInitiatorBalance.sub(premium) <= amount
? vars.aTokenInitiatorBalance.sub(premium)
: amount;
vars.amountToSwap = swapAllBalance && vars.aTokenInitiatorBalance.sub(premium) <= amount
? vars.aTokenInitiatorBalance.sub(premium)
: amount;
vars.receivedAmount =
_swapExactTokensForTokens(assetFrom, assetTo, vars.amountToSwap, minAmountToReceive, useEthPath);
vars.receivedAmount = _swapExactTokensForTokens(
assetFrom,
assetTo,
vars.amountToSwap,
minAmountToReceive,
useEthPath
);
// Deposit new reserve
IERC20(assetTo).safeApprove(address(LENDING_POOL), 0);
@ -277,4 +280,4 @@ contract UniswapLiquiditySwapAdapter is BaseUniswapAdapter {
useEthPath
);
}
}
}

11
contracts/adapters/UniswapRepayAdapter.sol
View File

@ -200,7 +200,13 @@ contract UniswapRepayAdapter is BaseUniswapAdapter {
);
// Swap collateral asset to the debt asset
_swapTokensForExactTokens(collateralAsset, debtAsset, amounts[0], neededForFlashLoanDebt, useEthPath);
_swapTokensForExactTokens(
collateralAsset,
debtAsset,
amounts[0],
neededForFlashLoanDebt,
useEthPath
);
} else {
// Pull aTokens from user
_pullAToken(
@ -228,6 +234,7 @@ contract UniswapRepayAdapter is BaseUniswapAdapter {
* uint8 v V param for the permit signature
* bytes32 r R param for the permit signature
* bytes32 s S param for the permit signature
* bool useEthPath use WETH path route
* @return RepayParams struct containing decoded params
*/
function _decodeParams(bytes memory params) internal pure returns (RepayParams memory) {
@ -256,4 +263,4 @@ contract UniswapRepayAdapter is BaseUniswapAdapter {
useEthPath
);
}
}
}

4
contracts/dependencies/openzeppelin/contracts/Context.sol
View File

@ -12,11 +12,11 @@ pragma solidity 0.6.12;
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}

6
contracts/dependencies/openzeppelin/contracts/ERC20.sol
View File

@ -95,14 +95,14 @@ contract ERC20 is Context, IERC20 {
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public override view returns (uint256) {
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public override view returns (uint256) {
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
@ -124,9 +124,9 @@ contract ERC20 is Context, IERC20 {
*/
function allowance(address owner, address spender)
public
view
virtual
override
view
returns (uint256)
{
return _allowances[owner][spender];

3
contracts/dependencies/openzeppelin/upgradeability/BaseAdminUpgradeabilityProxy.sol
View File

@ -24,7 +24,8 @@ contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
bytes32 internal constant ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Modifier to check whether the `msg.sender` is the admin.

5
contracts/dependencies/openzeppelin/upgradeability/BaseUpgradeabilityProxy.sol
View File

@ -22,13 +22,14 @@ contract BaseUpgradeabilityProxy is Proxy {
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
bytes32 internal constant IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/
function _implementation() internal override view returns (address impl) {
function _implementation() internal view override returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
//solium-disable-next-line
assembly {

2
contracts/dependencies/openzeppelin/upgradeability/Proxy.sol
View File

@ -20,7 +20,7 @@ abstract contract Proxy {
/**
* @return The Address of the implementation.
*/
function _implementation() internal virtual view returns (address);
function _implementation() internal view virtual returns (address);
/**
* @dev Delegates execution to an implementation contract.

16
contracts/interfaces/IUniswapV2Router02.sol
View File

@ -11,14 +11,20 @@ interface IUniswapV2Router02 {
) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint deadline
uint256 deadline
) external returns (uint256[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}

2
contracts/misc/AaveOracle.sol
View File

@ -80,7 +80,7 @@ contract AaveOracle is IPriceOracleGetter, Ownable {
/// @notice Gets an asset price by address
/// @param asset The asset address
function getAssetPrice(address asset) public override view returns (uint256) {
function getAssetPrice(address asset) public view override returns (uint256) {
IChainlinkAggregator source = assetsSources[asset];
if (asset == WETH) {

3
contracts/misc/WalletBalanceProvider.sol
View File

@ -93,7 +93,8 @@ contract WalletBalanceProvider {
uint256[] memory balances = new uint256[](reservesWithEth.length);
for (uint256 j = 0; j < reserves.length; j++) {
DataTypes.ReserveConfigurationMap memory configuration = pool.getConfiguration(reservesWithEth[j]);
DataTypes.ReserveConfigurationMap memory configuration =
pool.getConfiguration(reservesWithEth[j]);
(bool isActive, , , ) = configuration.getFlagsMemory();

5
contracts/mocks/flashloan/MockFlashLoanReceiver.sol
View File

@ -68,9 +68,8 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase {
'Invalid balance for the contract'
);
uint256 amountToReturn = (_amountToApprove != 0)
? _amountToApprove
: amounts[i].add(premiums[i]);
uint256 amountToReturn =
(_amountToApprove != 0) ? _amountToApprove : amounts[i].add(premiums[i]);
//execution does not fail - mint tokens and return them to the _destination
token.mint(premiums[i]);

2
contracts/mocks/oracle/LendingRateOracle.sol
View File

@ -8,7 +8,7 @@ contract LendingRateOracle is ILendingRateOracle, Ownable {
mapping(address => uint256) borrowRates;
mapping(address => uint256) liquidityRates;
function getMarketBorrowRate(address _asset) external override view returns (uint256) {
function getMarketBorrowRate(address _asset) external view override returns (uint256) {
return borrowRates[_asset];
}

2
contracts/mocks/oracle/PriceOracle.sol
View File

@ -10,7 +10,7 @@ contract PriceOracle is IPriceOracle {
event AssetPriceUpdated(address _asset, uint256 _price, uint256 timestamp);
event EthPriceUpdated(uint256 _price, uint256 timestamp);
function getAssetPrice(address _asset) external override view returns (uint256) {
function getAssetPrice(address _asset) external view override returns (uint256) {
return prices[_asset];
}

4
contracts/protocol/lendingpool/DefaultReserveInterestRateStrategy.sol
View File

@ -139,9 +139,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
vars.currentLiquidityRate = 0;
uint256 utilizationRate =
vars.totalDebt == 0
? 0
: vars.totalDebt.rayDiv(availableLiquidity.add(vars.totalDebt));
vars.totalDebt == 0 ? 0 : vars.totalDebt.rayDiv(availableLiquidity.add(vars.totalDebt));
vars.currentStableBorrowRate = ILendingRateOracle(addressesProvider.getLendingRateOracle())
.getMarketBorrowRate(reserve);

1
contracts/protocol/lendingpool/LendingPool.sol
View File

@ -441,6 +441,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
receiveAToken
)
);
require(success, Errors.LP_LIQUIDATION_CALL_FAILED);
(uint256 returnCode, string memory returnMessage) = abi.decode(result, (uint256, string));

10
contracts/protocol/libraries/aave-upgradeability/VersionedInitializable.sol
View File

@ -50,14 +50,14 @@ abstract contract VersionedInitializable {
}
/**
* @dev returns the revision number of the contract
* Needs to be defined in the inherited class as a constant.
**/
* @dev returns the revision number of the contract
* Needs to be defined in the inherited class as a constant.
**/
function getRevision() internal pure virtual returns (uint256);
/**
* @dev Returns true if and only if the function is running in the constructor
**/
* @dev Returns true if and only if the function is running in the constructor
**/
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not

41
contracts/protocol/libraries/configuration/ReserveConfiguration.sol
View File

@ -90,7 +90,10 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @param bonus The new liquidation bonus
**/
function setLiquidationBonus(DataTypes.ReserveConfigurationMap memory self, uint256 bonus) internal pure {
function setLiquidationBonus(DataTypes.ReserveConfigurationMap memory self, uint256 bonus)
internal
pure
{
require(bonus <= MAX_VALID_LIQUIDATION_BONUS, Errors.RC_INVALID_LIQ_BONUS);
self.data =
@ -116,7 +119,10 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @param decimals The decimals
**/
function setDecimals(DataTypes.ReserveConfigurationMap memory self, uint256 decimals) internal pure {
function setDecimals(DataTypes.ReserveConfigurationMap memory self, uint256 decimals)
internal
pure
{
require(decimals <= MAX_VALID_DECIMALS, Errors.RC_INVALID_DECIMALS);
self.data = (self.data & DECIMALS_MASK) | (decimals << RESERVE_DECIMALS_START_BIT_POSITION);
@ -127,7 +133,11 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @return The decimals of the asset
**/
function getDecimals(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256) {
function getDecimals(DataTypes.ReserveConfigurationMap storage self)
internal
view
returns (uint256)
{
return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION;
}
@ -176,7 +186,10 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @param enabled True if the borrowing needs to be enabled, false otherwise
**/
function setBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled) internal pure {
function setBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled)
internal
pure
{
self.data =
(self.data & BORROWING_MASK) |
(uint256(enabled ? 1 : 0) << BORROWING_ENABLED_START_BIT_POSITION);
@ -187,7 +200,11 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @return The borrowing state
**/
function getBorrowingEnabled(DataTypes.ReserveConfigurationMap storage self) internal view returns (bool) {
function getBorrowingEnabled(DataTypes.ReserveConfigurationMap storage self)
internal
view
returns (bool)
{
return (self.data & ~BORROWING_MASK) != 0;
}
@ -196,10 +213,10 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @param enabled True if the stable rate borrowing needs to be enabled, false otherwise
**/
function setStableRateBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled)
internal
pure
{
function setStableRateBorrowingEnabled(
DataTypes.ReserveConfigurationMap memory self,
bool enabled
) internal pure {
self.data =
(self.data & STABLE_BORROWING_MASK) |
(uint256(enabled ? 1 : 0) << STABLE_BORROWING_ENABLED_START_BIT_POSITION);
@ -239,7 +256,11 @@ library ReserveConfiguration {
* @param self The reserve configuration
* @return The reserve factor
**/
function getReserveFactor(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256) {
function getReserveFactor(DataTypes.ReserveConfigurationMap storage self)
internal
view
returns (uint256)
{
return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION;
}

9
contracts/protocol/libraries/configuration/UserConfiguration.sol
View File

@ -53,11 +53,10 @@ library UserConfiguration {
* @param reserveIndex The index of the reserve in the bitmap
* @return True if the user has been using a reserve for borrowing or as collateral, false otherwise
**/
function isUsingAsCollateralOrBorrowing(DataTypes.UserConfigurationMap memory self, uint256 reserveIndex)
internal
pure
returns (bool)
{
function isUsingAsCollateralOrBorrowing(
DataTypes.UserConfigurationMap memory self,
uint256 reserveIndex
) internal pure returns (bool) {
require(reserveIndex < 128, Errors.UL_INVALID_INDEX);
return (self.data >> (reserveIndex * 2)) & 3 != 0;
}

11
contracts/protocol/libraries/logic/GenericLogic.sol
View File

@ -65,7 +65,7 @@ library GenericLogic {
if (!userConfig.isBorrowingAny() || !userConfig.isUsingAsCollateral(reservesData[asset].id)) {
return true;
}
balanceDecreaseAllowedLocalVars memory vars;
(, vars.liquidationThreshold, , vars.decimals, ) = reservesData[asset]
@ -73,7 +73,7 @@ library GenericLogic {
.getParams();
if (vars.liquidationThreshold == 0) {
return true;
return true;
}
(
@ -213,9 +213,7 @@ library GenericLogic {
}
}
vars.avgLtv = vars.totalCollateralInETH > 0
? vars.avgLtv.div(vars.totalCollateralInETH)
: 0;
vars.avgLtv = vars.totalCollateralInETH > 0 ? vars.avgLtv.div(vars.totalCollateralInETH) : 0;
vars.avgLiquidationThreshold = vars.totalCollateralInETH > 0
? vars.avgLiquidationThreshold.div(vars.totalCollateralInETH)
: 0;
@ -265,8 +263,7 @@ library GenericLogic {
uint256 totalDebtInETH,
uint256 ltv
) internal pure returns (uint256) {
uint256 availableBorrowsETH = totalCollateralInETH.percentMul(ltv);
uint256 availableBorrowsETH = totalCollateralInETH.percentMul(ltv);
if (availableBorrowsETH < totalDebtInETH) {
return 0;

192
helpers/contracts-deployments.ts
View File

@ -11,7 +11,6 @@ import {
PoolConfiguration,
eEthereumNetwork,
} from './types';
import { MintableERC20 } from '../types/MintableERC20';
import { MockContract } from 'ethereum-waffle';
import { getReservesConfigByPool } from './configuration';
@ -49,6 +48,7 @@ import {
WalletBalanceProviderFactory,
WETH9MockedFactory,
WETHGatewayFactory,
FlashLiquidationAdapterFactory,
} from '../types';
import {
withSaveAndVerify,
@ -68,6 +68,7 @@ const readArtifact = async (id: string) => {
}
return (DRE as HardhatRuntimeEnvironment).artifacts.readArtifact(id);
};
export const deployLendingPoolAddressesProvider = async (marketId: string, verify?: boolean) =>
withSaveAndVerify(
await new LendingPoolAddressesProviderFactory(await getFirstSigner()).deploy(marketId),
@ -301,78 +302,111 @@ export const deployDefaultReserveInterestRateStrategy = async (
export const deployStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
verify: boolean
) =>
withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.StableDebtToken,
args,
[],
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
return instance;
}
export const deployVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
verify: boolean
) =>
withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.VariableDebtToken,
args,
[],
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
return instance;
}
export const deployGenericAToken = async (
[poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController]: [
[poolAddress, underlyingAssetAddress, treasuryAddress, incentivesController, name, symbol]: [
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress
string
],
verify: boolean
) => {
const args: [
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress,
tEthereumAddress
] = [poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController];
return withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(...args),
const instance = await withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(),
eContractid.AToken,
args,
[],
verify
);
await instance.initialize(
poolAddress,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
"18",
name,
symbol
);
return instance;
};
export const deployDelegationAwareAToken = async (
[poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController]: [
[pool, underlyingAssetAddress, treasuryAddress, incentivesController, name, symbol]: [
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress
string
],
verify: boolean
) => {
const args: [
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress,
tEthereumAddress
] = [poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController];
return withSaveAndVerify(
await new DelegationAwareATokenFactory(await getFirstSigner()).deploy(...args),
const instance = await withSaveAndVerify(
await new DelegationAwareATokenFactory(await getFirstSigner()).deploy(),
eContractid.DelegationAwareAToken,
args,
[],
verify
);
await instance.initialize(
pool,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
"18",
name,
symbol
)
return instance;
};
export const deployAllMockTokens = async (verify?: boolean) => {
@ -389,6 +423,7 @@ export const deployAllMockTokens = async (verify?: boolean) => {
[tokenSymbol, tokenSymbol, configData ? configData.reserveDecimals : decimals],
verify
);
await registerContractInJsonDb(tokenSymbol.toUpperCase(), tokens[tokenSymbol]);
}
return tokens;
};
@ -448,16 +483,29 @@ export const deployWETHGateway = async (
);
export const deployMockStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify?: boolean
) =>
withSaveAndVerify(
await new MockStableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new MockStableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.MockStableDebtToken,
args,
[],
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
return instance;
}
export const deployWETHMocked = async (verify?: boolean) =>
withSaveAndVerify(
await new WETH9MockedFactory(await getFirstSigner()).deploy(),
@ -467,26 +515,53 @@ export const deployWETHMocked = async (verify?: boolean) =>
);
export const deployMockVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify?: boolean
) =>
withSaveAndVerify(
await new MockVariableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new MockVariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.MockVariableDebtToken,
args,
[],
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
return instance;
}
export const deployMockAToken = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress,tEthereumAddress, string, string],
verify?: boolean
) =>
withSaveAndVerify(
await new MockATokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new MockATokenFactory(await getFirstSigner()).deploy(),
eContractid.MockAToken,
args,
[],
verify
);
await instance.initialize(
args[0],
args[2],
args[1],
args[3],
"18",
args[4],
args[5],
);
return instance;
}
export const deploySelfdestructTransferMock = async (verify?: boolean) =>
withSaveAndVerify(
@ -525,3 +600,14 @@ export const deployUniswapRepayAdapter = async (
args,
verify
);
export const deployFlashLiquidationAdapter = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress],
verify?: boolean
) =>
withSaveAndVerify(
await new FlashLiquidationAdapterFactory(await getFirstSigner()).deploy(...args),
eContractid.FlashLiquidationAdapter,
args,
verify
);

9
helpers/contracts-getters.ts
View File

@ -29,6 +29,7 @@ import {
WalletBalanceProviderFactory,
WETH9MockedFactory,
WETHGatewayFactory,
FlashLiquidationAdapterFactory,
} from '../types';
import { IERC20DetailedFactory } from '../types/IERC20DetailedFactory';
import { MockTokenMap } from './contracts-helpers';
@ -354,3 +355,11 @@ export const getUniswapRepayAdapter = async (address?: tEthereumAddress) =>
(await getDb().get(`${eContractid.UniswapRepayAdapter}.${DRE.network.name}`).value()).address,
await getFirstSigner()
);
export const getFlashLiquidationAdapter = async (address?: tEthereumAddress) =>
await FlashLiquidationAdapterFactory.connect(
address ||
(await getDb().get(`${eContractid.FlashLiquidationAdapter}.${DRE.network.name}`).value())
.address,
await getFirstSigner()
);

17
helpers/contracts-helpers.ts
View File

@ -17,6 +17,7 @@ import { Artifact } from 'hardhat/types';
import { Artifact as BuidlerArtifact } from '@nomiclabs/buidler/types';
import { verifyContract } from './etherscan-verification';
import { getIErc20Detailed } from './contracts-getters';
import { usingTenderly } from './tenderly-utils';
export type MockTokenMap = { [symbol: string]: MintableERC20 };
@ -90,7 +91,8 @@ export const withSaveAndVerify = async <ContractType extends Contract>(
): Promise<ContractType> => {
await waitForTx(instance.deployTransaction);
await registerContractInJsonDb(id, instance);
if (DRE.network.name.includes('tenderly')) {
if (usingTenderly()) {
console.log('doing verify of', id);
await (DRE as any).tenderlyRPC.verify({
name: id,
address: instance.address,
@ -286,3 +288,16 @@ export const buildRepayAdapterParams = (
[collateralAsset, collateralAmount, rateMode, permitAmount, deadline, v, r, s, useEthPath]
);
};
export const buildFlashLiquidationAdapterParams = (
collateralAsset: tEthereumAddress,
debtAsset: tEthereumAddress,
user: tEthereumAddress,
debtToCover: BigNumberish,
useEthPath: boolean
) => {
return ethers.utils.defaultAbiCoder.encode(
['address', 'address', 'address', 'uint256', 'bool'],
[collateralAsset, debtAsset, user, debtToCover, useEthPath]
);
};

8
helpers/etherscan-verification.ts
View File

@ -1,7 +1,7 @@
import {exit} from 'process';
import { exit } from 'process';
import fs from 'fs';
import {file} from 'tmp-promise';
import {DRE} from './misc-utils';
import { file } from 'tmp-promise';
import { DRE } from './misc-utils';
const fatalErrors = [
`The address provided as argument contains a contract, but its bytecode`,
@ -43,7 +43,7 @@ export const verifyContract = async (
const msDelay = 3000;
const times = 4;
// Write a temporal file to host complex parameters for buidler-etherscan https://github.com/nomiclabs/buidler/tree/development/packages/buidler-etherscan#complex-arguments
const {fd, path, cleanup} = await file({
const { fd, path, cleanup } = await file({
prefix: 'verify-params-',
postfix: '.js',
});

226
helpers/init-helpers.ts
View File

@ -12,6 +12,7 @@ import {
getAToken,
getATokensAndRatesHelper,
getLendingPoolAddressesProvider,
getLendingPoolConfiguratorProxy,
getStableAndVariableTokensHelper,
} from './contracts-getters';
import { rawInsertContractAddressInDb } from './contracts-helpers';
@ -75,11 +76,30 @@ export const initReservesByHelper = async (
let reserveInitDecimals: string[] = [];
let reserveSymbols: string[] = [];
let initInputParams: {
aTokenImpl: string,
stableDebtTokenImpl: string,
variableDebtTokenImpl: string,
underlyingAssetDecimals: BigNumberish,
interestRateStrategyAddress: string,
underlyingAsset: string,
treasury: string,
incentivesController: string,
underlyingAssetName: string,
aTokenName: string,
aTokenSymbol: string,
variableDebtTokenName: string,
variableDebtTokenSymbol: string,
stableDebtTokenName: string,
stableDebtTokenSymbol: string,
}[] = [];
console.log(
`- Token deployments in ${reservesChunks.length * 2} txs instead of ${
Object.entries(reservesParams).length * 4
} txs`
);
for (let reservesChunk of reservesChunks) {
// Prepare data
const tokens: string[] = [];
@ -94,6 +114,18 @@ export const initReservesByHelper = async (
][] = [];
const reservesDecimals: string[] = [];
const inputParams: {
asset: string,
rates: [
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish
]
}[] = [];
for (let [assetSymbol, { reserveDecimals }] of reservesChunk) {
const assetAddressIndex = Object.keys(tokenAddresses).findIndex(
(value) => value === assetSymbol
@ -128,11 +160,23 @@ export const initReservesByHelper = async (
stableRateSlope2,
]);
reservesDecimals.push(reserveDecimals);
inputParams.push({
asset: tokenAddress,
rates: [
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2
]
});
}
// Deploy stable and variable deployers and save implementations
const tx1 = await waitForTx(
await stableAndVariableDeployer.initDeployment(tokens, symbols, incentivesController)
await stableAndVariableDeployer.initDeployment(tokens, symbols)
);
tx1.events?.forEach((event, index) => {
rawInsertContractAddressInDb(`stableDebt${symbols[index]}`, event?.args?.stableToken);
@ -141,13 +185,7 @@ export const initReservesByHelper = async (
// Deploy atokens and rate strategies and save implementations
const tx2 = await waitForTx(
await atokenAndRatesDeployer.initDeployment(
tokens,
symbols,
strategyRates,
treasuryAddress,
incentivesController
)
await atokenAndRatesDeployer.initDeployment(inputParams)
);
tx2.events?.forEach((event, index) => {
rawInsertContractAddressInDb(`a${symbols[index]}`, event?.args?.aToken);
@ -158,7 +196,7 @@ export const initReservesByHelper = async (
console.log(' * gasUsed: debtTokens batch', tx1.gasUsed.toString());
console.log(' * gasUsed: aTokens and Strategy batch', tx2.gasUsed.toString());
gasUsage = gasUsage.add(tx1.gasUsed).add(tx2.gasUsed);
const stableTokens: string[] = tx1.events?.map((e) => e.args?.stableToken) || [];
const variableTokens: string[] = tx1.events?.map((e) => e.args?.variableToken) || [];
const aTokens: string[] = tx2.events?.map((e) => e.args?.aToken) || [];
@ -194,9 +232,9 @@ export const initReservesByHelper = async (
poolAddress,
tokenAddresses[symbol],
treasuryAddress,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -204,9 +242,9 @@ export const initReservesByHelper = async (
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`,
ZERO_ADDRESS,
`stableDebt${symbol}`
],
verify
);
@ -214,9 +252,9 @@ export const initReservesByHelper = async (
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -242,24 +280,37 @@ export const initReservesByHelper = async (
reserveSymbols.push(symbol);
}
// Deploy init reserves per chunks
const chunkedStableTokens = chunk(deployedStableTokens, initChunks);
const chunkedVariableTokens = chunk(deployedVariableTokens, initChunks);
const chunkedAtokens = chunk(deployedATokens, initChunks);
const chunkedRates = chunk(deployedRates, initChunks);
const chunkedDecimals = chunk(reserveInitDecimals, initChunks);
const chunkedSymbols = chunk(reserveSymbols, initChunks);
for (let i = 0; i < deployedATokens.length; i ++) {
initInputParams.push({
aTokenImpl: deployedATokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
variableDebtTokenImpl: deployedVariableTokens[i],
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: deployedRates[i],
underlyingAsset: reserveTokens[i],
treasury: treasuryAddress,
incentivesController: ZERO_ADDRESS,
underlyingAssetName: reserveSymbols[i],
aTokenName: `Aave interest bearing ${reserveSymbols[i]}`,
aTokenSymbol: `a${reserveSymbols[i]}`,
variableDebtTokenName: `Aave variable debt bearing ${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${reserveSymbols[i]}`,
stableDebtTokenName: `Aave stable debt bearing ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`
});
}
console.log(`- Reserves initialization in ${chunkedStableTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedDecimals.length; chunkIndex++) {
// Deploy init reserves per chunks
const chunkedSymbols = chunk(reserveSymbols, initChunks);
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
const tx3 = await waitForTx(
await atokenAndRatesDeployer.initReserve(
chunkedStableTokens[chunkIndex],
chunkedVariableTokens[chunkIndex],
chunkedAtokens[chunkIndex],
chunkedRates[chunkIndex],
chunkedDecimals[chunkIndex]
)
await configurator.batchInitReserve(chunkedInitInputParams[chunkIndex])
);
console.log(` - Reserve ready for: ${chunkedSymbols[chunkIndex].join(', ')}`);
@ -267,6 +318,7 @@ export const initReservesByHelper = async (
gasUsage = gasUsage.add(tx3.gasUsed);
}
// Set deployer back as admin
await waitForTx(await addressProvider.setPoolAdmin(admin));
return gasUsage;
@ -315,6 +367,15 @@ export const configureReservesByHelper = async (
const reserveFactors: string[] = [];
const stableRatesEnabled: boolean[] = [];
const inputParams : {
asset: string;
baseLTV: BigNumberish;
liquidationThreshold: BigNumberish;
liquidationBonus: BigNumberish;
reserveFactor: BigNumberish;
stableBorrowingEnabled: boolean;
}[] = [];
for (const [
assetSymbol,
{
@ -342,6 +403,16 @@ export const configureReservesByHelper = async (
continue;
}
// Push data
inputParams.push({
asset: tokenAddress,
baseLTV: baseLTVAsCollateral,
liquidationThreshold: liquidationThreshold,
liquidationBonus: liquidationBonus,
reserveFactor: reserveFactor,
stableBorrowingEnabled: stableBorrowRateEnabled
});
tokens.push(tokenAddress);
symbols.push(assetSymbol);
baseLTVA.push(baseLTVAsCollateral);
@ -356,24 +427,14 @@ export const configureReservesByHelper = async (
// Deploy init per chunks
const enableChunks = 20;
const chunkedTokens = chunk(tokens, enableChunks);
const chunkedSymbols = chunk(symbols, enableChunks);
const chunkedBase = chunk(baseLTVA, enableChunks);
const chunkedliquidationThresholds = chunk(liquidationThresholds, enableChunks);
const chunkedliquidationBonuses = chunk(liquidationBonuses, enableChunks);
const chunkedReserveFactors = chunk(reserveFactors, enableChunks);
const chunkedStableRatesEnabled = chunk(stableRatesEnabled, enableChunks);
const chunkedInputParams = chunk(inputParams, enableChunks);
console.log(`- Configure reserves in ${chunkedTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedTokens.length; chunkIndex++) {
console.log(`- Configure reserves in ${chunkedInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInputParams.length; chunkIndex++) {
await waitForTx(
await atokenAndRatesDeployer.configureReserves(
chunkedTokens[chunkIndex],
chunkedBase[chunkIndex],
chunkedliquidationThresholds[chunkIndex],
chunkedliquidationBonuses[chunkIndex],
chunkedReserveFactors[chunkIndex],
chunkedStableRatesEnabled[chunkIndex],
chunkedInputParams[chunkIndex],
{ gasLimit: 12000000 }
)
);
@ -425,8 +486,28 @@ export const initTokenReservesByHelper = async (
let deployedVariableTokens: string[] = [];
let deployedATokens: string[] = [];
let deployedRates: string[] = [];
let reserveTokens: string[] = [];
let reserveInitDecimals: string[] = [];
let reserveSymbols: string[] = [];
let initInputParams: {
aTokenImpl: string,
stableDebtTokenImpl: string,
variableDebtTokenImpl: string,
underlyingAssetDecimals: BigNumberish,
interestRateStrategyAddress: string,
underlyingAsset: string,
treasury: string,
incentivesController: string,
underlyingAssetName: string,
aTokenName: string,
aTokenSymbol: string,
variableDebtTokenName: string,
variableDebtTokenSymbol: string,
stableDebtTokenName: string,
stableDebtTokenSymbol: string,
}[] = [];
const network =
process.env.MAINNET_FORK === 'true'
? eEthereumNetwork.main
@ -454,9 +535,9 @@ export const initTokenReservesByHelper = async (
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`,
ZERO_ADDRESS,
`stableDebt${symbol}`
],
verify
);
@ -467,9 +548,9 @@ export const initTokenReservesByHelper = async (
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives Controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
ZERO_ADDRESS,
`variableDebt${symbol}`
],
verify
);
@ -485,9 +566,9 @@ export const initTokenReservesByHelper = async (
poolAddress,
tokenAddresses[symbol],
treasuryAddress,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`
],
verify
);
@ -531,34 +612,47 @@ export const initTokenReservesByHelper = async (
deployedStableTokens.push(stableTokenImpl);
deployedVariableTokens.push(variableTokenImpl);
deployedATokens.push(aTokenImplementation);
reserveTokens.push();
deployedRates.push(strategyImpl);
reserveInitDecimals.push(decimals.toString());
reserveSymbols.push(symbol);
}
// Deploy init reserves per chunks
const chunkedStableTokens = chunk(deployedStableTokens, initChunks);
const chunkedVariableTokens = chunk(deployedVariableTokens, initChunks);
const chunkedAtokens = chunk(deployedATokens, initChunks);
const chunkedRates = chunk(deployedRates, initChunks);
const chunkedDecimals = chunk(reserveInitDecimals, initChunks);
const chunkedSymbols = chunk(reserveSymbols, initChunks);
for (let i = 0; i < deployedATokens.length; i ++) {
initInputParams.push({
aTokenImpl: deployedATokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
variableDebtTokenImpl: deployedVariableTokens[i],
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: deployedRates[i],
underlyingAsset: tokenAddresses[reserveSymbols[i]],
treasury: treasuryAddress,
incentivesController: ZERO_ADDRESS,
underlyingAssetName: reserveSymbols[i],
aTokenName: `Aave interest bearing ${reserveSymbols[i]}`,
aTokenSymbol: `a${reserveSymbols[i]}`,
variableDebtTokenName: `Aave variable debt bearing ${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${reserveSymbols[i]}`,
stableDebtTokenName: `Aave stable debt bearing ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`
});
}
console.log(`- Reserves initialization in ${chunkedStableTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedDecimals.length; chunkIndex++) {
// Deploy init reserves per chunks
const chunkedSymbols = chunk(reserveSymbols, initChunks);
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
const tx3 = await waitForTx(
await atokenAndRatesDeployer.initReserve(
chunkedStableTokens[chunkIndex],
chunkedVariableTokens[chunkIndex],
chunkedAtokens[chunkIndex],
chunkedRates[chunkIndex],
chunkedDecimals[chunkIndex]
)
await configurator.batchInitReserve(chunkedInitInputParams[chunkIndex])
);
console.log(` - Reserve ready for: ${chunkedSymbols[chunkIndex].join(', ')}`);
console.log(' * gasUsed', tx3.gasUsed.toString());
gasUsage = gasUsage.add(tx3.gasUsed);
}
// Set deployer back as admin

43
helpers/misc-utils.ts
View File

@ -2,13 +2,13 @@ import BigNumber from 'bignumber.js';
import BN = require('bn.js');
import low from 'lowdb';
import FileSync from 'lowdb/adapters/FileSync';
import {WAD} from './constants';
import {Wallet, ContractTransaction} from 'ethers';
import {HardhatRuntimeEnvironment} from 'hardhat/types';
import {BuidlerRuntimeEnvironment} from '@nomiclabs/buidler/types';
import {tEthereumAddress} from './types';
import {isAddress} from 'ethers/lib/utils';
import {isZeroAddress} from 'ethereumjs-util';
import { WAD } from './constants';
import { Wallet, ContractTransaction } from 'ethers';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { BuidlerRuntimeEnvironment } from '@nomiclabs/buidler/types';
import { tEthereumAddress } from './types';
import { isAddress } from 'ethers/lib/utils';
import { isZeroAddress } from 'ethereumjs-util';
export const toWad = (value: string | number) => new BigNumber(value).times(WAD).toFixed();
@ -17,9 +17,8 @@ export const stringToBigNumber = (amount: string): BigNumber => new BigNumber(am
export const getDb = () => low(new FileSync('./deployed-contracts.json'));
export let DRE:
| HardhatRuntimeEnvironment
| BuidlerRuntimeEnvironment = {} as HardhatRuntimeEnvironment;
export let DRE: HardhatRuntimeEnvironment | BuidlerRuntimeEnvironment;
export const setDRE = (_DRE: HardhatRuntimeEnvironment | BuidlerRuntimeEnvironment) => {
DRE = _DRE;
};
@ -47,12 +46,32 @@ export const increaseTime = async (secondsToIncrease: number) => {
await DRE.ethers.provider.send('evm_mine', []);
};
// Workaround for time travel tests bug: https://github.com/Tonyhaenn/hh-time-travel/blob/0161d993065a0b7585ec5a043af2eb4b654498b8/test/test.js#L12
export const advanceTimeAndBlock = async function (forwardTime: number) {
const currentBlockNumber = await DRE.ethers.provider.getBlockNumber();
const currentBlock = await DRE.ethers.provider.getBlock(currentBlockNumber);
if (currentBlock === null) {
/* Workaround for https://github.com/nomiclabs/hardhat/issues/1183
*/
await DRE.ethers.provider.send('evm_increaseTime', [forwardTime]);
await DRE.ethers.provider.send('evm_mine', []);
//Set the next blocktime back to 15 seconds
await DRE.ethers.provider.send('evm_increaseTime', [15]);
return;
}
const currentTime = currentBlock.timestamp;
const futureTime = currentTime + forwardTime;
await DRE.ethers.provider.send('evm_setNextBlockTimestamp', [futureTime]);
await DRE.ethers.provider.send('evm_mine', []);
};
export const waitForTx = async (tx: ContractTransaction) => await tx.wait(1);
export const filterMapBy = (raw: {[key: string]: any}, fn: (key: string) => boolean) =>
export const filterMapBy = (raw: { [key: string]: any }, fn: (key: string) => boolean) =>
Object.keys(raw)
.filter(fn)
.reduce<{[key: string]: any}>((obj, key) => {
.reduce<{ [key: string]: any }>((obj, key) => {
obj[key] = raw[key];
return obj;
}, {});

10
helpers/mock-helpers.ts
View File

@ -1,10 +1,10 @@
import {tEthereumAddress} from './types';
import {MockAggregator} from '../types/MockAggregator';
import {MockTokenMap} from './contracts-helpers';
import { tEthereumAddress } from './types';
import { MockAggregator } from '../types/MockAggregator';
import { MockTokenMap } from './contracts-helpers';
export const getAllTokenAddresses = (mockTokens: MockTokenMap) =>
Object.entries(mockTokens).reduce(
(accum: {[tokenSymbol: string]: tEthereumAddress}, [tokenSymbol, tokenContract]) => ({
(accum: { [tokenSymbol: string]: tEthereumAddress }, [tokenSymbol, tokenContract]) => ({
...accum,
[tokenSymbol]: tokenContract.address,
}),
@ -14,7 +14,7 @@ export const getAllAggregatorsAddresses = (mockAggregators: {
[tokenSymbol: string]: MockAggregator;
}) =>
Object.entries(mockAggregators).reduce(
(accum: {[tokenSymbol: string]: tEthereumAddress}, [tokenSymbol, aggregator]) => ({
(accum: { [tokenSymbol: string]: tEthereumAddress }, [tokenSymbol, aggregator]) => ({
...accum,
[tokenSymbol]: aggregator.address,
}),

20
helpers/oracles-helpers.ts
View File

@ -7,16 +7,16 @@ import {
SymbolMap,
} from './types';
import {LendingRateOracle} from '../types/LendingRateOracle';
import {PriceOracle} from '../types/PriceOracle';
import {MockAggregator} from '../types/MockAggregator';
import {deployMockAggregator} from './contracts-deployments';
import {chunk, waitForTx} from './misc-utils';
import {getStableAndVariableTokensHelper} from './contracts-getters';
import { LendingRateOracle } from '../types/LendingRateOracle';
import { PriceOracle } from '../types/PriceOracle';
import { MockAggregator } from '../types/MockAggregator';
import { deployMockAggregator } from './contracts-deployments';
import { chunk, waitForTx } from './misc-utils';
import { getStableAndVariableTokensHelper } from './contracts-getters';
export const setInitialMarketRatesInRatesOracleByHelper = async (
marketRates: iMultiPoolsAssets<IMarketRates>,
assetsAddresses: {[x: string]: tEthereumAddress},
assetsAddresses: { [x: string]: tEthereumAddress },
lendingRateOracleInstance: LendingRateOracle,
admin: tEthereumAddress
) => {
@ -24,7 +24,7 @@ export const setInitialMarketRatesInRatesOracleByHelper = async (
const assetAddresses: string[] = [];
const borrowRates: string[] = [];
const symbols: string[] = [];
for (const [assetSymbol, {borrowRate}] of Object.entries(marketRates) as [
for (const [assetSymbol, { borrowRate }] of Object.entries(marketRates) as [
string,
IMarketRates
][]) {
@ -99,7 +99,7 @@ export const setAssetPricesInOracle = async (
};
export const deployMockAggregators = async (initialPrices: SymbolMap<string>, verify?: boolean) => {
const aggregators: {[tokenSymbol: string]: MockAggregator} = {};
const aggregators: { [tokenSymbol: string]: MockAggregator } = {};
for (const tokenContractName of Object.keys(initialPrices)) {
if (tokenContractName !== 'ETH') {
const priceIndex = Object.keys(initialPrices).findIndex(
@ -116,7 +116,7 @@ export const deployAllMockAggregators = async (
initialPrices: iAssetAggregatorBase<string>,
verify?: boolean
) => {
const aggregators: {[tokenSymbol: string]: MockAggregator} = {};
const aggregators: { [tokenSymbol: string]: MockAggregator } = {};
for (const tokenContractName of Object.keys(initialPrices)) {
if (tokenContractName !== 'ETH') {
const priceIndex = Object.keys(initialPrices).findIndex(

7
helpers/tenderly-utils.ts Normal file
View File

@ -0,0 +1,7 @@
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { DRE } from './misc-utils';
export const usingTenderly = () =>
DRE &&
((DRE as HardhatRuntimeEnvironment).network.name.includes('tenderly') ||
process.env.TENDERLY === 'true');

1
helpers/types.ts
View File

@ -70,6 +70,7 @@ export enum eContractid {
MockUniswapV2Router02 = 'MockUniswapV2Router02',
UniswapLiquiditySwapAdapter = 'UniswapLiquiditySwapAdapter',
UniswapRepayAdapter = 'UniswapRepayAdapter',
FlashLiquidationAdapter = 'FlashLiquidationAdapter',
}
/*

4832
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

59
package.json
View File

@ -1,7 +1,11 @@
{
"name": "protocol-v2",
"version": "1.0.0",
"name": "@aave/protocol-v2",
"version": "1.0.1",
"description": "Aave Protocol V2 smart contracts",
"files": [
"contracts",
"artifacts"
],
"scripts": {
"run-env": "npm i && tail -f /dev/null",
"hardhat": "hardhat",
@ -13,7 +17,7 @@
"compile": "SKIP_LOAD=true hardhat compile",
"console:fork": "MAINNET_FORK=true hardhat console",
"test": "TS_NODE_TRANSPILE_ONLY=1 hardhat test ./test/*.spec.ts",
"test-scenarios": "npm run test -- test/__setup.spec.ts test/scenario.spec.ts",
"test-scenarios": "npx hardhat test test/__setup.spec.ts test/scenario.spec.ts",
"test-repay-with-collateral": "hardhat test test/__setup.spec.ts test/repay-with-collateral.spec.ts",
"test-liquidate-with-collateral": "hardhat test test/__setup.spec.ts test/flash-liquidation-with-collateral.spec.ts",
"test-liquidate-underlying": "hardhat test test/__setup.spec.ts test/liquidation-underlying.spec.ts",
@ -39,7 +43,8 @@
"aave:fork:main": "npm run compile && MAINNET_FORK=true hardhat aave:mainnet",
"aave:main:full:migration": "npm run compile && npm run hardhat:main -- aave:mainnet --verify",
"aave:main:full:initialize": "npm run compile && MAINNET_FORK=true full:initialize-tokens --pool Aave",
"dev:prettier": "prettier --write .",
"prettier:check": "npx prettier -c 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test/**/*.ts'",
"prettier:write": "prettier --write 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test/**/*.ts'",
"ci:test": "npm run compile && npm run test",
"ci:clean": "rm -rf ./artifacts ./cache ./types",
"print-contracts:kovan": "npm run hardhat:kovan -- print-contracts",
@ -62,7 +67,8 @@
"main:initialize-tokens": "npm run compile && hardhat --network main full:initialize-tokens --pool Aave",
"kovan:initialize-tokens": "npm run compile && hardhat --network kovan full:initialize-tokens --pool Aave",
"external:deploy-assets-kovan": "npm run compile && hardhat --network kovan external:deploy-new-asset --symbol ${SYMBOL} --verify",
"external:deploy-assets-main": "npm run compile && hardhat --network main external:deploy-new-asset --symbol ${SYMBOL} --verify"
"external:deploy-assets-main": "npm run compile && hardhat --network main external:deploy-new-asset --symbol ${SYMBOL} --verify",
"prepublishOnly": "npm run compile"
},
"devDependencies": {
"@nomiclabs/buidler": "^1.4.7",
@ -93,7 +99,7 @@
"ethereumjs-util": "7.0.2",
"ethers": "^5.0.19",
"globby": "^11.0.1",
"hardhat": "^2.0.2",
"hardhat": "^2.0.8",
"hardhat-gas-reporter": "^1.0.0",
"hardhat-typechain": "^0.3.3",
"husky": "^4.2.5",
@ -113,38 +119,27 @@
},
"husky": {
"hooks": {
"pre-commit": "pretty-quick --staged"
"pre-commit": "pretty-quick --staged --pattern 'contracts/**/*.sol' --pattern 'helpers/**/*.ts' --pattern 'test/**/*.ts' --pattern 'tasks/**/*.ts'"
}
},
"author": "Aave",
"contributors": [
{
"name": "Emilio Frangella",
"email": "emilio@aave.com"
},
{
"name": "Ernesto Boado",
"email": "ernesto@aave.com"
},
{
"name": "Andrey Kozlov",
"email": "andrey@aave.com"
},
{
"name": "David Racero",
"email": "david.k@aave.com"
},
{
"name": "Pol Sendra",
"email": "pol@aave.com"
},
{
"name": "David Truong",
"email": "david@aave.com"
}
"Ernesto Boado <ernesto@aave.com>",
"Emilio Frangella <emilio@aave.com>",
"Andrey Kozlov <andrey@aave.com>",
"David Racero <david.k@aave.com>",
"Pol Sendra <pol@aave.com>",
"David Truong <david@aave.com>"
],
"license": "AGPLv3",
"dependencies": {
"tmp-promise": "^3.0.2"
}
},
"keywords": [
"aave",
"protocol",
"protocol-v2",
"ethereum",
"solidity"
]
}

6
tasks/dev/1_mock_tokens.ts
View File

@ -1,9 +1,9 @@
import {task} from 'hardhat/config';
import {deployAllMockTokens} from '../../helpers/contracts-deployments';
import { task } from 'hardhat/config';
import { deployAllMockTokens } from '../../helpers/contracts-deployments';
task('dev:deploy-mock-tokens', 'Deploy mock tokens for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({verify}, localBRE) => {
.setAction(async ({ verify }, localBRE) => {
await localBRE.run('set-DRE');
await deployAllMockTokens(verify);
});

10
tasks/dev/3_lending_pool.ts
View File

@ -1,22 +1,22 @@
import {task} from 'hardhat/config';
import { task } from 'hardhat/config';
import {
deployATokensAndRatesHelper,
deployLendingPool,
deployLendingPoolConfigurator,
deployStableAndVariableTokensHelper,
} from '../../helpers/contracts-deployments';
import {eContractid} from '../../helpers/types';
import {waitForTx} from '../../helpers/misc-utils';
import { eContractid } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import {
getLendingPoolAddressesProvider,
getLendingPool,
getLendingPoolConfiguratorProxy,
} from '../../helpers/contracts-getters';
import {insertContractAddressInDb} from '../../helpers/contracts-helpers';
import { insertContractAddressInDb } from '../../helpers/contracts-helpers';
task('dev:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({verify}, localBRE) => {
.setAction(async ({ verify }, localBRE) => {
await localBRE.run('set-DRE');
const addressesProvider = await getLendingPoolAddressesProvider();

18
tasks/dev/4_oracles.ts
View File

@ -1,4 +1,4 @@
import {task} from 'hardhat/config';
import { task } from 'hardhat/config';
import {
deployPriceOracle,
deployAaveOracle,
@ -10,10 +10,10 @@ import {
deployAllMockAggregators,
setInitialMarketRatesInRatesOracleByHelper,
} from '../../helpers/oracles-helpers';
import {ICommonConfiguration, iAssetBase, TokenContractId} from '../../helpers/types';
import {waitForTx} from '../../helpers/misc-utils';
import {getAllAggregatorsAddresses, getAllTokenAddresses} from '../../helpers/mock-helpers';
import {ConfigNames, loadPoolConfig, getWethAddress} from '../../helpers/configuration';
import { ICommonConfiguration, iAssetBase, TokenContractId } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import { getAllAggregatorsAddresses, getAllTokenAddresses } from '../../helpers/mock-helpers';
import { ConfigNames, loadPoolConfig, getWethAddress } from '../../helpers/configuration';
import {
getAllMockedTokens,
getLendingPoolAddressesProvider,
@ -23,12 +23,12 @@ import {
task('dev:deploy-oracles', 'Deploy oracles for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({verify, pool}, localBRE) => {
.setAction(async ({ verify, pool }, localBRE) => {
await localBRE.run('set-DRE');
const poolConfig = loadPoolConfig(pool);
const {
Mocks: {AllAssetsInitialPrices},
ProtocolGlobalParams: {UsdAddress, MockUsdPriceInWei},
Mocks: { AllAssetsInitialPrices },
ProtocolGlobalParams: { UsdAddress, MockUsdPriceInWei },
LendingRateOracleRatesCommon,
} = poolConfig as ICommonConfiguration;
@ -67,7 +67,7 @@ task('dev:deploy-oracles', 'Deploy oracles for dev enviroment')
const lendingRateOracle = await deployLendingRateOracle(verify);
await waitForTx(await addressesProvider.setLendingRateOracle(lendingRateOracle.address));
const {USD, ...tokensAddressesWithoutUsd} = allTokenAddresses;
const { USD, ...tokensAddressesWithoutUsd } = allTokenAddresses;
const allReservesAddresses = {
...tokensAddressesWithoutUsd,
};

12
tasks/dev/5_initialize.ts
View File

@ -16,10 +16,7 @@ import {
import { tEthereumAddress, AavePools, eContractid } from '../../helpers/types';
import { waitForTx, filterMapBy } from '../../helpers/misc-utils';
import {
configureReservesByHelper,
initReservesByHelper,
} from '../../helpers/init-helpers';
import { configureReservesByHelper, initReservesByHelper } from '../../helpers/init-helpers';
import { getAllTokenAddresses } from '../../helpers/mock-helpers';
import { ZERO_ADDRESS } from '../../helpers/constants';
import {
@ -60,12 +57,7 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
ZERO_ADDRESS,
verify
);
await configureReservesByHelper(
reservesParams,
protoPoolReservesAddresses,
testHelpers,
admin
);
await configureReservesByHelper(reservesParams, protoPoolReservesAddresses, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager(verify);
await waitForTx(

14
tasks/full/2_lending_pool.ts
View File

@ -1,25 +1,23 @@
import {task} from 'hardhat/config';
import {
getEthersSignersAddresses,
insertContractAddressInDb,
} from '../../helpers/contracts-helpers';
import { task } from 'hardhat/config';
import { insertContractAddressInDb } from '../../helpers/contracts-helpers';
import {
deployATokensAndRatesHelper,
deployLendingPool,
deployLendingPoolConfigurator,
deployStableAndVariableTokensHelper,
} from '../../helpers/contracts-deployments';
import {eContractid} from '../../helpers/types';
import {waitForTx} from '../../helpers/misc-utils';
import { eContractid } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import {
getLendingPoolAddressesProvider,
getLendingPool,
getLendingPoolConfiguratorProxy,
} from '../../helpers/contracts-getters';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
task('full:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({verify}, DRE) => {
.setAction(async ({ verify }, DRE: HardhatRuntimeEnvironment) => {
try {
await DRE.run('set-DRE');

21
tasks/full/5_initialize.ts
View File

@ -6,13 +6,15 @@ import {
deployAaveProtocolDataProvider,
deployWETHGateway,
} from '../../helpers/contracts-deployments';
import { loadPoolConfig, ConfigNames, getWethAddress, getTreasuryAddress } from '../../helpers/configuration';
import {
loadPoolConfig,
ConfigNames,
getWethAddress,
getTreasuryAddress,
} from '../../helpers/configuration';
import { eEthereumNetwork, ICommonConfiguration } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import {
initReservesByHelper,
configureReservesByHelper,
} from '../../helpers/init-helpers';
import { initReservesByHelper, configureReservesByHelper } from '../../helpers/init-helpers';
import { exit } from 'process';
import {
getAaveProtocolDataProvider,
@ -43,7 +45,14 @@ task('full:initialize-lending-pool', 'Initialize lending pool configuration.')
const treasuryAddress = await getTreasuryAddress(poolConfig);
await initReservesByHelper(ReservesConfig, reserveAssets, admin, treasuryAddress, ZERO_ADDRESS, verify);
await initReservesByHelper(
ReservesConfig,
reserveAssets,
admin,
treasuryAddress,
ZERO_ADDRESS,
verify
);
await configureReservesByHelper(ReservesConfig, reserveAssets, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager(verify);

2
tasks/helpers/deploy-new-asset.ts
View File

@ -53,9 +53,9 @@ WRONG RESERVE ASSET SETUP:
poolAddress,
reserveAssetAddress,
treasuryAddress,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
],
verify
);

20
tasks/migrations/aave.dev.ts
View File

@ -1,11 +1,11 @@
import {task} from 'hardhat/config';
import {checkVerification} from '../../helpers/etherscan-verification';
import {ConfigNames} from '../../helpers/configuration';
import {printContracts} from '../../helpers/misc-utils';
import { task } from 'hardhat/config';
import { checkVerification } from '../../helpers/etherscan-verification';
import { ConfigNames } from '../../helpers/configuration';
import { printContracts } from '../../helpers/misc-utils';
task('aave:dev', 'Deploy development enviroment')
.addOptionalParam('verify', 'Verify contracts at Etherscan')
.setAction(async ({verify}, localBRE) => {
.setAction(async ({ verify }, localBRE) => {
const POOL_NAME = ConfigNames.Aave;
await localBRE.run('set-DRE');
@ -18,19 +18,19 @@ task('aave:dev', 'Deploy development enviroment')
console.log('Migration started\n');
console.log('1. Deploy mock tokens');
await localBRE.run('dev:deploy-mock-tokens', {verify});
await localBRE.run('dev:deploy-mock-tokens', { verify });
console.log('2. Deploy address provider');
await localBRE.run('dev:deploy-address-provider', {verify});
await localBRE.run('dev:deploy-address-provider', { verify });
console.log('3. Deploy lending pool');
await localBRE.run('dev:deploy-lending-pool', {verify});
await localBRE.run('dev:deploy-lending-pool', { verify });
console.log('4. Deploy oracles');
await localBRE.run('dev:deploy-oracles', {verify, pool: POOL_NAME});
await localBRE.run('dev:deploy-oracles', { verify, pool: POOL_NAME });
console.log('5. Initialize lending pool');
await localBRE.run('dev:initialize-lending-pool', {verify, pool: POOL_NAME});
await localBRE.run('dev:initialize-lending-pool', { verify, pool: POOL_NAME });
console.log('\nFinished migration');
printContracts();

35
tasks/migrations/aave.mainnet.ts
View File

@ -1,15 +1,13 @@
import {task} from 'hardhat/config';
import {ExternalProvider} from '@ethersproject/providers';
import {checkVerification} from '../../helpers/etherscan-verification';
import {ConfigNames} from '../../helpers/configuration';
import {EthereumNetworkNames} from '../../helpers/types';
import {printContracts} from '../../helpers/misc-utils';
import { task } from 'hardhat/config';
import { checkVerification } from '../../helpers/etherscan-verification';
import { ConfigNames } from '../../helpers/configuration';
import { printContracts } from '../../helpers/misc-utils';
import { usingTenderly } from '../../helpers/tenderly-utils';
task('aave:mainnet', 'Deploy development enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({verify}, DRE) => {
.setAction(async ({ verify }, DRE) => {
const POOL_NAME = ConfigNames.Aave;
const network = <EthereumNetworkNames>DRE.network.name;
await DRE.run('set-DRE');
// Prevent loss of gas verifying all the needed ENVs for Etherscan verification
@ -17,40 +15,33 @@ task('aave:mainnet', 'Deploy development enviroment')
checkVerification();
}
if (network.includes('tenderly')) {
console.log('- Setting up Tenderly provider');
await DRE.tenderlyRPC.initializeFork();
const provider = new DRE.ethers.providers.Web3Provider(DRE.tenderlyRPC as any);
DRE.ethers.provider = provider;
}
console.log('Migration started\n');
console.log('1. Deploy address provider');
await DRE.run('full:deploy-address-provider', {pool: POOL_NAME});
await DRE.run('full:deploy-address-provider', { pool: POOL_NAME });
console.log('2. Deploy lending pool');
await DRE.run('full:deploy-lending-pool');
console.log('3. Deploy oracles');
await DRE.run('full:deploy-oracles', {pool: POOL_NAME});
await DRE.run('full:deploy-oracles', { pool: POOL_NAME });
console.log('4. Deploy Data Provider');
await DRE.run('full:data-provider', {pool: POOL_NAME});
await DRE.run('full:data-provider', { pool: POOL_NAME });
console.log('5. Initialize lending pool');
await DRE.run('full:initialize-lending-pool', {pool: POOL_NAME});
await DRE.run('full:initialize-lending-pool', { pool: POOL_NAME });
if (verify) {
printContracts();
console.log('4. Veryfing contracts');
await DRE.run('verify:general', {all: true, pool: POOL_NAME});
await DRE.run('verify:general', { all: true, pool: POOL_NAME });
console.log('5. Veryfing aTokens and debtTokens');
await DRE.run('verify:tokens', {pool: POOL_NAME});
await DRE.run('verify:tokens', { pool: POOL_NAME });
}
if (network.includes('tenderly')) {
if (usingTenderly()) {
const postDeployHead = DRE.tenderlyRPC.getHead();
console.log('Tenderly UUID', postDeployHead);
}

4
tasks/misc/print-contracts.ts
View File

@ -1,5 +1,5 @@
import {task} from 'hardhat/config';
import {printContracts} from '../../helpers/misc-utils';
import { task } from 'hardhat/config';
import { printContracts } from '../../helpers/misc-utils';
task('print-contracts', 'Inits the DRE, to have access to all the plugins').setAction(
async ({}, localBRE) => {

19
tasks/misc/set-bre.ts
View File

@ -1,8 +1,25 @@
import { task } from 'hardhat/config';
import { setDRE } from '../../helpers/misc-utils';
import { DRE, setDRE } from '../../helpers/misc-utils';
import { EthereumNetworkNames } from '../../helpers/types';
import { usingTenderly } from '../../helpers/tenderly-utils';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
task(`set-DRE`, `Inits the DRE, to have access to all the plugins' objects`).setAction(
async (_, _DRE) => {
if (DRE) {
return;
}
if (
(_DRE as HardhatRuntimeEnvironment).network.name.includes('tenderly') ||
process.env.TENDERLY === 'true'
) {
console.log('- Setting up Tenderly provider');
await _DRE.tenderlyRPC.initializeFork();
console.log('- Initialized Tenderly fork');
const provider = new _DRE.ethers.providers.Web3Provider(_DRE.tenderlyRPC as any);
_DRE.ethers.provider = provider;
}
setDRE(_DRE);
return _DRE;
}

6
tasks/misc/verify-sc.ts
View File

@ -1,5 +1,5 @@
import {task} from 'hardhat/config';
import {verifyContract, checkVerification} from '../../helpers/etherscan-verification';
import { task } from 'hardhat/config';
import { verifyContract, checkVerification } from '../../helpers/etherscan-verification';
interface VerifyParams {
contractName: string;
@ -19,7 +19,7 @@ task('verify-sc', 'Inits the DRE, to have access to all the plugins')
'arguments for contract constructor',
[]
)
.setAction(async ({address, constructorArguments = [], libraries}: VerifyParams, localBRE) => {
.setAction(async ({ address, constructorArguments = [], libraries }: VerifyParams, localBRE) => {
await localBRE.run('set-DRE');
checkVerification();

23
test/__setup.spec.ts
View File

@ -25,6 +25,7 @@ import {
deployMockUniswapRouter,
deployUniswapLiquiditySwapAdapter,
deployUniswapRepayAdapter,
deployFlashLiquidationAdapter,
} from '../helpers/contracts-deployments';
import { Signer } from 'ethers';
import { TokenContractId, eContractid, tEthereumAddress, AavePools } from '../helpers/types';
@ -232,29 +233,19 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
await waitForTx(
await addressesProvider.setLendingPoolCollateralManager(collateralManager.address)
);
const mockFlashLoanReceiver = await deployMockFlashLoanReceiver(addressesProvider.address);
await insertContractAddressInDb(eContractid.MockFlashLoanReceiver, mockFlashLoanReceiver.address);
await deployMockFlashLoanReceiver(addressesProvider.address);
const mockUniswapRouter = await deployMockUniswapRouter();
await insertContractAddressInDb(eContractid.MockUniswapV2Router02, mockUniswapRouter.address);
const UniswapLiquiditySwapAdapter = await deployUniswapLiquiditySwapAdapter([
const adapterParams: [string, string, string] = [
addressesProvider.address,
mockUniswapRouter.address,
mockTokens.WETH.address,
]);
await insertContractAddressInDb(
eContractid.UniswapLiquiditySwapAdapter,
UniswapLiquiditySwapAdapter.address
);
];
const UniswapRepayAdapter = await deployUniswapRepayAdapter([
addressesProvider.address,
mockUniswapRouter.address,
mockTokens.WETH.address,
]);
await insertContractAddressInDb(eContractid.UniswapRepayAdapter, UniswapRepayAdapter.address);
await deployUniswapLiquiditySwapAdapter(adapterParams);
await deployUniswapRepayAdapter(adapterParams);
await deployFlashLiquidationAdapter(adapterParams);
await deployWalletBalancerProvider();

28
test/addresses-provider-registry.spec.ts
View File

@ -1,12 +1,12 @@
import {TestEnv, makeSuite} from './helpers/make-suite';
import {ZERO_ADDRESS} from '../helpers/constants';
import {ProtocolErrors} from '../helpers/types';
import { TestEnv, makeSuite } from './helpers/make-suite';
import { ZERO_ADDRESS } from '../helpers/constants';
import { ProtocolErrors } from '../helpers/types';
const {expect} = require('chai');
const { expect } = require('chai');
makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
it('Checks the addresses provider is added to the registry', async () => {
const {addressesProvider, registry} = testEnv;
const { addressesProvider, registry } = testEnv;
const providers = await registry.getAddressesProvidersList();
@ -18,8 +18,8 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('tries to register an addresses provider with id 0', async () => {
const {users, registry} = testEnv;
const {LPAPR_INVALID_ADDRESSES_PROVIDER_ID} = ProtocolErrors;
const { users, registry } = testEnv;
const { LPAPR_INVALID_ADDRESSES_PROVIDER_ID } = ProtocolErrors;
await expect(registry.registerAddressesProvider(users[2].address, '0')).to.be.revertedWith(
LPAPR_INVALID_ADDRESSES_PROVIDER_ID
@ -27,7 +27,7 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('Registers a new mock addresses provider', async () => {
const {users, registry} = testEnv;
const { users, registry } = testEnv;
//simulating an addresses provider using the users[1] wallet address
await registry.registerAddressesProvider(users[1].address, '2');
@ -42,7 +42,7 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('Removes the mock addresses provider', async () => {
const {users, registry, addressesProvider} = testEnv;
const { users, registry, addressesProvider } = testEnv;
const id = await registry.getAddressesProviderIdByAddress(users[1].address);
@ -61,9 +61,9 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('Tries to remove a unregistered addressesProvider', async () => {
const {LPAPR_PROVIDER_NOT_REGISTERED} = ProtocolErrors;
const { LPAPR_PROVIDER_NOT_REGISTERED } = ProtocolErrors;
const {users, registry} = testEnv;
const { users, registry } = testEnv;
await expect(registry.unregisterAddressesProvider(users[2].address)).to.be.revertedWith(
LPAPR_PROVIDER_NOT_REGISTERED
@ -71,9 +71,9 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('Tries to remove a unregistered addressesProvider', async () => {
const {LPAPR_PROVIDER_NOT_REGISTERED} = ProtocolErrors;
const { LPAPR_PROVIDER_NOT_REGISTERED } = ProtocolErrors;
const {users, registry} = testEnv;
const { users, registry } = testEnv;
await expect(registry.unregisterAddressesProvider(users[2].address)).to.be.revertedWith(
LPAPR_PROVIDER_NOT_REGISTERED
@ -81,7 +81,7 @@ makeSuite('AddressesProviderRegistry', (testEnv: TestEnv) => {
});
it('Tries to add an already added addressesProvider with a different id. Should overwrite the previous id', async () => {
const {users, registry, addressesProvider} = testEnv;
const { users, registry, addressesProvider } = testEnv;
await registry.registerAddressesProvider(addressesProvider.address, '2');

16
test/atoken-modifiers.spec.ts
View File

@ -1,33 +1,33 @@
import {expect} from 'chai';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors} from '../helpers/types';
import { expect } from 'chai';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors } from '../helpers/types';
makeSuite('AToken: Modifiers', (testEnv: TestEnv) => {
const {CT_CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
const { CT_CALLER_MUST_BE_LENDING_POOL } = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, aDai} = testEnv;
const { deployer, aDai } = testEnv;
await expect(aDai.mint(deployer.address, '1', '1')).to.be.revertedWith(
CT_CALLER_MUST_BE_LENDING_POOL
);
});
it('Tries to invoke burn not being the LendingPool', async () => {
const {deployer, aDai} = testEnv;
const { deployer, aDai } = testEnv;
await expect(aDai.burn(deployer.address, deployer.address, '1', '1')).to.be.revertedWith(
CT_CALLER_MUST_BE_LENDING_POOL
);
});
it('Tries to invoke transferOnLiquidation not being the LendingPool', async () => {
const {deployer, users, aDai} = testEnv;
const { deployer, users, aDai } = testEnv;
await expect(
aDai.transferOnLiquidation(deployer.address, users[0].address, '1')
).to.be.revertedWith(CT_CALLER_MUST_BE_LENDING_POOL);
});
it('Tries to invoke transferUnderlyingTo not being the LendingPool', async () => {
const {deployer, aDai} = testEnv;
const { deployer, aDai } = testEnv;
await expect(aDai.transferUnderlyingTo(deployer.address, '1')).to.be.revertedWith(
CT_CALLER_MUST_BE_LENDING_POOL
);

22
test/atoken-transfer.spec.ts
View File

@ -1,10 +1,10 @@
import {APPROVAL_AMOUNT_LENDING_POOL, MAX_UINT_AMOUNT, ZERO_ADDRESS} from '../helpers/constants';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {expect} from 'chai';
import {ethers} from 'ethers';
import {RateMode, ProtocolErrors} from '../helpers/types';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {CommonsConfig} from '../markets/aave/commons';
import { APPROVAL_AMOUNT_LENDING_POOL, MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { expect } from 'chai';
import { ethers } from 'ethers';
import { RateMode, ProtocolErrors } from '../helpers/types';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { CommonsConfig } from '../markets/aave/commons';
const AAVE_REFERRAL = CommonsConfig.ProtocolGlobalParams.AaveReferral;
@ -16,7 +16,7 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
} = ProtocolErrors;
it('User 0 deposits 1000 DAI, transfers to user 1', async () => {
const {users, pool, dai, aDai} = testEnv;
const { users, pool, dai, aDai } = testEnv;
await dai.connect(users[0].signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
@ -46,7 +46,7 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
});
it('User 0 deposits 1 WETH and user 1 tries to borrow the WETH with the received DAI as collateral', async () => {
const {users, pool, weth, helpersContract} = testEnv;
const { users, pool, weth, helpersContract } = testEnv;
const userAddress = await pool.signer.getAddress();
await weth.connect(users[0].signer).mint(await convertToCurrencyDecimals(weth.address, '1'));
@ -75,7 +75,7 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
});
it('User 1 tries to transfer all the DAI used as collateral back to user 0 (revert expected)', async () => {
const {users, pool, aDai, dai, weth} = testEnv;
const { users, pool, aDai, dai, weth } = testEnv;
const aDAItoTransfer = await convertToCurrencyDecimals(dai.address, '1000');
@ -86,7 +86,7 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
});
it('User 1 tries to transfer a small amount of DAI used as collateral back to user 0', async () => {
const {users, pool, aDai, dai, weth} = testEnv;
const { users, pool, aDai, dai, weth } = testEnv;
const aDAItoTransfer = await convertToCurrencyDecimals(dai.address, '100');

64
test/configurator.spec.ts
View File

@ -1,10 +1,10 @@
import {TestEnv, makeSuite} from './helpers/make-suite';
import {APPROVAL_AMOUNT_LENDING_POOL, RAY} from '../helpers/constants';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {ProtocolErrors} from '../helpers/types';
import { TestEnv, makeSuite } from './helpers/make-suite';
import { APPROVAL_AMOUNT_LENDING_POOL, RAY } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { ProtocolErrors } from '../helpers/types';
import { strategyWETH } from '../markets/aave/reservesConfigs';
const {expect} = require('chai');
const { expect } = require('chai');
makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {
@ -18,7 +18,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
} = ProtocolErrors;
it('Reverts trying to set an invalid reserve factor', async () => {
const {configurator, weth} = testEnv;
const { configurator, weth } = testEnv;
const invalidReserveFactor = 65536;
@ -28,22 +28,22 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Deactivates the ETH reserve', async () => {
const {configurator, weth, helpersContract} = testEnv;
const { configurator, weth, helpersContract } = testEnv;
await configurator.deactivateReserve(weth.address);
const {isActive} = await helpersContract.getReserveConfigurationData(weth.address);
const { isActive } = await helpersContract.getReserveConfigurationData(weth.address);
expect(isActive).to.be.equal(false);
});
it('Rectivates the ETH reserve', async () => {
const {configurator, weth, helpersContract} = testEnv;
const { configurator, weth, helpersContract } = testEnv;
await configurator.activateReserve(weth.address);
const {isActive} = await helpersContract.getReserveConfigurationData(weth.address);
const { isActive } = await helpersContract.getReserveConfigurationData(weth.address);
expect(isActive).to.be.equal(true);
});
it('Check the onlyAaveAdmin on deactivateReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).deactivateReserve(weth.address),
CALLER_NOT_POOL_ADMIN
@ -51,7 +51,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on activateReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).activateReserve(weth.address),
CALLER_NOT_POOL_ADMIN
@ -59,9 +59,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Freezes the ETH reserve', async () => {
const {configurator, weth, helpersContract} = testEnv;
const { configurator, weth, helpersContract } = testEnv;
await configurator.freezeReserve(weth.address);
const {
@ -88,7 +86,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Unfreezes the ETH reserve', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.unfreezeReserve(weth.address);
const {
@ -115,7 +113,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on freezeReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).freezeReserve(weth.address),
CALLER_NOT_POOL_ADMIN
@ -123,7 +121,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on unfreezeReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).unfreezeReserve(weth.address),
CALLER_NOT_POOL_ADMIN
@ -131,7 +129,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Deactivates the ETH reserve for borrowing', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.disableBorrowingOnReserve(weth.address);
const {
decimals,
@ -157,9 +155,9 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Activates the ETH reserve for borrowing', async () => {
const {configurator, weth, helpersContract} = testEnv;
const { configurator, weth, helpersContract } = testEnv;
await configurator.enableBorrowingOnReserve(weth.address, true);
const {variableBorrowIndex} = await helpersContract.getReserveData(weth.address);
const { variableBorrowIndex } = await helpersContract.getReserveData(weth.address);
const {
decimals,
@ -187,7 +185,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on disableBorrowingOnReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).disableBorrowingOnReserve(weth.address),
CALLER_NOT_POOL_ADMIN
@ -195,7 +193,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on enableBorrowingOnReserve ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).enableBorrowingOnReserve(weth.address, true),
CALLER_NOT_POOL_ADMIN
@ -203,7 +201,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Deactivates the ETH reserve as collateral', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.configureReserveAsCollateral(weth.address, 0, 0, 0);
const {
@ -230,7 +228,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Activates the ETH reserve as collateral', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.configureReserveAsCollateral(weth.address, '8000', '8250', '10500');
const {
@ -257,7 +255,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on configureReserveAsCollateral ', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator
.connect(users[2].signer)
@ -267,7 +265,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Disable stable borrow rate on the ETH reserve', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.disableReserveStableRate(weth.address);
const {
decimals,
@ -293,7 +291,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Enables stable borrow rate on the ETH reserve', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.enableReserveStableRate(weth.address);
const {
decimals,
@ -319,7 +317,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on disableReserveStableRate', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).disableReserveStableRate(weth.address),
CALLER_NOT_POOL_ADMIN
@ -327,7 +325,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyAaveAdmin on enableReserveStableRate', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).enableReserveStableRate(weth.address),
CALLER_NOT_POOL_ADMIN
@ -335,7 +333,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Changes the reserve factor of WETH', async () => {
const {configurator, helpersContract, weth} = testEnv;
const { configurator, helpersContract, weth } = testEnv;
await configurator.setReserveFactor(weth.address, '1000');
const {
decimals,
@ -361,7 +359,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Check the onlyLendingPoolManager on setReserveFactor', async () => {
const {configurator, users, weth} = testEnv;
const { configurator, users, weth } = testEnv;
await expect(
configurator.connect(users[2].signer).setReserveFactor(weth.address, '2000'),
CALLER_NOT_POOL_ADMIN
@ -369,7 +367,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
});
it('Reverts when trying to disable the DAI reserve with liquidity on it', async () => {
const {dai, pool, configurator} = testEnv;
const { dai, pool, configurator } = testEnv;
const userAddress = await pool.signer.getAddress();
await dai.mint(await convertToCurrencyDecimals(dai.address, '1000'));

2
test/delegation-aware-atoken.spec.ts
View File

@ -33,7 +33,7 @@ makeSuite('AToken: underlying delegation', (testEnv: TestEnv) => {
delegationERC20 = await deployMintableDelegationERC20(['DEL', 'DEL', '18']);
delegationAToken = await deployDelegationAwareAToken(
[pool.address, delegationERC20.address, ZERO_ADDRESS, 'aDEL', 'aDEL', ZERO_ADDRESS],
[pool.address, delegationERC20.address, ZERO_ADDRESS, ZERO_ADDRESS, 'aDEL', 'aDEL'],
false
);
});

65
test/flashloan.spec.ts
View File

@ -1,20 +1,20 @@
import BigNumber from 'bignumber.js';
import {TestEnv, makeSuite} from './helpers/make-suite';
import {APPROVAL_AMOUNT_LENDING_POOL, oneRay} from '../helpers/constants';
import {convertToCurrencyDecimals, getContract} from '../helpers/contracts-helpers';
import {ethers} from 'ethers';
import {MockFlashLoanReceiver} from '../types/MockFlashLoanReceiver';
import {ProtocolErrors, eContractid} from '../helpers/types';
import {VariableDebtToken} from '../types/VariableDebtToken';
import {StableDebtToken} from '../types/StableDebtToken';
import { TestEnv, makeSuite } from './helpers/make-suite';
import { APPROVAL_AMOUNT_LENDING_POOL, oneRay } from '../helpers/constants';
import { convertToCurrencyDecimals, getContract } from '../helpers/contracts-helpers';
import { ethers } from 'ethers';
import { MockFlashLoanReceiver } from '../types/MockFlashLoanReceiver';
import { ProtocolErrors, eContractid } from '../helpers/types';
import { VariableDebtToken } from '../types/VariableDebtToken';
import { StableDebtToken } from '../types/StableDebtToken';
import {
getMockFlashLoanReceiver,
getStableDebtToken,
getVariableDebtToken,
} from '../helpers/contracts-getters';
const {expect} = require('chai');
const { expect } = require('chai');
makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
let _mockFlashLoanReceiver = {} as MockFlashLoanReceiver;
@ -32,7 +32,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Deposits WETH into the reserve', async () => {
const {pool, weth} = testEnv;
const { pool, weth } = testEnv;
const userAddress = await pool.signer.getAddress();
const amountToDeposit = ethers.utils.parseEther('1');
@ -44,7 +44,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes WETH flashloan with mode = 0, returns the funds correctly', async () => {
const {pool, helpersContract, weth} = testEnv;
const { pool, helpersContract, weth } = testEnv;
await pool.flashLoan(
_mockFlashLoanReceiver.address,
@ -73,7 +73,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes an ETH flashloan with mode = 0 as big as the available liquidity', async () => {
const {pool, helpersContract, weth} = testEnv;
const { pool, helpersContract, weth } = testEnv;
const reserveDataBefore = await helpersContract.getReserveData(weth.address);
const txResult = await pool.flashLoan(
@ -101,7 +101,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes WETH flashloan, does not return the funds with mode = 0. (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const { pool, weth, users } = testEnv;
const caller = users[1];
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
@ -121,7 +121,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes WETH flashloan, simulating a receiver as EOA (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const { pool, weth, users } = testEnv;
const caller = users[1];
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await _mockFlashLoanReceiver.setSimulateEOA(true);
@ -142,7 +142,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes a WETH flashloan with an invalid mode. (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const { pool, weth, users } = testEnv;
const caller = users[1];
await _mockFlashLoanReceiver.setSimulateEOA(false);
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
@ -163,7 +163,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller deposits 1000 DAI as collateral, Takes WETH flashloan with mode = 2, does not return the funds. A variable loan for caller is created', async () => {
const {dai, pool, weth, users, helpersContract} = testEnv;
const { dai, pool, weth, users, helpersContract } = testEnv;
const caller = users[1];
@ -188,7 +188,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
'0x10',
'0'
);
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
@ -200,7 +200,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('tries to take a flashloan that is bigger than the available liquidity (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const { pool, weth, users } = testEnv;
const caller = users[1];
await expect(
@ -218,7 +218,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('tries to take a flashloan using a non contract address as receiver (revert expected)', async () => {
const {pool, deployer, weth, users} = testEnv;
const { pool, deployer, weth, users } = testEnv;
const caller = users[1];
await expect(
@ -235,7 +235,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Deposits USDC into the reserve', async () => {
const {usdc, pool} = testEnv;
const { usdc, pool } = testEnv;
const userAddress = await pool.signer.getAddress();
await usdc.mint(await convertToCurrencyDecimals(usdc.address, '1000'));
@ -248,7 +248,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes out a 500 USDC flashloan, returns the funds correctly', async () => {
const {usdc, pool, helpersContract, deployer: depositor} = testEnv;
const { usdc, pool, helpersContract, deployer: depositor } = testEnv;
await _mockFlashLoanReceiver.setFailExecutionTransfer(false);
@ -268,7 +268,6 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
const reserveDataAfter = helpersContract.getReserveData(usdc.address);
const reserveData = await helpersContract.getReserveData(usdc.address);
const userData = await helpersContract.getUserReserveData(usdc.address, depositor.address);
@ -292,7 +291,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Takes out a 500 USDC flashloan with mode = 0, does not return the funds. (revert expected)', async () => {
const {usdc, pool, users} = testEnv;
const { usdc, pool, users } = testEnv;
const caller = users[2];
const flashloanAmount = await convertToCurrencyDecimals(usdc.address, '500');
@ -315,7 +314,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller deposits 5 WETH as collateral, Takes a USDC flashloan with mode = 2, does not return the funds. A loan for caller is created', async () => {
const {usdc, pool, weth, users, helpersContract} = testEnv;
const { usdc, pool, weth, users, helpersContract } = testEnv;
const caller = users[2];
@ -342,7 +341,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
'0x10',
'0'
);
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
usdc.address
);
@ -354,7 +353,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller deposits 1000 DAI as collateral, Takes a WETH flashloan with mode = 0, does not approve the transfer of the funds', async () => {
const {dai, pool, weth, users} = testEnv;
const { dai, pool, weth, users } = testEnv;
const caller = users[3];
await dai.connect(caller.signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
@ -386,7 +385,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller takes a WETH flashloan with mode = 1', async () => {
const {dai, pool, weth, users, helpersContract} = testEnv;
const { dai, pool, weth, users, helpersContract } = testEnv;
const caller = users[3];
@ -406,7 +405,9 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
'0'
);
const {stableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(weth.address);
const { stableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const wethDebtToken = await getStableDebtToken(stableDebtTokenAddress);
@ -416,7 +417,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller takes a WETH flashloan with mode = 1 onBehalfOf user without allowance', async () => {
const {dai, pool, weth, users, helpersContract} = testEnv;
const { dai, pool, weth, users, helpersContract } = testEnv;
const caller = users[5];
const onBehalfOf = users[4];
@ -452,7 +453,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
});
it('Caller takes a WETH flashloan with mode = 1 onBehalfOf user with allowance. A loan for onBehalfOf is creatd.', async () => {
const {dai, pool, weth, users, helpersContract} = testEnv;
const { dai, pool, weth, users, helpersContract } = testEnv;
const caller = users[5];
const onBehalfOf = users[4];
@ -480,7 +481,9 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
'0'
);
const {stableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(weth.address);
const { stableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const wethDebtToken = await getStableDebtToken(stableDebtTokenAddress);

4
test/helpers/actions.ts
View File

@ -26,7 +26,7 @@ import {
} from '../../helpers/contracts-getters';
import { MAX_UINT_AMOUNT, ONE_YEAR } from '../../helpers/constants';
import { SignerWithAddress, TestEnv } from './make-suite';
import { DRE, increaseTime, timeLatest, waitForTx } from '../../helpers/misc-utils';
import { advanceTimeAndBlock, DRE, timeLatest, waitForTx } from '../../helpers/misc-utils';
import chai from 'chai';
import { ReserveData, UserReserveData } from './utils/interfaces';
@ -361,7 +361,7 @@ export const borrow = async (
if (timeTravel) {
const secondsToTravel = new BigNumber(timeTravel).multipliedBy(ONE_YEAR).div(365).toNumber();
await increaseTime(secondsToTravel);
await advanceTimeAndBlock(secondsToTravel);
}
const {

33
test/helpers/make-suite.ts
View File

@ -13,6 +13,7 @@ import {
getWETHGateway,
getUniswapLiquiditySwapAdapter,
getUniswapRepayAdapter,
getFlashLiquidationAdapter,
} from '../../helpers/contracts-getters';
import { eEthereumNetwork, tEthereumAddress } from '../../helpers/types';
import { LendingPool } from '../../types/LendingPool';
@ -36,6 +37,9 @@ import { WETH9Mocked } from '../../types/WETH9Mocked';
import { WETHGateway } from '../../types/WETHGateway';
import { solidity } from 'ethereum-waffle';
import { AaveConfig } from '../../markets/aave';
import { FlashLiquidationAdapter } from '../../types';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { usingTenderly } from '../../helpers/tenderly-utils';
chai.use(bignumberChai());
chai.use(almostEqual());
@ -63,13 +67,12 @@ export interface TestEnv {
uniswapRepayAdapter: UniswapRepayAdapter;
registry: LendingPoolAddressesProviderRegistry;
wethGateway: WETHGateway;
flashLiquidationAdapter: FlashLiquidationAdapter;
}
let buidlerevmSnapshotId: string = '0x1';
const setBuidlerevmSnapshotId = (id: string) => {
if (DRE.network.name === 'hardhat') {
buidlerevmSnapshotId = id;
}
buidlerevmSnapshotId = id;
};
const testEnv: TestEnv = {
@ -88,6 +91,7 @@ const testEnv: TestEnv = {
addressesProvider: {} as LendingPoolAddressesProvider,
uniswapLiquiditySwapAdapter: {} as UniswapLiquiditySwapAdapter,
uniswapRepayAdapter: {} as UniswapRepayAdapter,
flashLiquidationAdapter: {} as FlashLiquidationAdapter,
registry: {} as LendingPoolAddressesProviderRegistry,
wethGateway: {} as WETHGateway,
} as TestEnv;
@ -153,16 +157,35 @@ export async function initializeMakeSuite() {
testEnv.uniswapLiquiditySwapAdapter = await getUniswapLiquiditySwapAdapter();
testEnv.uniswapRepayAdapter = await getUniswapRepayAdapter();
testEnv.flashLiquidationAdapter = await getFlashLiquidationAdapter();
}
const setSnapshot = async () => {
const hre = DRE as HardhatRuntimeEnvironment;
if (usingTenderly()) {
setBuidlerevmSnapshotId((await hre.tenderlyRPC.getHead()) || '0x1');
return;
}
setBuidlerevmSnapshotId(await evmSnapshot());
};
const revertHead = async () => {
const hre = DRE as HardhatRuntimeEnvironment;
if (usingTenderly()) {
await hre.tenderlyRPC.setHead(buidlerevmSnapshotId);
return;
}
await evmRevert(buidlerevmSnapshotId);
};
export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
describe(name, () => {
before(async () => {
setBuidlerevmSnapshotId(await evmSnapshot());
await setSnapshot();
});
tests(testEnv);
after(async () => {
await evmRevert(buidlerevmSnapshotId);
await revertHead();
});
});
}

28
test/helpers/scenario-engine.ts
View File

@ -1,4 +1,4 @@
import {TestEnv, SignerWithAddress} from './make-suite';
import { TestEnv, SignerWithAddress } from './make-suite';
import {
mint,
approve,
@ -11,7 +11,7 @@ import {
rebalanceStableBorrowRate,
delegateBorrowAllowance,
} from './actions';
import {RateMode} from '../../helpers/types';
import { RateMode } from '../../helpers/types';
export interface Action {
name: string;
@ -33,14 +33,14 @@ export interface Scenario {
export const executeStory = async (story: Story, testEnv: TestEnv) => {
for (const action of story.actions) {
const {users} = testEnv;
const { users } = testEnv;
await executeAction(action, users, testEnv);
}
};
const executeAction = async (action: Action, users: SignerWithAddress[], testEnv: TestEnv) => {
const {reserve, user: userIndex, borrowRateMode} = action.args;
const {name, expected, revertMessage} = action;
const { reserve, user: userIndex, borrowRateMode } = action.args;
const { name, expected, revertMessage } = action;
if (!name || name === '') {
throw 'Action name is missing';
@ -75,7 +75,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
switch (name) {
case 'mint':
const {amount} = action.args;
const { amount } = action.args;
if (!amount || amount === '') {
throw `Invalid amount of ${reserve} to mint`;
@ -90,7 +90,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'deposit':
{
const {amount, sendValue, onBehalfOf: onBehalfOfIndex} = action.args;
const { amount, sendValue, onBehalfOf: onBehalfOfIndex } = action.args;
const onBehalfOf = onBehalfOfIndex
? users[parseInt(onBehalfOfIndex)].address
: user.address;
@ -114,7 +114,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'delegateBorrowAllowance':
{
const {amount, toUser: toUserIndex} = action.args;
const { amount, toUser: toUserIndex } = action.args;
const toUser = users[parseInt(toUserIndex, 10)].address;
if (!amount || amount === '') {
throw `Invalid amount to deposit into the ${reserve} reserve`;
@ -135,7 +135,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'withdraw':
{
const {amount} = action.args;
const { amount } = action.args;
if (!amount || amount === '') {
throw `Invalid amount to withdraw from the ${reserve} reserve`;
@ -146,7 +146,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
break;
case 'borrow':
{
const {amount, timeTravel, onBehalfOf: onBehalfOfIndex} = action.args;
const { amount, timeTravel, onBehalfOf: onBehalfOfIndex } = action.args;
const onBehalfOf = onBehalfOfIndex
? users[parseInt(onBehalfOfIndex)].address
@ -172,8 +172,8 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'repay':
{
const {amount, borrowRateMode, sendValue} = action.args;
let {onBehalfOf: onBehalfOfIndex} = action.args;
const { amount, borrowRateMode, sendValue } = action.args;
let { onBehalfOf: onBehalfOfIndex } = action.args;
if (!amount || amount === '') {
throw `Invalid amount to repay into the ${reserve} reserve`;
@ -205,7 +205,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'setUseAsCollateral':
{
const {useAsCollateral} = action.args;
const { useAsCollateral } = action.args;
if (!useAsCollateral || useAsCollateral === '') {
throw `A valid value for useAsCollateral needs to be set when calling setUseReserveAsCollateral on reserve ${reserve}`;
@ -220,7 +220,7 @@ const executeAction = async (action: Action, users: SignerWithAddress[], testEnv
case 'rebalanceStableBorrowRate':
{
const {target: targetIndex} = action.args;
const { target: targetIndex } = action.args;
if (!targetIndex || targetIndex === '') {
throw `A target must be selected when trying to rebalance a stable rate`;

9
test/helpers/scenarios/borrow-repay-stable.json
View File

@ -208,6 +208,15 @@
},
"expected": "revert",
"revertMessage": "The collateral balance is 0"
},
{
"name": "withdraw",
"args": {
"reserve": "DAI",
"amount": "1000",
"user": "1"
},
"expected": "success"
}
]
},

30
test/helpers/scenarios/credit-delegation.json
View File

@ -10,7 +10,7 @@
"args": {
"reserve": "WETH",
"amount": "1000",
"user": "0"
"user": "3"
},
"expected": "success"
},
@ -18,7 +18,7 @@
"name": "approve",
"args": {
"reserve": "WETH",
"user": "0"
"user": "3"
},
"expected": "success"
},
@ -27,6 +27,32 @@
"args": {
"reserve": "WETH",
"amount": "1000",
"user": "3"
},
"expected": "success"
},
{
"name": "mint",
"args": {
"reserve": "DAI",
"amount": "1000",
"user": "0"
},
"expected": "success"
},
{
"name": "approve",
"args": {
"reserve": "DAI",
"user": "0"
},
"expected": "success"
},
{
"name": "deposit",
"args": {
"reserve": "DAI",
"amount": "1000",
"user": "0"
},
"expected": "success"

111
test/helpers/scenarios/rebalance-stable-rate.json
View File

@ -8,7 +8,7 @@
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1",
"borrowRateMode": "variable"
@ -19,12 +19,12 @@
]
},
{
"description": "User 0 deposits 1000 DAI, user 1 deposits 5 ETH, borrows 600 DAI at a variable rate, user 0 rebalances user 1 (revert expected)",
"description": "User 0 deposits 1000 USDC, user 1 deposits 5 ETH, borrows 250 USDC at a stable rate, user 0 rebalances user 1 (revert expected)",
"actions": [
{
"name": "mint",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"amount": "1000",
"user": "0"
},
@ -33,7 +33,7 @@
{
"name": "approve",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0"
},
"expected": "success"
@ -41,7 +41,7 @@
{
"name": "deposit",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"amount": "1000",
"user": "0"
},
@ -51,7 +51,7 @@
"name": "mint",
"args": {
"reserve": "WETH",
"amount": "5",
"amount": "7",
"user": "1"
},
"expected": "success"
@ -69,7 +69,7 @@
"args": {
"reserve": "WETH",
"amount": "5",
"amount": "7",
"user": "1"
},
"expected": "success"
@ -77,18 +77,17 @@
{
"name": "borrow",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"amount": "250",
"borrowRateMode": "stable",
"user": "1",
"timeTravel": "365"
"user": "1"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1"
},
@ -103,18 +102,17 @@
{
"name": "borrow",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"amount": "200",
"borrowRateMode": "stable",
"user": "1",
"timeTravel": "365"
"borrowRateMode": "variable",
"user": "1"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1"
},
@ -129,18 +127,17 @@
{
"name": "borrow",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"amount": "200",
"borrowRateMode": "stable",
"user": "1",
"timeTravel": "365"
"borrowRateMode": "variable",
"user": "1"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1"
},
@ -155,18 +152,17 @@
{
"name": "borrow",
"args": {
"reserve": "DAI",
"amount": "100",
"borrowRateMode": "stable",
"user": "1",
"timeTravel": "365"
"reserve": "USDC",
"amount": "280",
"borrowRateMode": "variable",
"user": "1"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1"
},
@ -175,75 +171,24 @@
}
]
},
{
"description": "User 2 deposits ETH and borrows the remaining DAI, causing the stable rates to rise (usage ratio = 94%). User 0 tries to rebalance user 1 (revert expected)",
"actions": [
{
"name": "mint",
"args": {
"reserve": "WETH",
"amount": "5",
"user": "2"
},
"expected": "success"
},
{
"name": "approve",
"args": {
"reserve": "WETH",
"user": "2"
},
"expected": "success"
},
{
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "5",
"user": "2"
},
"expected": "success"
},
{
"name": "borrow",
"args": {
"reserve": "DAI",
"amount": "190",
"borrowRateMode": "variable",
"user": "2"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"user": "0",
"target": "1"
},
"expected": "revert",
"revertMessage": "Interest rate rebalance conditions were not met"
}
]
},
{
"description": "User 2 borrows the remaining DAI (usage ratio = 100%). User 0 rebalances user 1",
"description": "User 0 borrows the remaining USDC (usage ratio = 100%). User 0 rebalances user 1",
"actions": [
{
"name": "borrow",
"args": {
"reserve": "DAI",
"amount": "60",
"reserve": "USDC",
"amount": "20",
"borrowRateMode": "variable",
"user": "2"
"user": "1"
},
"expected": "success"
},
{
"name": "rebalanceStableBorrowRate",
"args": {
"reserve": "DAI",
"reserve": "USDC",
"user": "0",
"target": "1"
},

37
test/helpers/utils/calculations.ts
View File

@ -996,7 +996,7 @@ export const calcExpectedReserveDataAfterStableRateRebalance = (
//removing the stable liquidity at the old rate
const avgRateBefore = calcExpectedAverageStableBorrowRate(
const avgRateBefore = calcExpectedAverageStableBorrowRateRebalance(
reserveDataBeforeAction.averageStableBorrowRate,
expectedReserveData.totalStableDebt,
userStableDebt.negated(),
@ -1004,7 +1004,7 @@ export const calcExpectedReserveDataAfterStableRateRebalance = (
);
// adding it again at the new rate
expectedReserveData.averageStableBorrowRate = calcExpectedAverageStableBorrowRate(
expectedReserveData.averageStableBorrowRate = calcExpectedAverageStableBorrowRateRebalance(
avgRateBefore,
expectedReserveData.totalStableDebt.minus(userStableDebt),
userStableDebt,
@ -1044,6 +1044,8 @@ export const calcExpectedUserDataAfterStableRateRebalance = (
): UserReserveData => {
const expectedUserData = { ...userDataBeforeAction };
expectedUserData.principalStableDebt = userDataBeforeAction.principalStableDebt;
expectedUserData.principalVariableDebt = calcExpectedVariableDebtTokenBalance(
reserveDataBeforeAction,
userDataBeforeAction,
@ -1056,12 +1058,18 @@ export const calcExpectedUserDataAfterStableRateRebalance = (
txTimestamp
);
expectedUserData.currentVariableDebt = calcExpectedVariableDebtTokenBalance(
reserveDataBeforeAction,
userDataBeforeAction,
txTimestamp
);
expectedUserData.stableRateLastUpdated = txTimestamp;
expectedUserData.principalVariableDebt = userDataBeforeAction.principalVariableDebt;
expectedUserData.stableBorrowRate = reserveDataBeforeAction.stableBorrowRate;
// Stable rate after burn
expectedUserData.stableBorrowRate = expectedDataAfterAction.averageStableBorrowRate;
expectedUserData.liquidityRate = expectedDataAfterAction.liquidityRate;
expectedUserData.currentATokenBalance = calcExpectedATokenBalance(
@ -1104,7 +1112,7 @@ const calcExpectedAverageStableBorrowRate = (
) => {
const weightedTotalBorrows = avgStableRateBefore.multipliedBy(totalStableDebtBefore);
const weightedAmountBorrowed = rate.multipliedBy(amountChanged);
const totalBorrowedStable = totalStableDebtBefore.plus(new BigNumber(amountChanged));
const totalBorrowedStable = totalStableDebtBefore.plus(amountChanged);
if (totalBorrowedStable.eq(0)) return new BigNumber('0');
@ -1114,6 +1122,24 @@ const calcExpectedAverageStableBorrowRate = (
.decimalPlaces(0, BigNumber.ROUND_DOWN);
};
const calcExpectedAverageStableBorrowRateRebalance = (
avgStableRateBefore: BigNumber,
totalStableDebtBefore: BigNumber,
amountChanged: BigNumber,
rate: BigNumber
) => {
const weightedTotalBorrows = avgStableRateBefore.rayMul(totalStableDebtBefore);
const weightedAmountBorrowed = rate.rayMul(amountChanged.wadToRay());
const totalBorrowedStable = totalStableDebtBefore.plus(amountChanged.wadToRay());
if (totalBorrowedStable.eq(0)) return new BigNumber('0');
return weightedTotalBorrows
.plus(weightedAmountBorrowed)
.rayDiv(totalBorrowedStable)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
};
export const calcExpectedVariableDebtTokenBalance = (
reserveData: ReserveData,
userData: UserReserveData,
@ -1211,7 +1237,6 @@ export const calcExpectedInterestRates = (
): BigNumber[] => {
const { reservesParams } = configuration;
const reserveIndex = Object.keys(reservesParams).findIndex((value) => value === reserveSymbol);
const [, reserveConfiguration] = (Object.entries(reservesParams) as [string, IReserveParams][])[
reserveIndex

25
test/helpers/utils/math.ts
View File

@ -1,5 +1,13 @@
import BigNumber from 'bignumber.js';
import {RAY, WAD, HALF_RAY, HALF_WAD, WAD_RAY_RATIO, HALF_PERCENTAGE, PERCENTAGE_FACTOR} from '../../../helpers/constants';
import {
RAY,
WAD,
HALF_RAY,
HALF_WAD,
WAD_RAY_RATIO,
HALF_PERCENTAGE,
PERCENTAGE_FACTOR,
} from '../../../helpers/constants';
declare module 'bignumber.js' {
interface BigNumber {
@ -68,19 +76,22 @@ BigNumber.prototype.wadToRay = function (): BigNumber {
return this.multipliedBy(WAD_RAY_RATIO).decimalPlaces(0, BigNumber.ROUND_DOWN);
};
BigNumber.prototype.halfPercentage = (): BigNumber => {
return new BigNumber(HALF_PERCENTAGE).decimalPlaces(0, BigNumber.ROUND_DOWN);
};
BigNumber.prototype.percentMul = function (b: BigNumber): BigNumber {
return this.halfPercentage().plus(this.multipliedBy(b)).div(PERCENTAGE_FACTOR).decimalPlaces(0, BigNumber.ROUND_DOWN);
return this.halfPercentage()
.plus(this.multipliedBy(b))
.div(PERCENTAGE_FACTOR)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
};
BigNumber.prototype.percentDiv = function (a: BigNumber): BigNumber {
const halfA = a.div(2).decimalPlaces(0, BigNumber.ROUND_DOWN);
return halfA.plus(this.multipliedBy(PERCENTAGE_FACTOR)).div(a).decimalPlaces(0, BigNumber.ROUND_DOWN);
};
return halfA
.plus(this.multipliedBy(PERCENTAGE_FACTOR))
.div(a)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
};

39
test/lending-pool-addresses-provider.spec.ts
View File

@ -1,19 +1,19 @@
import {expect} from 'chai';
import {createRandomAddress} from '../helpers/misc-utils';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors} from '../helpers/types';
import {ethers} from 'ethers';
import {ZERO_ADDRESS} from '../helpers/constants';
import {waitForTx} from '../helpers/misc-utils';
import {deployLendingPool} from '../helpers/contracts-deployments';
import { expect } from 'chai';
import { createRandomAddress } from '../helpers/misc-utils';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors } from '../helpers/types';
import { ethers } from 'ethers';
import { ZERO_ADDRESS } from '../helpers/constants';
import { waitForTx } from '../helpers/misc-utils';
import { deployLendingPool } from '../helpers/contracts-deployments';
const {utils} = ethers;
const { utils } = ethers;
makeSuite('LendingPoolAddressesProvider', (testEnv: TestEnv) => {
it('Test the accessibility of the LendingPoolAddressesProvider', async () => {
const {addressesProvider, users} = testEnv;
const { addressesProvider, users } = testEnv;
const mockAddress = createRandomAddress();
const {INVALID_OWNER_REVERT_MSG} = ProtocolErrors;
const { INVALID_OWNER_REVERT_MSG } = ProtocolErrors;
await addressesProvider.transferOwnership(users[1].address);
@ -30,10 +30,7 @@ makeSuite('LendingPoolAddressesProvider', (testEnv: TestEnv) => {
}
await expect(
addressesProvider.setAddress(
utils.keccak256(utils.toUtf8Bytes('RANDOM_ID')),
mockAddress
)
addressesProvider.setAddress(utils.keccak256(utils.toUtf8Bytes('RANDOM_ID')), mockAddress)
).to.be.revertedWith(INVALID_OWNER_REVERT_MSG);
await expect(
@ -42,16 +39,14 @@ makeSuite('LendingPoolAddressesProvider', (testEnv: TestEnv) => {
mockAddress
)
).to.be.revertedWith(INVALID_OWNER_REVERT_MSG);
});
it('Tests adding a proxied address with `setAddressAsProxy()`', async () => {
const {addressesProvider, users} = testEnv;
const {INVALID_OWNER_REVERT_MSG} = ProtocolErrors;
const { addressesProvider, users } = testEnv;
const { INVALID_OWNER_REVERT_MSG } = ProtocolErrors;
const currentAddressesProviderOwner = users[1];
const mockLendingPool = await deployLendingPool();
const proxiedAddressId = utils.keccak256(utils.toUtf8Bytes('RANDOM_PROXIED'));
@ -74,10 +69,9 @@ makeSuite('LendingPoolAddressesProvider', (testEnv: TestEnv) => {
expect(proxiedAddressSetReceipt.events[1].args?.hasProxy).to.be.equal(true);
});
it('Tests adding a non proxied address with `setAddress()`', async () => {
const {addressesProvider, users} = testEnv;
const {INVALID_OWNER_REVERT_MSG} = ProtocolErrors;
const { addressesProvider, users } = testEnv;
const { INVALID_OWNER_REVERT_MSG } = ProtocolErrors;
const currentAddressesProviderOwner = users[1];
const mockNonProxiedAddress = createRandomAddress();
@ -103,6 +97,5 @@ makeSuite('LendingPoolAddressesProvider', (testEnv: TestEnv) => {
mockNonProxiedAddress
);
expect(nonProxiedAddressSetReceipt.events[0].args?.hasProxy).to.be.equal(false);
});
});

38
test/liquidation-underlying.spec.ts
View File

@ -1,33 +1,33 @@
import BigNumber from 'bignumber.js';
import {DRE, increaseTime} from '../helpers/misc-utils';
import {APPROVAL_AMOUNT_LENDING_POOL, oneEther} from '../helpers/constants';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {makeSuite} from './helpers/make-suite';
import {ProtocolErrors, RateMode} from '../helpers/types';
import {calcExpectedStableDebtTokenBalance} from './helpers/utils/calculations';
import {getUserData} from './helpers/utils/helpers';
import {CommonsConfig} from '../markets/aave/commons';
import { DRE, increaseTime } from '../helpers/misc-utils';
import { APPROVAL_AMOUNT_LENDING_POOL, oneEther } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { makeSuite } from './helpers/make-suite';
import { ProtocolErrors, RateMode } from '../helpers/types';
import { calcExpectedStableDebtTokenBalance } from './helpers/utils/calculations';
import { getUserData } from './helpers/utils/helpers';
import { CommonsConfig } from '../markets/aave/commons';
import {parseEther} from 'ethers/lib/utils';
import { parseEther } from 'ethers/lib/utils';
const chai = require('chai');
const {expect} = chai;
const { expect } = chai;
makeSuite('LendingPool liquidation - liquidator receiving the underlying asset', (testEnv) => {
const {INVALID_HF} = ProtocolErrors;
const { INVALID_HF } = ProtocolErrors;
before('Before LendingPool liquidation: set config', () => {
BigNumber.config({DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN});
BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN });
});
after('After LendingPool liquidation: reset config', () => {
BigNumber.config({DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP});
BigNumber.config({ DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP });
});
it("It's not possible to liquidate on a non-active collateral or a non active principal", async () => {
const {configurator, weth, pool, users, dai} = testEnv;
const { configurator, weth, pool, users, dai } = testEnv;
const user = users[1];
await configurator.deactivateReserve(weth.address);
@ -47,7 +47,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
});
it('Deposits WETH, borrows DAI', async () => {
const {dai, weth, users, pool, oracle} = testEnv;
const { dai, weth, users, pool, oracle } = testEnv;
const depositor = users[0];
const borrower = users[1];
@ -102,7 +102,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
});
it('Drop the health factor below 1', async () => {
const {dai, weth, users, pool, oracle} = testEnv;
const { dai, weth, users, pool, oracle } = testEnv;
const borrower = users[1];
const daiPrice = await oracle.getAssetPrice(dai.address);
@ -121,7 +121,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
});
it('Liquidates the borrow', async () => {
const {dai, weth, users, pool, oracle, helpersContract} = testEnv;
const { dai, weth, users, pool, oracle, helpersContract } = testEnv;
const liquidator = users[3];
const borrower = users[1];
@ -226,7 +226,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
});
it('User 3 deposits 1000 USDC, user 4 1 WETH, user 4 borrows - drops HF, liquidates the borrow', async () => {
const {usdc, users, pool, oracle, weth, helpersContract} = testEnv;
const { usdc, users, pool, oracle, weth, helpersContract } = testEnv;
const depositor = users[3];
const borrower = users[4];
@ -379,7 +379,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
});
it('User 4 deposits 10 AAVE - drops HF, liquidates the AAVE, which results on a lower amount being liquidated', async () => {
const {aave, usdc, users, pool, oracle, helpersContract} = testEnv;
const { aave, usdc, users, pool, oracle, helpersContract } = testEnv;
const depositor = users[3];
const borrower = users[4];

92
test/mainnet/check-list.spec.ts
View File

@ -1,28 +1,28 @@
import {MAX_UINT_AMOUNT} from '../../helpers/constants';
import {convertToCurrencyDecimals} from '../../helpers/contracts-helpers';
import {makeSuite, TestEnv} from '../helpers/make-suite';
import {parseEther} from 'ethers/lib/utils';
import {DRE, waitForTx} from '../../helpers/misc-utils';
import {BigNumber} from 'ethers';
import {getStableDebtToken, getVariableDebtToken} from '../../helpers/contracts-getters';
import {deploySelfdestructTransferMock} from '../../helpers/contracts-deployments';
import {IUniswapV2Router02Factory} from '../../types/IUniswapV2Router02Factory';
import { MAX_UINT_AMOUNT } from '../../helpers/constants';
import { convertToCurrencyDecimals } from '../../helpers/contracts-helpers';
import { makeSuite, TestEnv } from '../helpers/make-suite';
import { parseEther } from 'ethers/lib/utils';
import { DRE, waitForTx } from '../../helpers/misc-utils';
import { BigNumber } from 'ethers';
import { getStableDebtToken, getVariableDebtToken } from '../../helpers/contracts-getters';
import { deploySelfdestructTransferMock } from '../../helpers/contracts-deployments';
import { IUniswapV2Router02Factory } from '../../types/IUniswapV2Router02Factory';
const {expect} = require('chai');
const { expect } = require('chai');
const UNISWAP_ROUTER = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D';
makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
const zero = BigNumber.from('0');
const depositSize = parseEther('5');
const daiSize = parseEther('10000');
it('Deposit WETH', async () => {
const {users, wethGateway, aWETH, pool} = testEnv;
const { users, wethGateway, aWETH, pool } = testEnv;
const user = users[1];
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -31,7 +31,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Withdraw WETH - Partial', async () => {
const {users, wethGateway, aWETH, pool} = testEnv;
const { users, wethGateway, aWETH, pool } = testEnv;
const user = users[1];
const priorEthersBalance = await user.signer.getBalance();
@ -46,10 +46,10 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
const approveTx = await aWETH
.connect(user.signer)
.approve(wethGateway.address, MAX_UINT_AMOUNT);
const {gasUsed: approveGas} = await waitForTx(approveTx);
const { gasUsed: approveGas } = await waitForTx(approveTx);
// Partial Withdraw and send native Ether to user
const {gasUsed: withdrawGas} = await waitForTx(
const { gasUsed: withdrawGas } = await waitForTx(
await wethGateway.connect(user.signer).withdrawETH(partialWithdraw, user.address)
);
@ -68,7 +68,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Withdraw WETH - Full', async () => {
const {users, aWETH, wethGateway, pool} = testEnv;
const { users, aWETH, wethGateway, pool } = testEnv;
const user = users[1];
const priorEthersBalance = await user.signer.getBalance();
@ -80,10 +80,10 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
const approveTx = await aWETH
.connect(user.signer)
.approve(wethGateway.address, MAX_UINT_AMOUNT);
const {gasUsed: approveGas} = await waitForTx(approveTx);
const { gasUsed: approveGas } = await waitForTx(approveTx);
// Full withdraw
const {gasUsed: withdrawGas} = await waitForTx(
const { gasUsed: withdrawGas } = await waitForTx(
await wethGateway.connect(user.signer).withdrawETH(MAX_UINT_AMOUNT, user.address)
);
@ -99,22 +99,26 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Borrow stable WETH and Full Repay with ETH', async () => {
const {users, wethGateway, aWETH, weth, pool, helpersContract} = testEnv;
const { users, wethGateway, aWETH, dai, aDai, weth, pool, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const repaySize = borrowSize.add(borrowSize.mul(5).div(100));
const user = users[1];
const {stableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(weth.address);
const { stableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const stableDebtToken = await getStableDebtToken(stableDebtTokenAddress);
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
// Deposit 10000 DAI
await dai.connect(user.signer).mint(daiSize);
await dai.connect(user.signer).approve(pool.address, daiSize);
await pool.connect(user.signer).deposit(dai.address, daiSize, user.address, '0');
const aTokensBalance = await aWETH.balanceOf(user.address);
const aTokensBalance = await aDai.balanceOf(user.address);
expect(aTokensBalance).to.be.gt(zero);
expect(aTokensBalance).to.be.gte(depositSize);
expect(aTokensBalance).to.be.gte(daiSize);
// Borrow WETH with WETH as collateral
await waitForTx(
@ -129,7 +133,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '1', user.address, {value: repaySize})
.repayETH(MAX_UINT_AMOUNT, '1', user.address, { value: repaySize })
);
const debtBalanceAfterRepay = await stableDebtToken.balanceOf(user.address);
@ -137,19 +141,19 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Borrow variable WETH and Full Repay with ETH', async () => {
const {users, wethGateway, aWETH, weth, pool, helpersContract} = testEnv;
const { users, wethGateway, aWETH, weth, pool, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const repaySize = borrowSize.add(borrowSize.mul(5).div(100));
const user = users[1];
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const varDebtToken = await getVariableDebtToken(variableDebtTokenAddress);
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -170,7 +174,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(partialPayment, '2', user.address, {value: partialPayment})
.repayETH(partialPayment, '2', user.address, { value: partialPayment })
);
const debtBalanceAfterPartialRepay = await varDebtToken.balanceOf(user.address);
@ -180,17 +184,17 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '2', user.address, {value: repaySize})
.repayETH(MAX_UINT_AMOUNT, '2', user.address, { value: repaySize })
);
const debtBalanceAfterFullRepay = await varDebtToken.balanceOf(user.address);
expect(debtBalanceAfterFullRepay).to.be.eq(zero);
});
it('Borrow ETH via delegateApprove ETH and repays back', async () => {
const {users, wethGateway, aWETH, weth, helpersContract} = testEnv;
const { users, wethGateway, aWETH, weth, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const user = users[2];
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const varDebtToken = await getVariableDebtToken(variableDebtTokenAddress);
@ -199,7 +203,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
expect(priorDebtBalance).to.be.eq(zero);
// Deposit WETH with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -222,14 +226,14 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '2', user.address, {value: borrowSize.mul(2)})
.repayETH(MAX_UINT_AMOUNT, '2', user.address, { value: borrowSize.mul(2) })
);
const debtBalanceAfterFullRepay = await varDebtToken.balanceOf(user.address);
expect(debtBalanceAfterFullRepay).to.be.eq(zero);
});
it('Should revert if receiver function receives Ether if not WETH', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const amount = parseEther('1');
@ -244,7 +248,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Should revert if fallback functions is called with Ether', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const amount = parseEther('1');
const fakeABI = ['function wantToCallFallback()'];
@ -263,7 +267,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Should revert if fallback functions is called', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const fakeABI = ['function wantToCallFallback()'];
@ -281,7 +285,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Getters should retrieve correct state', async () => {
const {aWETH, weth, pool, wethGateway} = testEnv;
const { aWETH, weth, pool, wethGateway } = testEnv;
const WETHAddress = await wethGateway.getWETHAddress();
const aWETHAddress = await wethGateway.getAWETHAddress();
@ -293,7 +297,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Owner can do emergency token recovery', async () => {
const {users, weth, dai, wethGateway, deployer} = testEnv;
const { users, weth, dai, wethGateway, deployer } = testEnv;
const user = users[0];
const amount = parseEther('1');
@ -328,7 +332,7 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
});
it('Owner can do emergency native ETH recovery', async () => {
const {users, wethGateway, deployer} = testEnv;
const { users, wethGateway, deployer } = testEnv;
const user = users[0];
const amount = parseEther('1');
const userBalancePriorCall = await user.signer.getBalance();
@ -339,13 +343,13 @@ makeSuite('Mainnet Check list', (testEnv: TestEnv) => {
// Selfdestruct the mock, pointing to WETHGateway address
const callTx = await selfdestructContract
.connect(user.signer)
.destroyAndTransfer(wethGateway.address, {value: amount});
const {gasUsed} = await waitForTx(callTx);
.destroyAndTransfer(wethGateway.address, { value: amount });
const { gasUsed } = await waitForTx(callTx);
const gasFees = gasUsed.mul(callTx.gasPrice);
const userBalanceAfterCall = await user.signer.getBalance();
expect(userBalanceAfterCall).to.be.eq(userBalancePriorCall.sub(amount).sub(gasFees), '');
'User should have lost the funds';
('User should have lost the funds');
// Recover the funds from the contract and sends back to the user
await wethGateway.connect(deployer.signer).emergencyEtherTransfer(user.address, amount);

38
test/pausable-functions.spec.ts
View File

@ -1,13 +1,13 @@
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors, RateMode} from '../helpers/types';
import {APPROVAL_AMOUNT_LENDING_POOL, oneEther} from '../helpers/constants';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {parseEther, parseUnits} from 'ethers/lib/utils';
import {BigNumber} from 'bignumber.js';
import {MockFlashLoanReceiver} from '../types/MockFlashLoanReceiver';
import {getMockFlashLoanReceiver} from '../helpers/contracts-getters';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors, RateMode } from '../helpers/types';
import { APPROVAL_AMOUNT_LENDING_POOL, oneEther } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { parseEther, parseUnits } from 'ethers/lib/utils';
import { BigNumber } from 'bignumber.js';
import { MockFlashLoanReceiver } from '../types/MockFlashLoanReceiver';
import { getMockFlashLoanReceiver } from '../helpers/contracts-getters';
const {expect} = require('chai');
const { expect } = require('chai');
makeSuite('Pausable Pool', (testEnv: TestEnv) => {
let _mockFlashLoanReceiver = {} as MockFlashLoanReceiver;
@ -23,7 +23,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succees', async () => {
const {users, pool, dai, aDai, configurator} = testEnv;
const { users, pool, dai, aDai, configurator } = testEnv;
const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000');
@ -78,7 +78,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Deposit', async () => {
const {users, pool, dai, aDai, configurator} = testEnv;
const { users, pool, dai, aDai, configurator } = testEnv;
const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000');
@ -98,7 +98,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Withdraw', async () => {
const {users, pool, dai, aDai, configurator} = testEnv;
const { users, pool, dai, aDai, configurator } = testEnv;
const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000');
@ -123,7 +123,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Borrow', async () => {
const {pool, dai, users, configurator} = testEnv;
const { pool, dai, users, configurator } = testEnv;
const user = users[1];
// Pause the pool
@ -139,7 +139,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Repay', async () => {
const {pool, dai, users, configurator} = testEnv;
const { pool, dai, users, configurator } = testEnv;
const user = users[1];
// Pause the pool
@ -155,7 +155,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Flash loan', async () => {
const {dai, pool, weth, users, configurator} = testEnv;
const { dai, pool, weth, users, configurator } = testEnv;
const caller = users[3];
@ -185,7 +185,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('Liquidation call', async () => {
const {users, pool, usdc, oracle, weth, configurator, helpersContract} = testEnv;
const { users, pool, usdc, oracle, weth, configurator, helpersContract } = testEnv;
const depositor = users[3];
const borrower = users[4];
@ -266,7 +266,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('SwapBorrowRateMode', async () => {
const {pool, weth, dai, usdc, users, configurator} = testEnv;
const { pool, weth, dai, usdc, users, configurator } = testEnv;
const user = users[1];
const amountWETHToDeposit = parseEther('10');
const amountDAIToDeposit = parseEther('120');
@ -295,7 +295,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('RebalanceStableBorrowRate', async () => {
const {pool, dai, users, configurator} = testEnv;
const { pool, dai, users, configurator } = testEnv;
const user = users[1];
// Pause pool
await configurator.connect(users[1].signer).setPoolPause(true);
@ -309,7 +309,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => {
});
it('setUserUseReserveAsCollateral', async () => {
const {pool, weth, users, configurator} = testEnv;
const { pool, weth, users, configurator } = testEnv;
const user = users[1];
const amountWETHToDeposit = parseEther('1');

20
test/scenario.spec.ts
View File

@ -1,12 +1,12 @@
import {configuration as actionsConfiguration} from './helpers/actions';
import {configuration as calculationsConfiguration} from './helpers/utils/calculations';
import { configuration as actionsConfiguration } from './helpers/actions';
import { configuration as calculationsConfiguration } from './helpers/utils/calculations';
import fs from 'fs';
import BigNumber from 'bignumber.js';
import {makeSuite} from './helpers/make-suite';
import {getReservesConfigByPool} from '../helpers/configuration';
import {AavePools, iAavePoolAssets, IReserveParams} from '../helpers/types';
import {executeStory} from './helpers/scenario-engine';
import { makeSuite } from './helpers/make-suite';
import { getReservesConfigByPool } from '../helpers/configuration';
import { AavePools, iAavePoolAssets, IReserveParams } from '../helpers/types';
import { executeStory } from './helpers/scenario-engine';
const scenarioFolder = './test/helpers/scenarios/';
@ -20,7 +20,7 @@ fs.readdirSync(scenarioFolder).forEach((file) => {
makeSuite(scenario.title, async (testEnv) => {
before('Initializing configuration', async () => {
// Sets BigNumber for this suite, instead of globally
BigNumber.config({DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN});
BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN });
actionsConfiguration.skipIntegrityCheck = false; //set this to true to execute solidity-coverage
@ -30,11 +30,13 @@ fs.readdirSync(scenarioFolder).forEach((file) => {
});
after('Reset', () => {
// Reset BigNumber
BigNumber.config({DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP});
BigNumber.config({ DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP });
});
for (const story of scenario.stories) {
it(story.description, async () => {
it(story.description, async function () {
// Retry the test scenarios up to 4 times if an error happens, due erratic HEVM network errors
this.retries(4);
await executeStory(story, testEnv);
});
}

14
test/stable-token.spec.ts
View File

@ -1,13 +1,13 @@
import {expect} from 'chai';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors} from '../helpers/types';
import {getStableDebtToken} from '../helpers/contracts-getters';
import { expect } from 'chai';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors } from '../helpers/types';
import { getStableDebtToken } from '../helpers/contracts-getters';
makeSuite('Stable debt token tests', (testEnv: TestEnv) => {
const {CT_CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
const { CT_CALLER_MUST_BE_LENDING_POOL } = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, pool, dai, helpersContract} = testEnv;
const { deployer, pool, dai, helpersContract } = testEnv;
const daiStableDebtTokenAddress = (await helpersContract.getReserveTokensAddresses(dai.address))
.stableDebtTokenAddress;
@ -20,7 +20,7 @@ makeSuite('Stable debt token tests', (testEnv: TestEnv) => {
});
it('Tries to invoke burn not being the LendingPool', async () => {
const {deployer, dai, helpersContract} = testEnv;
const { deployer, dai, helpersContract } = testEnv;
const daiStableDebtTokenAddress = (await helpersContract.getReserveTokensAddresses(dai.address))
.stableDebtTokenAddress;

16
test/subgraph-scenarios.spec.ts
View File

@ -1,11 +1,11 @@
import {configuration as actionsConfiguration} from './helpers/actions';
import {configuration as calculationsConfiguration} from './helpers/utils/calculations';
import { configuration as actionsConfiguration } from './helpers/actions';
import { configuration as calculationsConfiguration } from './helpers/utils/calculations';
import BigNumber from 'bignumber.js';
import {makeSuite} from './helpers/make-suite';
import {getReservesConfigByPool} from '../helpers/configuration';
import {AavePools, iAavePoolAssets, IReserveParams} from '../helpers/types';
import {executeStory} from './helpers/scenario-engine';
import { makeSuite } from './helpers/make-suite';
import { getReservesConfigByPool } from '../helpers/configuration';
import { AavePools, iAavePoolAssets, IReserveParams } from '../helpers/types';
import { executeStory } from './helpers/scenario-engine';
makeSuite('Subgraph scenario tests', async (testEnv) => {
let story: any;
@ -14,7 +14,7 @@ makeSuite('Subgraph scenario tests', async (testEnv) => {
const scenario = require(`./helpers/scenarios/borrow-repay-stable`);
story = scenario.stories[0];
// Sets BigNumber for this suite, instead of globally
BigNumber.config({DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN});
BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN });
actionsConfiguration.skipIntegrityCheck = false; //set this to true to execute solidity-coverage
@ -24,7 +24,7 @@ makeSuite('Subgraph scenario tests', async (testEnv) => {
});
after('Reset', () => {
// Reset BigNumber
BigNumber.config({DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP});
BigNumber.config({ DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP });
});
it('deposit-borrow', async () => {
await executeStory(story, testEnv);

850
test/uniswapAdapters.flashLiquidation.spec.ts Normal file
View File

@ -0,0 +1,850 @@
import { makeSuite, TestEnv } from './helpers/make-suite';
import {
convertToCurrencyDecimals,
buildFlashLiquidationAdapterParams,
} from '../helpers/contracts-helpers';
import { getMockUniswapRouter } from '../helpers/contracts-getters';
import { deployFlashLiquidationAdapter } from '../helpers/contracts-deployments';
import { MockUniswapV2Router02 } from '../types/MockUniswapV2Router02';
import BigNumber from 'bignumber.js';
import { DRE, evmRevert, evmSnapshot, increaseTime, waitForTx } from '../helpers/misc-utils';
import { ethers } from 'ethers';
import { ProtocolErrors, RateMode } from '../helpers/types';
import { APPROVAL_AMOUNT_LENDING_POOL, MAX_UINT_AMOUNT, oneEther } from '../helpers/constants';
import { getUserData } from './helpers/utils/helpers';
import { calcExpectedStableDebtTokenBalance } from './helpers/utils/calculations';
const { expect } = require('chai');
makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
let mockUniswapRouter: MockUniswapV2Router02;
let evmSnapshotId: string;
const { INVALID_HF, LP_LIQUIDATION_CALL_FAILED } = ProtocolErrors;
before(async () => {
mockUniswapRouter = await getMockUniswapRouter();
});
const depositAndHFBelowOne = async () => {
const { dai, weth, users, pool, oracle } = testEnv;
const depositor = users[0];
const borrower = users[1];
//mints DAI to depositor
await dai.connect(depositor.signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
//approve protocol to access depositor wallet
await dai.connect(depositor.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
//user 1 deposits 1000 DAI
const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000');
await pool
.connect(depositor.signer)
.deposit(dai.address, amountDAItoDeposit, depositor.address, '0');
//user 2 deposits 1 ETH
const amountETHtoDeposit = await convertToCurrencyDecimals(weth.address, '1');
//mints WETH to borrower
await weth.connect(borrower.signer).mint(await convertToCurrencyDecimals(weth.address, '1000'));
//approve protocol to access the borrower wallet
await weth.connect(borrower.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
await pool
.connect(borrower.signer)
.deposit(weth.address, amountETHtoDeposit, borrower.address, '0');
//user 2 borrows
const userGlobalDataBefore = await pool.getUserAccountData(borrower.address);
const daiPrice = await oracle.getAssetPrice(dai.address);
const amountDAIToBorrow = await convertToCurrencyDecimals(
dai.address,
new BigNumber(userGlobalDataBefore.availableBorrowsETH.toString())
.div(daiPrice.toString())
.multipliedBy(0.95)
.toFixed(0)
);
await pool
.connect(borrower.signer)
.borrow(dai.address, amountDAIToBorrow, RateMode.Stable, '0', borrower.address);
const userGlobalDataAfter = await pool.getUserAccountData(borrower.address);
expect(userGlobalDataAfter.currentLiquidationThreshold.toString()).to.be.equal(
'8250',
INVALID_HF
);
await oracle.setAssetPrice(
dai.address,
new BigNumber(daiPrice.toString()).multipliedBy(1.18).toFixed(0)
);
const userGlobalData = await pool.getUserAccountData(borrower.address);
expect(userGlobalData.healthFactor.toString()).to.be.bignumber.lt(
oneEther.toFixed(0),
INVALID_HF
);
};
const depositSameAssetAndHFBelowOne = async () => {
const { dai, weth, users, pool, oracle } = testEnv;
const depositor = users[0];
const borrower = users[1];
//mints DAI to depositor
await dai.connect(depositor.signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
//approve protocol to access depositor wallet
await dai.connect(depositor.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
//user 1 deposits 1000 DAI
const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000');
await pool
.connect(depositor.signer)
.deposit(dai.address, amountDAItoDeposit, depositor.address, '0');
//user 2 deposits 1 ETH
const amountETHtoDeposit = await convertToCurrencyDecimals(weth.address, '1');
//mints WETH to borrower
await weth.connect(borrower.signer).mint(await convertToCurrencyDecimals(weth.address, '1000'));
//approve protocol to access the borrower wallet
await weth.connect(borrower.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
await pool
.connect(borrower.signer)
.deposit(weth.address, amountETHtoDeposit, borrower.address, '0');
//user 2 borrows
const userGlobalDataBefore = await pool.getUserAccountData(borrower.address);
const daiPrice = await oracle.getAssetPrice(dai.address);
const amountDAIToBorrow = await convertToCurrencyDecimals(
dai.address,
new BigNumber(userGlobalDataBefore.availableBorrowsETH.toString())
.div(daiPrice.toString())
.multipliedBy(0.8)
.toFixed(0)
);
await waitForTx(
await pool
.connect(borrower.signer)
.borrow(dai.address, amountDAIToBorrow, RateMode.Stable, '0', borrower.address)
);
const userGlobalDataBefore2 = await pool.getUserAccountData(borrower.address);
const amountWETHToBorrow = new BigNumber(userGlobalDataBefore2.availableBorrowsETH.toString())
.multipliedBy(0.8)
.toFixed(0);
await pool
.connect(borrower.signer)
.borrow(weth.address, amountWETHToBorrow, RateMode.Variable, '0', borrower.address);
const userGlobalDataAfter = await pool.getUserAccountData(borrower.address);
expect(userGlobalDataAfter.currentLiquidationThreshold.toString()).to.be.equal(
'8250',
INVALID_HF
);
await oracle.setAssetPrice(
dai.address,
new BigNumber(daiPrice.toString()).multipliedBy(1.18).toFixed(0)
);
const userGlobalData = await pool.getUserAccountData(borrower.address);
expect(userGlobalData.healthFactor.toString()).to.be.bignumber.lt(
oneEther.toFixed(0),
INVALID_HF
);
};
beforeEach(async () => {
evmSnapshotId = await evmSnapshot();
});
afterEach(async () => {
await evmRevert(evmSnapshotId);
});
describe('Flash Liquidation Adapter', () => {
before('Before LendingPool liquidation: set config', () => {
BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN });
});
after('After LendingPool liquidation: reset config', () => {
BigNumber.config({ DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP });
});
describe('constructor', () => {
it('should deploy with correct parameters', async () => {
const { addressesProvider, weth } = testEnv;
await deployFlashLiquidationAdapter([
addressesProvider.address,
mockUniswapRouter.address,
weth.address,
]);
});
it('should revert if not valid addresses provider', async () => {
const { weth } = testEnv;
expect(
deployFlashLiquidationAdapter([
mockUniswapRouter.address,
mockUniswapRouter.address,
weth.address,
])
).to.be.reverted;
});
});
describe('executeOperation: succesfully liquidateCall and swap via Flash Loan with profits', () => {
it('Liquidates the borrow with profit', async () => {
await depositAndHFBelowOne();
await increaseTime(100);
const {
dai,
weth,
users,
pool,
oracle,
helpersContract,
flashLiquidationAdapter,
} = testEnv;
const liquidator = users[3];
const borrower = users[1];
const expectedSwap = ethers.utils.parseEther('0.4');
const liquidatorWethBalanceBefore = await weth.balanceOf(liquidator.address);
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (await mockUniswapRouter.setAmountToSwap(weth.address, expectedSwap)).wait();
const collateralPrice = await oracle.getAssetPrice(weth.address);
const principalPrice = await oracle.getAssetPrice(dai.address);
const daiReserveDataBefore = await helpersContract.getReserveData(dai.address);
const ethReserveDataBefore = await helpersContract.getReserveData(weth.address);
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const collateralDecimals = (
await helpersContract.getReserveConfigurationData(weth.address)
).decimals.toString();
const principalDecimals = (
await helpersContract.getReserveConfigurationData(dai.address)
).decimals.toString();
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2).toFixed(0);
const expectedCollateralLiquidated = new BigNumber(principalPrice.toString())
.times(new BigNumber(amountToLiquidate).times(105))
.times(new BigNumber(10).pow(collateralDecimals))
.div(
new BigNumber(collateralPrice.toString()).times(
new BigNumber(10).pow(principalDecimals)
)
)
.div(100)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
const flashLoanDebt = new BigNumber(amountToLiquidate.toString())
.multipliedBy(1.0009)
.toFixed(0);
const expectedProfit = ethers.BigNumber.from(expectedCollateralLiquidated.toString()).sub(
expectedSwap
);
const params = buildFlashLiquidationAdapterParams(
weth.address,
dai.address,
borrower.address,
amountToLiquidate,
false
);
const tx = await pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address],
[amountToLiquidate],
[0],
borrower.address,
params,
0
);
// Expect Swapped event
await expect(Promise.resolve(tx)).to.emit(flashLiquidationAdapter, 'Swapped');
// Expect LiquidationCall event
await expect(Promise.resolve(tx)).to.emit(pool, 'LiquidationCall');
const userReserveDataAfter = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const liquidatorWethBalanceAfter = await weth.balanceOf(liquidator.address);
const daiReserveDataAfter = await helpersContract.getReserveData(dai.address);
const ethReserveDataAfter = await helpersContract.getReserveData(weth.address);
if (!tx.blockNumber) {
expect(false, 'Invalid block number');
return;
}
const txTimestamp = new BigNumber(
(await DRE.ethers.provider.getBlock(tx.blockNumber)).timestamp
);
const stableDebtBeforeTx = calcExpectedStableDebtTokenBalance(
userReserveDataBefore.principalStableDebt,
userReserveDataBefore.stableBorrowRate,
userReserveDataBefore.stableRateLastUpdated,
txTimestamp
);
const collateralAssetContractBalance = await weth.balanceOf(
flashLiquidationAdapter.address
);
const borrowAssetContractBalance = await dai.balanceOf(flashLiquidationAdapter.address);
expect(collateralAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
expect(borrowAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
expect(userReserveDataAfter.currentStableDebt.toString()).to.be.bignumber.almostEqual(
stableDebtBeforeTx.minus(amountToLiquidate).toFixed(0),
'Invalid user debt after liquidation'
);
//the liquidity index of the principal reserve needs to be bigger than the index before
expect(daiReserveDataAfter.liquidityIndex.toString()).to.be.bignumber.gte(
daiReserveDataBefore.liquidityIndex.toString(),
'Invalid liquidity index'
);
//the principal APY after a liquidation needs to be lower than the APY before
expect(daiReserveDataAfter.liquidityRate.toString()).to.be.bignumber.lt(
daiReserveDataBefore.liquidityRate.toString(),
'Invalid liquidity APY'
);
expect(daiReserveDataAfter.availableLiquidity.toString()).to.be.bignumber.almostEqual(
new BigNumber(daiReserveDataBefore.availableLiquidity.toString())
.plus(flashLoanDebt)
.toFixed(0),
'Invalid principal available liquidity'
);
expect(ethReserveDataAfter.availableLiquidity.toString()).to.be.bignumber.almostEqual(
new BigNumber(ethReserveDataBefore.availableLiquidity.toString())
.minus(expectedCollateralLiquidated)
.toFixed(0),
'Invalid collateral available liquidity'
);
// Profit after flash loan liquidation
expect(liquidatorWethBalanceAfter).to.be.equal(
liquidatorWethBalanceBefore.add(expectedProfit),
'Invalid expected WETH profit'
);
});
});
describe('executeOperation: succesfully liquidateCall with same asset via Flash Loan, but no swap needed', () => {
it('Liquidates the borrow with profit', async () => {
await depositSameAssetAndHFBelowOne();
await increaseTime(100);
const { weth, users, pool, oracle, helpersContract, flashLiquidationAdapter } = testEnv;
const liquidator = users[3];
const borrower = users[1];
const liquidatorWethBalanceBefore = await weth.balanceOf(liquidator.address);
const assetPrice = await oracle.getAssetPrice(weth.address);
const ethReserveDataBefore = await helpersContract.getReserveData(weth.address);
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
weth.address,
borrower.address
);
const assetDecimals = (
await helpersContract.getReserveConfigurationData(weth.address)
).decimals.toString();
const amountToLiquidate = userReserveDataBefore.currentVariableDebt.div(2).toFixed(0);
const expectedCollateralLiquidated = new BigNumber(assetPrice.toString())
.times(new BigNumber(amountToLiquidate).times(105))
.times(new BigNumber(10).pow(assetDecimals))
.div(new BigNumber(assetPrice.toString()).times(new BigNumber(10).pow(assetDecimals)))
.div(100)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
const flashLoanDebt = new BigNumber(amountToLiquidate.toString())
.multipliedBy(1.0009)
.toFixed(0);
const params = buildFlashLiquidationAdapterParams(
weth.address,
weth.address,
borrower.address,
amountToLiquidate,
false
);
const tx = await pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[weth.address],
[amountToLiquidate],
[0],
borrower.address,
params,
0
);
// Dont expect Swapped event due is same asset
await expect(Promise.resolve(tx)).to.not.emit(flashLiquidationAdapter, 'Swapped');
// Expect LiquidationCall event
await expect(Promise.resolve(tx))
.to.emit(pool, 'LiquidationCall')
.withArgs(
weth.address,
weth.address,
borrower.address,
amountToLiquidate.toString(),
expectedCollateralLiquidated.toString(),
flashLiquidationAdapter.address,
false
);
const borrowAssetContractBalance = await weth.balanceOf(flashLiquidationAdapter.address);
expect(borrowAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
});
});
describe('executeOperation: succesfully liquidateCall and swap via Flash Loan without profits', () => {
it('Liquidates the borrow', async () => {
await depositAndHFBelowOne();
await increaseTime(100);
const {
dai,
weth,
users,
pool,
oracle,
helpersContract,
flashLiquidationAdapter,
} = testEnv;
const liquidator = users[3];
const borrower = users[1];
const liquidatorWethBalanceBefore = await weth.balanceOf(liquidator.address);
const collateralPrice = await oracle.getAssetPrice(weth.address);
const principalPrice = await oracle.getAssetPrice(dai.address);
const daiReserveDataBefore = await helpersContract.getReserveData(dai.address);
const ethReserveDataBefore = await helpersContract.getReserveData(weth.address);
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const collateralDecimals = (
await helpersContract.getReserveConfigurationData(weth.address)
).decimals.toString();
const principalDecimals = (
await helpersContract.getReserveConfigurationData(dai.address)
).decimals.toString();
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2).toFixed(0);
const expectedCollateralLiquidated = new BigNumber(principalPrice.toString())
.times(new BigNumber(amountToLiquidate).times(105))
.times(new BigNumber(10).pow(collateralDecimals))
.div(
new BigNumber(collateralPrice.toString()).times(
new BigNumber(10).pow(principalDecimals)
)
)
.div(100)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
const flashLoanDebt = new BigNumber(amountToLiquidate.toString())
.multipliedBy(1.0009)
.toFixed(0);
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (
await mockUniswapRouter.setAmountToSwap(
weth.address,
expectedCollateralLiquidated.toString()
)
).wait();
const params = buildFlashLiquidationAdapterParams(
weth.address,
dai.address,
borrower.address,
amountToLiquidate,
false
);
const tx = await pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address],
[flashLoanDebt],
[0],
borrower.address,
params,
0
);
// Expect Swapped event
await expect(Promise.resolve(tx)).to.emit(flashLiquidationAdapter, 'Swapped');
// Expect LiquidationCall event
await expect(Promise.resolve(tx)).to.emit(pool, 'LiquidationCall');
const userReserveDataAfter = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const liquidatorWethBalanceAfter = await weth.balanceOf(liquidator.address);
const daiReserveDataAfter = await helpersContract.getReserveData(dai.address);
const ethReserveDataAfter = await helpersContract.getReserveData(weth.address);
if (!tx.blockNumber) {
expect(false, 'Invalid block number');
return;
}
const txTimestamp = new BigNumber(
(await DRE.ethers.provider.getBlock(tx.blockNumber)).timestamp
);
const stableDebtBeforeTx = calcExpectedStableDebtTokenBalance(
userReserveDataBefore.principalStableDebt,
userReserveDataBefore.stableBorrowRate,
userReserveDataBefore.stableRateLastUpdated,
txTimestamp
);
const collateralAssetContractBalance = await dai.balanceOf(flashLiquidationAdapter.address);
const borrowAssetContractBalance = await weth.balanceOf(flashLiquidationAdapter.address);
expect(collateralAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
expect(borrowAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
expect(userReserveDataAfter.currentStableDebt.toString()).to.be.bignumber.almostEqual(
stableDebtBeforeTx.minus(amountToLiquidate).toFixed(0),
'Invalid user debt after liquidation'
);
//the liquidity index of the principal reserve needs to be bigger than the index before
expect(daiReserveDataAfter.liquidityIndex.toString()).to.be.bignumber.gte(
daiReserveDataBefore.liquidityIndex.toString(),
'Invalid liquidity index'
);
//the principal APY after a liquidation needs to be lower than the APY before
expect(daiReserveDataAfter.liquidityRate.toString()).to.be.bignumber.lt(
daiReserveDataBefore.liquidityRate.toString(),
'Invalid liquidity APY'
);
expect(ethReserveDataAfter.availableLiquidity.toString()).to.be.bignumber.almostEqual(
new BigNumber(ethReserveDataBefore.availableLiquidity.toString())
.minus(expectedCollateralLiquidated)
.toFixed(0),
'Invalid collateral available liquidity'
);
// Net Profit == 0 after flash loan liquidation
expect(liquidatorWethBalanceAfter).to.be.equal(
liquidatorWethBalanceBefore,
'Invalid expected WETH profit'
);
});
});
describe('executeOperation: succesfully liquidateCall all available debt and swap via Flash Loan ', () => {
it('Liquidates the borrow', async () => {
await depositAndHFBelowOne();
await increaseTime(100);
const {
dai,
weth,
users,
pool,
oracle,
helpersContract,
flashLiquidationAdapter,
} = testEnv;
const liquidator = users[3];
const borrower = users[1];
const liquidatorWethBalanceBefore = await weth.balanceOf(liquidator.address);
const collateralPrice = await oracle.getAssetPrice(weth.address);
const principalPrice = await oracle.getAssetPrice(dai.address);
const daiReserveDataBefore = await helpersContract.getReserveData(dai.address);
const ethReserveDataBefore = await helpersContract.getReserveData(weth.address);
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const collateralDecimals = (
await helpersContract.getReserveConfigurationData(weth.address)
).decimals.toString();
const principalDecimals = (
await helpersContract.getReserveConfigurationData(dai.address)
).decimals.toString();
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2).toFixed(0);
const extraAmount = new BigNumber(amountToLiquidate).times('1.15').toFixed(0);
const expectedCollateralLiquidated = new BigNumber(principalPrice.toString())
.times(new BigNumber(amountToLiquidate).times(105))
.times(new BigNumber(10).pow(collateralDecimals))
.div(
new BigNumber(collateralPrice.toString()).times(
new BigNumber(10).pow(principalDecimals)
)
)
.div(100)
.decimalPlaces(0, BigNumber.ROUND_DOWN);
const flashLoanDebt = new BigNumber(amountToLiquidate.toString())
.multipliedBy(1.0009)
.toFixed(0);
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (
await mockUniswapRouter.setAmountToSwap(
weth.address,
expectedCollateralLiquidated.toString()
)
).wait();
const params = buildFlashLiquidationAdapterParams(
weth.address,
dai.address,
borrower.address,
MAX_UINT_AMOUNT,
false
);
const tx = await pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address],
[extraAmount],
[0],
borrower.address,
params,
0
);
// Expect Swapped event
await expect(Promise.resolve(tx)).to.emit(flashLiquidationAdapter, 'Swapped');
// Expect LiquidationCall event
await expect(Promise.resolve(tx)).to.emit(pool, 'LiquidationCall');
const collateralAssetContractBalance = await dai.balanceOf(flashLiquidationAdapter.address);
const borrowAssetContractBalance = await dai.balanceOf(flashLiquidationAdapter.address);
expect(collateralAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
expect(borrowAssetContractBalance).to.be.equal(
'0',
'Contract address should not keep any balance.'
);
});
});
describe('executeOperation: invalid params', async () => {
it('Revert if debt asset is different than requested flash loan token', async () => {
await depositAndHFBelowOne();
const { dai, weth, users, pool, helpersContract, flashLiquidationAdapter } = testEnv;
const liquidator = users[3];
const borrower = users[1];
const expectedSwap = ethers.utils.parseEther('0.4');
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (await mockUniswapRouter.setAmountToSwap(weth.address, expectedSwap)).wait();
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2).toFixed(0);
// Wrong debt asset
const params = buildFlashLiquidationAdapterParams(
weth.address,
weth.address, // intentionally bad
borrower.address,
amountToLiquidate,
false
);
await expect(
pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address],
[amountToLiquidate],
[0],
borrower.address,
params,
0
)
).to.be.revertedWith('INCONSISTENT_PARAMS');
});
it('Revert if debt asset amount to liquidate is greater than requested flash loan', async () => {
await depositAndHFBelowOne();
const { dai, weth, users, pool, helpersContract, flashLiquidationAdapter } = testEnv;
const liquidator = users[3];
const borrower = users[1];
const expectedSwap = ethers.utils.parseEther('0.4');
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (await mockUniswapRouter.setAmountToSwap(weth.address, expectedSwap)).wait();
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2);
// Correct params
const params = buildFlashLiquidationAdapterParams(
weth.address,
dai.address,
borrower.address,
amountToLiquidate.toString(),
false
);
// Bad flash loan params: requested DAI amount below amountToLiquidate
await expect(
pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address],
[amountToLiquidate.div(2).toString()],
[0],
borrower.address,
params,
0
)
).to.be.revertedWith(LP_LIQUIDATION_CALL_FAILED);
});
it('Revert if requested multiple assets', async () => {
await depositAndHFBelowOne();
const { dai, weth, users, pool, helpersContract, flashLiquidationAdapter } = testEnv;
const liquidator = users[3];
const borrower = users[1];
const expectedSwap = ethers.utils.parseEther('0.4');
// Set how much ETH will be sold and swapped for DAI at Uniswap mock
await (await mockUniswapRouter.setAmountToSwap(weth.address, expectedSwap)).wait();
const userReserveDataBefore = await getUserData(
pool,
helpersContract,
dai.address,
borrower.address
);
const amountToLiquidate = userReserveDataBefore.currentStableDebt.div(2);
// Correct params
const params = buildFlashLiquidationAdapterParams(
weth.address,
dai.address,
borrower.address,
amountToLiquidate.toString(),
false
);
// Bad flash loan params: requested multiple assets
await expect(
pool
.connect(liquidator.signer)
.flashLoan(
flashLiquidationAdapter.address,
[dai.address, weth.address],
[10, 10],
[0],
borrower.address,
params,
0
)
).to.be.revertedWith('INCONSISTENT_PARAMS');
});
});
});
});

114
test/uniswapAdapters.repay.spec.ts
View File

@ -4,14 +4,10 @@ import {
getContract,
buildPermitParams,
getSignatureFromTypedData,
buildLiquiditySwapParams,
buildRepayAdapterParams,
} from '../helpers/contracts-helpers';
import { getMockUniswapRouter } from '../helpers/contracts-getters';
import {
deployUniswapLiquiditySwapAdapter,
deployUniswapRepayAdapter,
} from '../helpers/contracts-deployments';
import { deployUniswapRepayAdapter } from '../helpers/contracts-deployments';
import { MockUniswapV2Router02 } from '../types/MockUniswapV2Router02';
import { Zero } from '@ethersproject/constants';
import BigNumber from 'bignumber.js';
@ -21,6 +17,7 @@ import { eContractid } from '../helpers/types';
import { StableDebtToken } from '../types/StableDebtToken';
import { BUIDLEREVM_CHAINID } from '../helpers/buidler-constants';
import { MAX_UINT_AMOUNT } from '../helpers/constants';
import { VariableDebtToken } from '../types';
const { parseEther } = ethers.utils;
const { expect } = require('chai');
@ -801,32 +798,34 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(liquidityToSwap));
});
it('should correctly repay debt using the same asset as collateral', async () => {
it('should correctly repay debt via flash loan using the same asset as collateral', async () => {
const { users, pool, aDai, dai, uniswapRepayAdapter, helpersContract } = testEnv;
const user = users[0].signer;
const userAddress = users[0].address;
// Add deposit for user
await dai.mint(parseEther('20'));
await dai.approve(pool.address, parseEther('20'));
await pool.deposit(dai.address, parseEther('20'), userAddress, 0);
await dai.mint(parseEther('30'));
await dai.approve(pool.address, parseEther('30'));
await pool.deposit(dai.address, parseEther('30'), userAddress, 0);
const amountCollateralToSwap = parseEther('10');
const debtAmount = parseEther('10');
// Open user Debt
await pool.connect(user).borrow(dai.address, debtAmount, 1, 0, userAddress);
await pool.connect(user).borrow(dai.address, debtAmount, 2, 0, userAddress);
const daiStableDebtTokenAddress = (
const daiVariableDebtTokenAddress = (
await helpersContract.getReserveTokensAddresses(dai.address)
).stableDebtTokenAddress;
).variableDebtTokenAddress;
const daiStableDebtContract = await getContract<StableDebtToken>(
eContractid.StableDebtToken,
daiStableDebtTokenAddress
const daiVariableDebtContract = await getContract<VariableDebtToken>(
eContractid.VariableDebtToken,
daiVariableDebtTokenAddress
);
const userDaiStableDebtAmountBefore = await daiStableDebtContract.balanceOf(userAddress);
const userDaiVariableDebtAmountBefore = await daiVariableDebtContract.balanceOf(
userAddress
);
const flashLoanDebt = new BigNumber(amountCollateralToSwap.toString())
.multipliedBy(1.0009)
@ -839,7 +838,7 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
const params = buildRepayAdapterParams(
dai.address,
amountCollateralToSwap,
1,
2,
0,
0,
0,
@ -861,18 +860,30 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
);
const adapterDaiBalance = await dai.balanceOf(uniswapRepayAdapter.address);
const userDaiStableDebtAmount = await daiStableDebtContract.balanceOf(userAddress);
const userDaiVariableDebtAmount = await daiVariableDebtContract.balanceOf(userAddress);
const userADaiBalance = await aDai.balanceOf(userAddress);
const adapterADaiBalance = await aDai.balanceOf(uniswapRepayAdapter.address);
const userDaiBalance = await dai.balanceOf(userAddress);
expect(adapterADaiBalance).to.be.eq(Zero);
expect(adapterDaiBalance).to.be.eq(Zero);
expect(userDaiStableDebtAmountBefore).to.be.gte(debtAmount);
expect(userDaiStableDebtAmount).to.be.lt(debtAmount);
expect(userADaiBalance).to.be.lt(userADaiBalanceBefore);
expect(userADaiBalance).to.be.gte(userADaiBalanceBefore.sub(flashLoanDebt));
expect(userDaiBalance).to.be.eq(userDaiBalanceBefore);
expect(adapterADaiBalance).to.be.eq(Zero, 'adapter aDAI balance should be zero');
expect(adapterDaiBalance).to.be.eq(Zero, 'adapter DAI balance should be zero');
expect(userDaiVariableDebtAmountBefore).to.be.gte(
debtAmount,
' user DAI variable debt before should be gte debtAmount'
);
expect(userDaiVariableDebtAmount).to.be.lt(
debtAmount,
'user dai variable debt amount should be lt debt amount'
);
expect(userADaiBalance).to.be.lt(
userADaiBalanceBefore,
'user aDAI balance should be lt aDAI prior balance'
);
expect(userADaiBalance).to.be.gte(
userADaiBalanceBefore.sub(flashLoanDebt),
'user aDAI balance should be gte aDAI prior balance sub flash loan debt'
);
expect(userDaiBalance).to.be.eq(userDaiBalanceBefore, 'user dai balance eq prior balance');
});
});
@ -1380,27 +1391,29 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
const userAddress = users[0].address;
// Add deposit for user
await dai.mint(parseEther('20'));
await dai.approve(pool.address, parseEther('20'));
await pool.deposit(dai.address, parseEther('20'), userAddress, 0);
await dai.mint(parseEther('30'));
await dai.approve(pool.address, parseEther('30'));
await pool.deposit(dai.address, parseEther('30'), userAddress, 0);
const amountCollateralToSwap = parseEther('4');
const debtAmount = parseEther('3');
// Open user Debt
await pool.connect(user).borrow(dai.address, debtAmount, 1, 0, userAddress);
await pool.connect(user).borrow(dai.address, debtAmount, 2, 0, userAddress);
const daiStableDebtTokenAddress = (
const daiVariableDebtTokenAddress = (
await helpersContract.getReserveTokensAddresses(dai.address)
).stableDebtTokenAddress;
).variableDebtTokenAddress;
const daiStableDebtContract = await getContract<StableDebtToken>(
const daiVariableDebtContract = await getContract<StableDebtToken>(
eContractid.StableDebtToken,
daiStableDebtTokenAddress
daiVariableDebtTokenAddress
);
const userDaiStableDebtAmountBefore = await daiStableDebtContract.balanceOf(userAddress);
const userDaiVariableDebtAmountBefore = await daiVariableDebtContract.balanceOf(
userAddress
);
await aDai.connect(user).approve(uniswapRepayAdapter.address, amountCollateralToSwap);
const userADaiBalanceBefore = await aDai.balanceOf(userAddress);
@ -1411,7 +1424,7 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
dai.address,
amountCollateralToSwap,
amountCollateralToSwap,
1,
2,
{
amount: 0,
deadline: 0,
@ -1423,18 +1436,33 @@ makeSuite('Uniswap adapters', (testEnv: TestEnv) => {
);
const adapterDaiBalance = await dai.balanceOf(uniswapRepayAdapter.address);
const userDaiStableDebtAmount = await daiStableDebtContract.balanceOf(userAddress);
const userDaiVariableDebtAmount = await daiVariableDebtContract.balanceOf(userAddress);
const userADaiBalance = await aDai.balanceOf(userAddress);
const adapterADaiBalance = await aDai.balanceOf(uniswapRepayAdapter.address);
const userDaiBalance = await dai.balanceOf(userAddress);
expect(adapterADaiBalance).to.be.eq(Zero);
expect(adapterDaiBalance).to.be.eq(Zero);
expect(userDaiStableDebtAmountBefore).to.be.gte(debtAmount);
expect(userDaiStableDebtAmount).to.be.lt(debtAmount);
expect(userADaiBalance).to.be.lt(userADaiBalanceBefore);
expect(userADaiBalance).to.be.gte(userADaiBalanceBefore.sub(amountCollateralToSwap));
expect(userDaiBalance).to.be.eq(userDaiBalanceBefore);
expect(adapterADaiBalance).to.be.eq(Zero, 'adapter aADAI should be zero');
expect(adapterDaiBalance).to.be.eq(Zero, 'adapter DAI should be zero');
expect(userDaiVariableDebtAmountBefore).to.be.gte(
debtAmount,
'user dai variable debt before should be gte debtAmount'
);
expect(userDaiVariableDebtAmount).to.be.lt(
debtAmount,
'current user dai variable debt amount should be less than debtAmount'
);
expect(userADaiBalance).to.be.lt(
userADaiBalanceBefore,
'current user aDAI balance should be less than prior balance'
);
expect(userADaiBalance).to.be.gte(
userADaiBalanceBefore.sub(amountCollateralToSwap),
'current user aDAI balance should be gte user balance sub swapped collateral'
);
expect(userDaiBalance).to.be.eq(
userDaiBalanceBefore,
'user DAI balance should remain equal'
);
});
});
});

160
test/upgradeability.spec.ts
View File

@ -1,15 +1,16 @@
import {expect} from 'chai';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors, eContractid} from '../helpers/types';
import {deployContract, getContract} from '../helpers/contracts-helpers';
import {MockAToken} from '../types/MockAToken';
import {MockStableDebtToken} from '../types/MockStableDebtToken';
import {MockVariableDebtToken} from '../types/MockVariableDebtToken';
import {ZERO_ADDRESS} from '../helpers/constants';
import { expect } from 'chai';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors, eContractid } from '../helpers/types';
import { deployContract, getContract } from '../helpers/contracts-helpers';
import { MockAToken } from '../types/MockAToken';
import { MockStableDebtToken } from '../types/MockStableDebtToken';
import { MockVariableDebtToken } from '../types/MockVariableDebtToken';
import { ZERO_ADDRESS } from '../helpers/constants';
import {
getAToken,
getMockStableDebtToken,
getMockVariableDebtToken,
getStableDebtToken,
getVariableDebtToken,
} from '../helpers/contracts-getters';
import {
@ -19,36 +20,36 @@ import {
} from '../helpers/contracts-deployments';
makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {CALLER_NOT_POOL_ADMIN} = ProtocolErrors;
const { CALLER_NOT_POOL_ADMIN } = ProtocolErrors;
let newATokenAddress: string;
let newStableTokenAddress: string;
let newVariableTokenAddress: string;
before('deploying instances', async () => {
const {dai, pool} = testEnv;
const { dai, pool } = testEnv;
const aTokenInstance = await deployMockAToken([
pool.address,
dai.address,
ZERO_ADDRESS,
ZERO_ADDRESS,
'Aave Interest bearing DAI updated',
'aDAI',
ZERO_ADDRESS,
]);
const stableDebtTokenInstance = await deployMockStableDebtToken([
pool.address,
dai.address,
ZERO_ADDRESS,
'Aave stable debt bearing DAI updated',
'stableDebtDAI',
ZERO_ADDRESS,
]);
const variableDebtTokenInstance = await deployMockVariableDebtToken([
pool.address,
dai.address,
ZERO_ADDRESS,
'Aave variable debt bearing DAI updated',
'variableDebtDAI',
ZERO_ADDRESS,
]);
newATokenAddress = aTokenInstance.address;
@ -57,19 +58,53 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
});
it('Tries to update the DAI Atoken implementation with a different address than the lendingPoolManager', async () => {
const {dai, configurator, users} = testEnv;
const { dai, configurator, users } = testEnv;
const name = await (await getAToken(newATokenAddress)).name();
const symbol = await (await getAToken(newATokenAddress)).symbol();
const updateATokenInputParams: {
asset: string;
treasury: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
treasury: ZERO_ADDRESS,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newATokenAddress,
};
await expect(
configurator.connect(users[1].signer).updateAToken(dai.address, newATokenAddress)
configurator.connect(users[1].signer).updateAToken(updateATokenInputParams)
).to.be.revertedWith(CALLER_NOT_POOL_ADMIN);
});
it('Upgrades the DAI Atoken implementation ', async () => {
const {dai, configurator, aDai} = testEnv;
const { dai, configurator, aDai } = testEnv;
const name = await (await getAToken(newATokenAddress)).name();
const symbol = await (await getAToken(newATokenAddress)).symbol();
await configurator.updateAToken(dai.address, newATokenAddress);
const updateATokenInputParams: {
asset: string;
treasury: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
treasury: ZERO_ADDRESS,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newATokenAddress,
};
await configurator.updateAToken(updateATokenInputParams);
const tokenName = await aDai.name();
@ -77,23 +112,57 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
});
it('Tries to update the DAI Stable debt token implementation with a different address than the lendingPoolManager', async () => {
const {dai, configurator, users} = testEnv;
const { dai, configurator, users } = testEnv;
const name = await (await getStableDebtToken(newStableTokenAddress)).name();
const symbol = await (await getStableDebtToken(newStableTokenAddress)).symbol();
const updateDebtTokenInput: {
asset: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newStableTokenAddress,
}
await expect(
configurator
.connect(users[1].signer)
.updateStableDebtToken(dai.address, newStableTokenAddress)
.updateStableDebtToken(updateDebtTokenInput)
).to.be.revertedWith(CALLER_NOT_POOL_ADMIN);
});
it('Upgrades the DAI stable debt token implementation ', async () => {
const {dai, configurator, pool, helpersContract} = testEnv;
const { dai, configurator, pool, helpersContract } = testEnv;
const name = await (await getAToken(newATokenAddress)).name();
const name = await (await getStableDebtToken(newStableTokenAddress)).name();
const symbol = await (await getStableDebtToken(newStableTokenAddress)).symbol();
await configurator.updateStableDebtToken(dai.address, newStableTokenAddress);
const updateDebtTokenInput: {
asset: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newStableTokenAddress,
}
const {stableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(dai.address);
await configurator.updateStableDebtToken(updateDebtTokenInput);
const { stableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(dai.address);
const debtToken = await getMockStableDebtToken(stableDebtTokenAddress);
@ -104,22 +173,57 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
it('Tries to update the DAI variable debt token implementation with a different address than the lendingPoolManager', async () => {
const {dai, configurator, users} = testEnv;
const name = await (await getVariableDebtToken(newVariableTokenAddress)).name();
const symbol = await (await getVariableDebtToken(newVariableTokenAddress)).symbol();
const updateDebtTokenInput: {
asset: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newVariableTokenAddress,
}
await expect(
configurator
.connect(users[1].signer)
.updateVariableDebtToken(dai.address, newVariableTokenAddress)
.updateVariableDebtToken(updateDebtTokenInput)
).to.be.revertedWith(CALLER_NOT_POOL_ADMIN);
});
it('Upgrades the DAI variable debt token implementation ', async () => {
const {dai, configurator, pool, helpersContract} = testEnv;
const name = await (await getVariableDebtToken(newVariableTokenAddress)).name();
const symbol = await (await getVariableDebtToken(newVariableTokenAddress)).symbol();
const updateDebtTokenInput: {
asset: string;
incentivesController: string;
name: string;
symbol: string;
implementation: string;
} = {
asset: dai.address,
incentivesController: ZERO_ADDRESS,
name: name,
symbol: symbol,
implementation: newVariableTokenAddress,
}
//const name = await (await getAToken(newATokenAddress)).name();
const name = await (await getAToken(newATokenAddress)).name();
await configurator.updateVariableDebtToken(updateDebtTokenInput);
await configurator.updateVariableDebtToken(dai.address, newVariableTokenAddress);
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(dai.address);
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
dai.address
);
const debtToken = await getMockVariableDebtToken(variableDebtTokenAddress);

14
test/variable-debt-token.spec.ts
View File

@ -1,13 +1,13 @@
import {expect} from 'chai';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors, TokenContractId, eContractid} from '../helpers/types';
import {getVariableDebtToken} from '../helpers/contracts-getters';
import { expect } from 'chai';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors, TokenContractId, eContractid } from '../helpers/types';
import { getVariableDebtToken } from '../helpers/contracts-getters';
makeSuite('Variable debt token tests', (testEnv: TestEnv) => {
const {CT_CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
const { CT_CALLER_MUST_BE_LENDING_POOL } = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, pool, dai, helpersContract} = testEnv;
const { deployer, pool, dai, helpersContract } = testEnv;
const daiVariableDebtTokenAddress = (
await helpersContract.getReserveTokensAddresses(dai.address)
@ -21,7 +21,7 @@ makeSuite('Variable debt token tests', (testEnv: TestEnv) => {
});
it('Tries to invoke burn not being the LendingPool', async () => {
const {deployer, pool, dai, helpersContract} = testEnv;
const { deployer, pool, dai, helpersContract } = testEnv;
const daiVariableDebtTokenAddress = (
await helpersContract.getReserveTokensAddresses(dai.address)

108
test/weth-gateway.spec.ts
View File

@ -1,25 +1,31 @@
import {MAX_UINT_AMOUNT} from '../helpers/constants';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {parseEther} from 'ethers/lib/utils';
import {DRE, waitForTx} from '../helpers/misc-utils';
import {BigNumber} from 'ethers';
import {getStableDebtToken, getVariableDebtToken} from '../helpers/contracts-getters';
import {deploySelfdestructTransferMock} from '../helpers/contracts-deployments';
import { MAX_UINT_AMOUNT } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { parseEther } from 'ethers/lib/utils';
import { DRE, waitForTx } from '../helpers/misc-utils';
import { BigNumber } from 'ethers';
import { getStableDebtToken, getVariableDebtToken } from '../helpers/contracts-getters';
import { deploySelfdestructTransferMock } from '../helpers/contracts-deployments';
const {expect} = require('chai');
const { expect } = require('chai');
makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) => {
const zero = BigNumber.from('0');
const depositSize = parseEther('5');
it('Deposit WETH', async () => {
const {users, wethGateway, aWETH, pool} = testEnv;
const daiSize = parseEther('10000');
it('Deposit WETH via WethGateway and DAI', async () => {
const { users, wethGateway, aWETH } = testEnv;
const user = users[1];
const depositor = users[0];
// Deposit liquidity with native ETH
await wethGateway
.connect(depositor.signer)
.depositETH(depositor.address, '0', { value: depositSize });
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -28,7 +34,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Withdraw WETH - Partial', async () => {
const {users, wethGateway, aWETH, pool} = testEnv;
const { users, wethGateway, aWETH, pool } = testEnv;
const user = users[1];
const priorEthersBalance = await user.signer.getBalance();
@ -43,10 +49,10 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
const approveTx = await aWETH
.connect(user.signer)
.approve(wethGateway.address, MAX_UINT_AMOUNT);
const {gasUsed: approveGas} = await waitForTx(approveTx);
const { gasUsed: approveGas } = await waitForTx(approveTx);
// Partial Withdraw and send native Ether to user
const {gasUsed: withdrawGas} = await waitForTx(
const { gasUsed: withdrawGas } = await waitForTx(
await wethGateway.connect(user.signer).withdrawETH(partialWithdraw, user.address)
);
@ -65,7 +71,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Withdraw WETH - Full', async () => {
const {users, aWETH, wethGateway, pool} = testEnv;
const { users, aWETH, wethGateway, pool } = testEnv;
const user = users[1];
const priorEthersBalance = await user.signer.getBalance();
@ -77,10 +83,10 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
const approveTx = await aWETH
.connect(user.signer)
.approve(wethGateway.address, MAX_UINT_AMOUNT);
const {gasUsed: approveGas} = await waitForTx(approveTx);
const { gasUsed: approveGas } = await waitForTx(approveTx);
// Full withdraw
const {gasUsed: withdrawGas} = await waitForTx(
const { gasUsed: withdrawGas } = await waitForTx(
await wethGateway.connect(user.signer).withdrawETH(MAX_UINT_AMOUNT, user.address)
);
@ -96,22 +102,32 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Borrow stable WETH and Full Repay with ETH', async () => {
const {users, wethGateway, aWETH, weth, pool, helpersContract} = testEnv;
const { users, wethGateway, aDai, weth, dai, pool, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const repaySize = borrowSize.add(borrowSize.mul(5).div(100));
const user = users[1];
const depositor = users[0];
const {stableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(weth.address);
// Deposit with native ETH
await wethGateway
.connect(depositor.signer)
.depositETH(depositor.address, '0', { value: depositSize });
const { stableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const stableDebtToken = await getStableDebtToken(stableDebtTokenAddress);
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
// Deposit 10000 DAI
await dai.connect(user.signer).mint(daiSize);
await dai.connect(user.signer).approve(pool.address, daiSize);
await pool.connect(user.signer).deposit(dai.address, daiSize, user.address, '0');
const aTokensBalance = await aWETH.balanceOf(user.address);
const aTokensBalance = await aDai.balanceOf(user.address);
expect(aTokensBalance).to.be.gt(zero);
expect(aTokensBalance).to.be.gte(depositSize);
expect(aTokensBalance).to.be.gte(daiSize);
// Borrow WETH with WETH as collateral
await waitForTx(
@ -126,27 +142,31 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '1', user.address, {value: repaySize})
.repayETH(MAX_UINT_AMOUNT, '1', user.address, { value: repaySize })
);
const debtBalanceAfterRepay = await stableDebtToken.balanceOf(user.address);
expect(debtBalanceAfterRepay).to.be.eq(zero);
// Withdraw DAI
await aDai.connect(user.signer).approve(pool.address, MAX_UINT_AMOUNT);
await pool.connect(user.signer).withdraw(dai.address, MAX_UINT_AMOUNT, user.address);
});
it('Borrow variable WETH and Full Repay with ETH', async () => {
const {users, wethGateway, aWETH, weth, pool, helpersContract} = testEnv;
const { users, wethGateway, aWETH, weth, pool, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const repaySize = borrowSize.add(borrowSize.mul(5).div(100));
const user = users[1];
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const varDebtToken = await getVariableDebtToken(variableDebtTokenAddress);
// Deposit with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -167,7 +187,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(partialPayment, '2', user.address, {value: partialPayment})
.repayETH(partialPayment, '2', user.address, { value: partialPayment })
);
const debtBalanceAfterPartialRepay = await varDebtToken.balanceOf(user.address);
@ -177,17 +197,17 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '2', user.address, {value: repaySize})
.repayETH(MAX_UINT_AMOUNT, '2', user.address, { value: repaySize })
);
const debtBalanceAfterFullRepay = await varDebtToken.balanceOf(user.address);
expect(debtBalanceAfterFullRepay).to.be.eq(zero);
});
it('Borrow ETH via delegateApprove ETH and repays back', async () => {
const {users, wethGateway, aWETH, weth, helpersContract} = testEnv;
const { users, wethGateway, aWETH, weth, helpersContract } = testEnv;
const borrowSize = parseEther('1');
const user = users[2];
const {variableDebtTokenAddress} = await helpersContract.getReserveTokensAddresses(
const { variableDebtTokenAddress } = await helpersContract.getReserveTokensAddresses(
weth.address
);
const varDebtToken = await getVariableDebtToken(variableDebtTokenAddress);
@ -196,7 +216,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
expect(priorDebtBalance).to.be.eq(zero);
// Deposit WETH with native ETH
await wethGateway.connect(user.signer).depositETH(user.address, '0', {value: depositSize});
await wethGateway.connect(user.signer).depositETH(user.address, '0', { value: depositSize });
const aTokensBalance = await aWETH.balanceOf(user.address);
@ -219,14 +239,14 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
await waitForTx(
await wethGateway
.connect(user.signer)
.repayETH(MAX_UINT_AMOUNT, '2', user.address, {value: borrowSize.mul(2)})
.repayETH(MAX_UINT_AMOUNT, '2', user.address, { value: borrowSize.mul(2) })
);
const debtBalanceAfterFullRepay = await varDebtToken.balanceOf(user.address);
expect(debtBalanceAfterFullRepay).to.be.eq(zero);
});
it('Should revert if receiver function receives Ether if not WETH', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const amount = parseEther('1');
@ -241,7 +261,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Should revert if fallback functions is called with Ether', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const amount = parseEther('1');
const fakeABI = ['function wantToCallFallback()'];
@ -260,7 +280,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Should revert if fallback functions is called', async () => {
const {users, wethGateway} = testEnv;
const { users, wethGateway } = testEnv;
const user = users[0];
const fakeABI = ['function wantToCallFallback()'];
@ -278,7 +298,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Getters should retrieve correct state', async () => {
const {aWETH, weth, pool, wethGateway} = testEnv;
const { aWETH, weth, pool, wethGateway } = testEnv;
const WETHAddress = await wethGateway.getWETHAddress();
const aWETHAddress = await wethGateway.getAWETHAddress();
@ -290,7 +310,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Owner can do emergency token recovery', async () => {
const {users, dai, wethGateway, deployer} = testEnv;
const { users, dai, wethGateway, deployer } = testEnv;
const user = users[0];
const amount = parseEther('1');
@ -316,7 +336,7 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
});
it('Owner can do emergency native ETH recovery', async () => {
const {users, wethGateway, deployer} = testEnv;
const { users, wethGateway, deployer } = testEnv;
const user = users[0];
const amount = parseEther('1');
const userBalancePriorCall = await user.signer.getBalance();
@ -327,13 +347,13 @@ makeSuite('Use native ETH at LendingPool via WETHGateway', (testEnv: TestEnv) =>
// Selfdestruct the mock, pointing to WETHGateway address
const callTx = await selfdestructContract
.connect(user.signer)
.destroyAndTransfer(wethGateway.address, {value: amount});
const {gasUsed} = await waitForTx(callTx);
.destroyAndTransfer(wethGateway.address, { value: amount });
const { gasUsed } = await waitForTx(callTx);
const gasFees = gasUsed.mul(callTx.gasPrice);
const userBalanceAfterCall = await user.signer.getBalance();
expect(userBalanceAfterCall).to.be.eq(userBalancePriorCall.sub(amount).sub(gasFees), '');
'User should have lost the funds';
('User should have lost the funds');
// Recover the funds from the contract and sends back to the user
await wethGateway.connect(deployer.signer).emergencyEtherTransfer(user.address, amount);