diff --git a/contracts/interfaces/ILendingPool.sol b/contracts/interfaces/ILendingPool.sol index c5801065..4f3d172e 100644 --- a/contracts/interfaces/ILendingPool.sol +++ b/contracts/interfaces/ILendingPool.sol @@ -459,9 +459,7 @@ interface ILendingPool { function paused() external view returns (bool); - function authorizeFlashBorrower(address flashBorrower) external; - - function unauthorizeFlashBorrower(address flashBorrower) external; + function updateFlashBorrowerAuthorization(address flashBorrower, bool authorized) external; function isFlashBorrowerAuthorized(address flashBorrower) external view returns (bool); } diff --git a/contracts/interfaces/ILendingPoolConfigurator.sol b/contracts/interfaces/ILendingPoolConfigurator.sol index 26de950f..ee5cdf2f 100644 --- a/contracts/interfaces/ILendingPoolConfigurator.sol +++ b/contracts/interfaces/ILendingPoolConfigurator.sol @@ -203,21 +203,199 @@ interface ILendingPoolConfigurator { address indexed implementation ); - event RiskAdminRegistered(address indexed admin); - - event RiskAdminUnregistered(address indexed admin); - + /** + * @dev Emitted when a new borrower is authorized (fees = 0) + * @param flashBorrower The address of the authorized borrower + **/ event FlashBorrowerAuthorized(address indexed flashBorrower); + /** + * @dev Emitted when a borrower is unauthorized + * @param flashBorrower The address of the unauthorized borrower + **/ event FlashBorrowerUnauthorized(address indexed flashBorrower); + /** + * @dev Emitted when a new risk admin is registered + * @param admin the newly registered admin + **/ + event RiskAdminRegistered(address indexed admin); + + /** + * @dev Emitted when a risk admin is unregistered + * @param admin the unregistered admin + **/ + event RiskAdminUnregistered(address indexed admin); + + /** + * @dev Initializes reserves in batch + * @param input The array of reserves initialization parameters + **/ + function batchInitReserve(InitReserveInput[] calldata input) external; + + /** + * @dev Updates the aToken implementation for the reserve + * @param input The aToken update paramenters + **/ + function updateAToken(UpdateATokenInput calldata input) external; + + /** + * @dev Updates the stable debt token implementation for the reserve + * @param input The stableDebtToken update parameters + **/ + function updateStableDebtToken(UpdateDebtTokenInput calldata input) external; + + /** + * @dev Updates the variable debt token implementation for the asset + * @param input The variableDebtToken update parameters + **/ + function updateVariableDebtToken(UpdateDebtTokenInput calldata input) external; + + /** + * @dev Enables borrowing on a reserve + * @param asset The address of the underlying asset of the reserve + * @param borrowCap The borrow cap for this specific asset, in absolute units of tokens + * @param stableBorrowRateEnabled True if stable borrow rate needs to be enabled by default on this reserve + **/ + function enableBorrowingOnReserve( + address asset, + uint256 borrowCap, + bool stableBorrowRateEnabled + ) external; + + /** + * @dev Disables borrowing on a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function disableBorrowingOnReserve(address asset) external; + + /** + * @dev Configures the reserve collateralization parameters + * all the values are expressed in percentages with two decimals of precision. A valid value is 10000, which means 100.00% + * @param asset The address of the underlying asset of the reserve + * @param ltv The loan to value of the asset when used as collateral + * @param liquidationThreshold The threshold at which loans using this asset as collateral will be considered undercollateralized + * @param liquidationBonus The bonus liquidators receive to liquidate this asset. The values is always above 100%. A value of 105% + * means the liquidator will receive a 5% bonus + **/ + function configureReserveAsCollateral( + address asset, + uint256 ltv, + uint256 liquidationThreshold, + uint256 liquidationBonus + ) external; + + /** + * @dev Enable stable rate borrowing on a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function enableReserveStableRate(address asset) external; + + /** + * @dev Disable stable rate borrowing on a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function disableReserveStableRate(address asset) external; + + /** + * @dev Activates a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function activateReserve(address asset) external; + + /** + * @dev Deactivates a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function deactivateReserve(address asset) external; + + /** + * @dev Freezes a reserve. A frozen reserve doesn't allow any new deposit, borrow or rate swap + * but allows repayments, liquidations, rate rebalances and withdrawals + * @param asset The address of the underlying asset of the reserve + **/ + function freezeReserve(address asset) external; + + /** + * @dev Unfreezes a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function unfreezeReserve(address asset) external; + + /** + * @dev Pauses a reserve. A paused reserve allow now user moves such as deposit, borrow, repay, swap interestrate, liquidate + * @param asset The address of the underlying asset of the reserve + **/ + function pauseReserve(address asset) external; + + /** + * @dev Unpauses a reserve + * @param asset The address of the underlying asset of the reserve + **/ + function unpauseReserve(address asset) external; + + /** + * @dev Updates the reserve factor of a reserve + * @param asset The address of the underlying asset of the reserve + * @param reserveFactor The new reserve factor of the reserve + **/ + function setReserveFactor(address asset, uint256 reserveFactor) external; + + /** + * @dev Sets the interest rate strategy of a reserve + * @param asset The address of the underlying asset of the reserve + * @param rateStrategyAddress The new address of the interest strategy contract + **/ + function setReserveInterestRateStrategyAddress(address asset, address rateStrategyAddress) + external; + + /** + * @dev pauses or unpauses all the actions of the protocol, including aToken transfers + * @param val true if protocol needs to be paused, false otherwise + **/ + function setPoolPause(bool val) external; + + /** + * @dev Updates the borrow cap of a reserve + * @param asset The address of the underlying asset of the reserve + * @param borrowCap The new borrow of the reserve + **/ + function setBorrowCap(address asset, uint256 borrowCap) external; + + /** + * @dev Updates the supply cap of a reserve + * @param asset The address of the underlying asset of the reserve + * @param supplyCap The new supply of the reserve + **/ + function setSupplyCap(address asset, uint256 supplyCap) external; + + /** + * @dev Registers a new admin with rights on risk related configurations + * @param admin The address of the admin to register + **/ function registerRiskAdmin(address admin) external; + /** + * @dev Unegisters a risk admin + * @param admin The address of the admin to unregister + **/ function unregisterRiskAdmin(address admin) external; + /** + * @dev Returns wether an address in a risk admin or not + * @param admin The address of the potential admin + **/ + function isRiskAdmin(address admin) external view returns (bool); + + /** + * @dev Authorize a new borrower (fees are 0 for the authorized borrower) + * @param flashBorrower The address of the authorized borrower + **/ function authorizeFlashBorrower(address flashBorrower) external; + /** + * @dev Unauthorize a borrower + * @param flashBorrower The address of the unauthorized borrower + **/ function unauthorizeFlashBorrower(address flashBorrower) external; - - function isRiskAdmin(address admin) external view returns (bool); } diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index a675253d..07e62f65 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -825,20 +825,12 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage } } - function authorizeFlashBorrower(address flashBorrower) + function updateFlashBorrowerAuthorization(address flashBorrower, bool authorized) external override onlyLendingPoolConfigurator { - _authorizedFlashBorrowers[flashBorrower] = true; - } - - function unauthorizeFlashBorrower(address flashBorrower) - external - override - onlyLendingPoolConfigurator - { - _authorizedFlashBorrowers[flashBorrower] = false; + _authorizedFlashBorrowers[flashBorrower] = authorized; } function isFlashBorrowerAuthorized(address flashBorrower) external view override returns (bool) { diff --git a/contracts/protocol/lendingpool/LendingPoolConfigurator.sol b/contracts/protocol/lendingpool/LendingPoolConfigurator.sol index 80ca2410..2730937f 100644 --- a/contracts/protocol/lendingpool/LendingPoolConfigurator.sol +++ b/contracts/protocol/lendingpool/LendingPoolConfigurator.sol @@ -30,19 +30,19 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur using PercentageMath for uint256; using ReserveConfiguration for DataTypes.ReserveConfigurationMap; - ILendingPoolAddressesProvider internal addressesProvider; - ILendingPool internal pool; + ILendingPoolAddressesProvider internal _addressesProvider; + ILendingPool internal _pool; mapping(address => bool) private _riskAdmins; modifier onlyPoolAdmin { - require(addressesProvider.getPoolAdmin() == msg.sender, Errors.CALLER_NOT_POOL_ADMIN); + require(_addressesProvider.getPoolAdmin() == msg.sender, Errors.CALLER_NOT_POOL_ADMIN); _; } modifier onlyEmergencyAdmin { require( - addressesProvider.getEmergencyAdmin() == msg.sender, + _addressesProvider.getEmergencyAdmin() == msg.sender, Errors.LPC_CALLER_NOT_EMERGENCY_ADMIN ); _; @@ -50,8 +50,8 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur modifier onlyEmergencyOrPoolAdmin { require( - addressesProvider.getEmergencyAdmin() == msg.sender || - addressesProvider.getPoolAdmin() == msg.sender, + _addressesProvider.getEmergencyAdmin() == msg.sender || + _addressesProvider.getPoolAdmin() == msg.sender, Errors.LPC_CALLER_NOT_EMERGENCY_OR_POOL_ADMIN ); _; @@ -59,7 +59,7 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur modifier onlyRiskOrPoolAdmins { require( - _riskAdmins[msg.sender] || addressesProvider.getPoolAdmin() == msg.sender, + _riskAdmins[msg.sender] || _addressesProvider.getPoolAdmin() == msg.sender, Errors.LPC_CALLER_NOT_RISK_OR_POOL_ADMIN ); _; @@ -72,15 +72,13 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur } function initialize(ILendingPoolAddressesProvider provider) public initializer { - addressesProvider = provider; - pool = ILendingPool(addressesProvider.getLendingPool()); + _addressesProvider = provider; + _pool = ILendingPool(_addressesProvider.getLendingPool()); } - /** - * @dev Initializes reserves in batch - **/ - function batchInitReserve(InitReserveInput[] calldata input) external onlyPoolAdmin { - ILendingPool cachedPool = pool; + /// @inheritdoc ILendingPoolConfigurator + function batchInitReserve(InitReserveInput[] calldata input) external override onlyPoolAdmin { + ILendingPool cachedPool = _pool; for (uint256 i = 0; i < input.length; i++) { _initReserve(cachedPool, input[i]); } @@ -161,11 +159,9 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur ); } - /** - * @dev Updates the aToken implementation for the reserve - **/ - function updateAToken(UpdateATokenInput calldata input) external onlyPoolAdmin { - ILendingPool cachedPool = pool; + /// @inheritdoc ILendingPoolConfigurator + function updateAToken(UpdateATokenInput calldata input) external override onlyPoolAdmin { + ILendingPool cachedPool = _pool; DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset); @@ -189,11 +185,13 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur emit ATokenUpgraded(input.asset, reserveData.aTokenAddress, input.implementation); } - /** - * @dev Updates the stable debt token implementation for the reserve - **/ - function updateStableDebtToken(UpdateDebtTokenInput calldata input) external onlyPoolAdmin { - ILendingPool cachedPool = pool; + /// @inheritdoc ILendingPoolConfigurator + function updateStableDebtToken(UpdateDebtTokenInput calldata input) + external + override + onlyPoolAdmin + { + ILendingPool cachedPool = _pool; DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset); @@ -224,12 +222,13 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur ); } - /** - * @dev Updates the variable debt token implementation for the asset - **/ - function updateVariableDebtToken(UpdateDebtTokenInput calldata input) external onlyPoolAdmin { - ILendingPool cachedPool = pool; - + /// @inheritdoc ILendingPoolConfigurator + function updateVariableDebtToken(UpdateDebtTokenInput calldata input) + external + override + onlyPoolAdmin + { + ILendingPool cachedPool = _pool; DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset); (, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory(); @@ -259,56 +258,42 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur ); } - /** - * @dev Enables borrowing on a reserve - * @param asset The address of the underlying asset of the reserve - * @param stableBorrowRateEnabled True if stable borrow rate needs to be enabled by default on this reserve - **/ + /// @inheritdoc ILendingPoolConfigurator function enableBorrowingOnReserve( address asset, uint256 borrowCap, bool stableBorrowRateEnabled - ) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + ) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setBorrowingEnabled(true); currentConfig.setBorrowCap(borrowCap); currentConfig.setStableRateBorrowingEnabled(stableBorrowRateEnabled); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); + emit BorrowCapChanged(asset, borrowCap); emit BorrowingEnabledOnReserve(asset, stableBorrowRateEnabled); } - /** - * @dev Disables borrowing on a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function disableBorrowingOnReserve(address asset) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function disableBorrowingOnReserve(address asset) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setBorrowingEnabled(false); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit BorrowingDisabledOnReserve(asset); } - /** - * @dev Configures the reserve collateralization parameters - * all the values are expressed in percentages with two decimals of precision. A valid value is 10000, which means 100.00% - * @param asset The address of the underlying asset of the reserve - * @param ltv The loan to value of the asset when used as collateral - * @param liquidationThreshold The threshold at which loans using this asset as collateral will be considered undercollateralized - * @param liquidationBonus The bonus liquidators receive to liquidate this asset. The values is always above 100%. A value of 105% - * means the liquidator will receive a 5% bonus - **/ + /// @inheritdoc ILendingPoolConfigurator function configureReserveAsCollateral( address asset, uint256 ltv, uint256 liquidationThreshold, uint256 liquidationBonus - ) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + ) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); //validation of the parameters: the LTV can //only be lower or equal than the liquidation threshold @@ -341,212 +326,178 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur currentConfig.setLiquidationThreshold(liquidationThreshold); currentConfig.setLiquidationBonus(liquidationBonus); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit CollateralConfigurationChanged(asset, ltv, liquidationThreshold, liquidationBonus); } - /** - * @dev Enable stable rate borrowing on a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function enableReserveStableRate(address asset) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function enableReserveStableRate(address asset) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setStableRateBorrowingEnabled(true); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit StableRateEnabledOnReserve(asset); } - /** - * @dev Disable stable rate borrowing on a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function disableReserveStableRate(address asset) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function disableReserveStableRate(address asset) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setStableRateBorrowingEnabled(false); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit StableRateDisabledOnReserve(asset); } - /** - * @dev Activates a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function activateReserve(address asset) external onlyPoolAdmin { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function activateReserve(address asset) external override onlyPoolAdmin { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setActive(true); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveActivated(asset); } - /** - * @dev Deactivates a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function deactivateReserve(address asset) external onlyPoolAdmin { + /// @inheritdoc ILendingPoolConfigurator + function deactivateReserve(address asset) external override onlyPoolAdmin { _checkNoLiquidity(asset); - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setActive(false); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveDeactivated(asset); } - /** - * @dev Freezes a reserve. A frozen reserve doesn't allow any new deposit, borrow or rate swap - * but allows repayments, liquidations, rate rebalances and withdrawals - * @param asset The address of the underlying asset of the reserve - **/ - function freezeReserve(address asset) external onlyPoolAdmin { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function freezeReserve(address asset) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setFrozen(true); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveFrozen(asset); } - /** - * @dev Unfreezes a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function unfreezeReserve(address asset) external onlyPoolAdmin { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function unfreezeReserve(address asset) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setFrozen(false); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveUnfrozen(asset); } - /** - * @dev Pauses a reserve. A paused reserve allow now user moves such as deposit, borrow, repay, swap interestrate, liquidate - * @param asset The address of the underlying asset of the reserve - **/ - function pauseReserve(address asset) external onlyEmergencyOrPoolAdmin { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function pauseReserve(address asset) external override onlyEmergencyOrPoolAdmin { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setPaused(true); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReservePaused(asset); } - /** - * @dev Unpauses a reserve - * @param asset The address of the underlying asset of the reserve - **/ - function unpauseReserve(address asset) external onlyEmergencyOrPoolAdmin { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function unpauseReserve(address asset) external override onlyEmergencyOrPoolAdmin { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setPaused(false); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveUnpaused(asset); } - /** - * @dev Updates the reserve factor of a reserve - * @param asset The address of the underlying asset of the reserve - * @param reserveFactor The new reserve factor of the reserve - **/ - function setReserveFactor(address asset, uint256 reserveFactor) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + /// @inheritdoc ILendingPoolConfigurator + function setReserveFactor(address asset, uint256 reserveFactor) + external + override + onlyRiskOrPoolAdmins + { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setReserveFactor(reserveFactor); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit ReserveFactorChanged(asset, reserveFactor); } - /** - * @dev Updates the borrow cap of a reserve - * @param asset The address of the underlying asset of the reserve - * @param borrowCap The new borrow of the reserve - **/ - function setBorrowCap(address asset, uint256 borrowCap) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + ///@inheritdoc ILendingPoolConfigurator + function setBorrowCap(address asset, uint256 borrowCap) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setBorrowCap(borrowCap); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit BorrowCapChanged(asset, borrowCap); } - /** - * @dev Updates the supply cap of a reserve - * @param asset The address of the underlying asset of the reserve - * @param supplyCap The new supply of the reserve - **/ - function setSupplyCap(address asset, uint256 supplyCap) external onlyRiskOrPoolAdmins { - DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset); + ///@inheritdoc ILendingPoolConfigurator + function setSupplyCap(address asset, uint256 supplyCap) external override onlyRiskOrPoolAdmins { + DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset); currentConfig.setSupplyCap(supplyCap); - pool.setConfiguration(asset, currentConfig.data); + _pool.setConfiguration(asset, currentConfig.data); emit SupplyCapChanged(asset, supplyCap); } - /** - * @dev Sets the interest rate strategy of a reserve - * @param asset The address of the underlying asset of the reserve - * @param rateStrategyAddress The new address of the interest strategy contract - **/ + ///@inheritdoc ILendingPoolConfigurator function setReserveInterestRateStrategyAddress(address asset, address rateStrategyAddress) external + override onlyRiskOrPoolAdmins { - pool.setReserveInterestRateStrategyAddress(asset, rateStrategyAddress); + _pool.setReserveInterestRateStrategyAddress(asset, rateStrategyAddress); emit ReserveInterestRateStrategyChanged(asset, rateStrategyAddress); } - /** - * @dev pauses or unpauses all the actions of the protocol, including aToken transfers - * @param val true if protocol needs to be paused, false otherwise - **/ - function setPoolPause(bool val) external onlyEmergencyAdmin { - pool.setPause(val); + /// @inheritdoc ILendingPoolConfigurator + function setPoolPause(bool val) external override onlyEmergencyAdmin { + _pool.setPause(val); } + /// @inheritdoc ILendingPoolConfigurator function registerRiskAdmin(address admin) external override onlyPoolAdmin { _riskAdmins[admin] = true; emit RiskAdminRegistered(admin); } + /// @inheritdoc ILendingPoolConfigurator function unregisterRiskAdmin(address admin) external override onlyPoolAdmin { _riskAdmins[admin] = false; emit RiskAdminUnregistered(admin); } + /// @inheritdoc ILendingPoolConfigurator function authorizeFlashBorrower(address flashBorrower) external override onlyPoolAdmin { - pool.authorizeFlashBorrower(flashBorrower); + _pool.updateFlashBorrowerAuthorization(flashBorrower, true); emit FlashBorrowerAuthorized(flashBorrower); } + /// @inheritdoc ILendingPoolConfigurator function unauthorizeFlashBorrower(address flashBorrower) external override onlyPoolAdmin { - pool.unauthorizeFlashBorrower(flashBorrower); + _pool.updateFlashBorrowerAuthorization(flashBorrower, false); emit FlashBorrowerUnauthorized(flashBorrower); } + /// @inheritdoc ILendingPoolConfigurator function isRiskAdmin(address admin) external view override onlyPoolAdmin returns (bool) { return _riskAdmins[admin]; } @@ -575,7 +526,7 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur } function _checkNoLiquidity(address asset) internal view { - DataTypes.ReserveData memory reserveData = pool.getReserveData(asset); + DataTypes.ReserveData memory reserveData = _pool.getReserveData(asset); uint256 availableLiquidity = IERC20Detailed(asset).balanceOf(reserveData.aTokenAddress); diff --git a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol index 59cb734d..91d8bc50 100644 --- a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol +++ b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol @@ -20,8 +20,8 @@ library ReserveConfiguration { uint256 constant STABLE_BORROWING_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFF; // prettier-ignore uint256 constant PAUSED_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFF; // prettier-ignore uint256 constant RESERVE_FACTOR_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFFFFFFFFFF; // prettier-ignore - uint256 constant BORROW_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFFFF; // prettier-ignore - uint256 constant SUPPLY_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore + uint256 constant BORROW_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFF; // prettier-ignore + uint256 constant SUPPLY_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore /// @dev For the LTV, the start bit is 0 (up to 15), hence no bitshifting is needed uint256 constant LIQUIDATION_THRESHOLD_START_BIT_POSITION = 16; @@ -35,15 +35,15 @@ library ReserveConfiguration { // bits 61 62 63 unused yet uint256 constant RESERVE_FACTOR_START_BIT_POSITION = 64; uint256 constant BORROW_CAP_START_BIT_POSITION = 80; - uint256 constant SUPPLY_CAP_START_BIT_POSITION = 128; + uint256 constant SUPPLY_CAP_START_BIT_POSITION = 116; uint256 constant MAX_VALID_LTV = 65535; uint256 constant MAX_VALID_LIQUIDATION_THRESHOLD = 65535; uint256 constant MAX_VALID_LIQUIDATION_BONUS = 65535; uint256 constant MAX_VALID_DECIMALS = 255; uint256 constant MAX_VALID_RESERVE_FACTOR = 65535; - uint256 constant MAX_VALID_BORROW_CAP = 281474976710655; - uint256 constant MAX_VALID_SUPPLY_CAP = 281474976710655; + uint256 constant MAX_VALID_BORROW_CAP = 68719476735; + uint256 constant MAX_VALID_SUPPLY_CAP = 68719476735; /** * @dev Sets the Loan to Value of the reserve @@ -304,9 +304,7 @@ library ReserveConfiguration { { require(borrowCap <= MAX_VALID_BORROW_CAP, Errors.RC_INVALID_BORROW_CAP); - self.data = - (self.data & BORROW_CAP_MASK) | - (borrowCap << BORROW_CAP_START_BIT_POSITION); + self.data = (self.data & BORROW_CAP_MASK) | (borrowCap << BORROW_CAP_START_BIT_POSITION); } /** @@ -333,9 +331,7 @@ library ReserveConfiguration { { require(supplyCap <= MAX_VALID_SUPPLY_CAP, Errors.RC_INVALID_SUPPLY_CAP); - self.data = - (self.data & SUPPLY_CAP_MASK) | - (supplyCap << SUPPLY_CAP_START_BIT_POSITION); + self.data = (self.data & SUPPLY_CAP_MASK) | (supplyCap << SUPPLY_CAP_START_BIT_POSITION); } /** @@ -413,16 +409,13 @@ library ReserveConfiguration { function getCaps(DataTypes.ReserveConfigurationMap storage self) internal view - returns ( - uint256, - uint256 - ) + returns (uint256, uint256) { uint256 dataLocal = self.data; return ( - (self.data & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION, - (self.data & ~SUPPLY_CAP_MASK) >> SUPPLY_CAP_START_BIT_POSITION + (dataLocal & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION, + (dataLocal & ~SUPPLY_CAP_MASK) >> SUPPLY_CAP_START_BIT_POSITION ); } @@ -459,10 +452,7 @@ library ReserveConfiguration { function getCapsMemory(DataTypes.ReserveConfigurationMap memory self) internal pure - returns ( - uint256, - uint256 - ) + returns (uint256, uint256) { return ( (self.data & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION, @@ -494,4 +484,30 @@ library ReserveConfiguration { (self.data & ~PAUSED_MASK) != 0 ); } + + /** + * @dev Gets the supply cap of the reserve from a memory objet + * @param self The reserve configuration + * @return The supply cap + **/ + function getSupplyCapMemory(DataTypes.ReserveConfigurationMap memory self) + internal + pure + returns (uint256) + { + return (self.data & ~SUPPLY_CAP_MASK) >> SUPPLY_CAP_START_BIT_POSITION; + } + + /** + * @dev Gets the borrow cap of the reserve from a memory object + * @param self The reserve configuration + * @return The borrow cap + **/ + function getBorrowCapMemory(DataTypes.ReserveConfigurationMap memory self) + internal + pure + returns (uint256) + { + return (self.data & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION; + } } diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index ca22b7ff..40ef23be 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -40,17 +40,20 @@ library ValidationLogic { * @param reserve The reserve object on which the user is depositing * @param amount The amount to be deposited */ - function validateDeposit(DataTypes.ReserveData storage reserve, uint256 amount) external view { - (bool isActive, bool isFrozen, , , bool isPaused) = reserve.configuration.getFlags(); + function validateDeposit(DataTypes.ReserveData storage reserve, uint256 amount) internal view { + DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration; + (bool isActive, bool isFrozen, , , bool isPaused) = reserveConfiguration.getFlagsMemory(); + (, , , uint256 reserveDecimals, ) = reserveConfiguration.getParamsMemory(); + uint256 supplyCap = reserveConfiguration.getSupplyCapMemory(); require(amount != 0, Errors.VL_INVALID_AMOUNT); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); require(!isFrozen, Errors.VL_RESERVE_FROZEN); require( - IERC20(reserve.aTokenAddress).totalSupply().add(amount).div( - 10**reserve.configuration.getDecimals() - ) < reserve.configuration.getSupplyCap(), + supplyCap == 0 || + IERC20(reserve.aTokenAddress).totalSupply().add(amount).div(10**reserveDecimals) < + supplyCap, Errors.VL_SUPPLY_CAP_EXCEEDED ); } @@ -84,6 +87,8 @@ library ValidationLogic { uint256 healthFactor; uint256 totalSupplyStableDebt; uint256 totalSupplyVariableDebt; + uint256 reserveDecimals; + uint256 borrowCap; bool isActive; bool isFrozen; bool isPaused; @@ -119,16 +124,19 @@ library ValidationLogic { mapping(uint256 => address) storage reserves, uint256 reservesCount, address oracle - ) internal view { + ) external view { ValidateBorrowLocalVars memory vars; + DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration; + (, , , vars.reserveDecimals, ) = reserveConfiguration.getParamsMemory(); + ( vars.isActive, vars.isFrozen, vars.borrowingEnabled, vars.stableRateBorrowingEnabled, vars.isPaused - ) = reserve.configuration.getFlags(); + ) = reserveConfiguration.getFlagsMemory(); require(vars.isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!vars.isPaused, Errors.VL_RESERVE_PAUSED); @@ -144,17 +152,16 @@ library ValidationLogic { Errors.VL_INVALID_INTEREST_RATE_MODE_SELECTED ); - (vars.totalSupplyStableDebt, ) = IStableDebtToken(reserve.stableDebtTokenAddress) - .getTotalSupplyAndAvgRate(); - - vars.totalSupplyVariableDebt = IVariableDebtToken(reserve.variableDebtTokenAddress) - .scaledTotalSupply() - .rayMul(reserve.variableBorrowIndex); + vars.totalSupplyStableDebt = IERC20(reserve.stableDebtTokenAddress).totalSupply(); + vars.borrowCap = reserveConfiguration.getBorrowCapMemory(); + vars.totalSupplyVariableDebt = IERC20(reserve.variableDebtTokenAddress).totalSupply(); require( - vars.totalSupplyStableDebt.add(vars.totalSupplyVariableDebt).add(amount).div( - 10**reserve.configuration.getDecimals() - ) < reserve.configuration.getBorrowCap(), + vars.borrowCap == 0 || + vars.totalSupplyStableDebt.add(vars.totalSupplyVariableDebt).add(amount).div( + 10**vars.reserveDecimals + ) < + vars.borrowCap, Errors.VL_BORROW_CAP_EXCEEDED ); diff --git a/contracts/protocol/libraries/types/DataTypes.sol b/contracts/protocol/libraries/types/DataTypes.sol index b56c8b47..d6399a58 100644 --- a/contracts/protocol/libraries/types/DataTypes.sol +++ b/contracts/protocol/libraries/types/DataTypes.sol @@ -39,8 +39,8 @@ library DataTypes { //bit 60: asset is paused //bit 61-63: reserved //bit 64-79: reserve factor - //bit 80-127 borrow cap - //bit 128-175 borrow cap + //bit 80-115 borrow cap, borrowCap == 0 => disabled + //bit 116-152 supply cap, supplyCap == 0 => disabled uint256 data; } diff --git a/docker-compose.yml b/docker-compose.yml index 7c94bcb3..d81dc720 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -21,3 +21,5 @@ services: ALCHEMY_KEY: ${ALCHEMY_KEY} TENDERLY_FORK_ID: ${TENDERLY_FORK_ID} TENDERLY_HEAD_ID: ${TENDERLY_HEAD_ID} + DEFENDER_API_KEY: ${DEFENDER_API_KEY} + DEFENDER_SECRET_KEY: ${DEFENDER_SECRET_KEY} diff --git a/helpers/configuration.ts b/helpers/configuration.ts index 9b21d08d..82e74e41 100644 --- a/helpers/configuration.ts +++ b/helpers/configuration.ts @@ -6,7 +6,7 @@ import { ICommonConfiguration, eNetwork, } from './types'; -import { getParamPerPool } from './contracts-helpers'; +import { getEthersSignersAddresses, getParamPerPool } from './contracts-helpers'; import AaveConfig from '../markets/aave'; import MaticConfig from '../markets/matic'; import AmmConfig from '../markets/amm'; @@ -66,9 +66,7 @@ export const getGenesisPoolAdmin = async ( if (targetAddress) { return targetAddress; } - const addressList = await Promise.all( - (await DRE.ethers.getSigners()).map((signer) => signer.getAddress()) - ); + const addressList = await getEthersSignersAddresses(); const addressIndex = config.PoolAdminIndex; return addressList[addressIndex]; }; @@ -81,9 +79,7 @@ export const getEmergencyAdmin = async ( if (targetAddress) { return targetAddress; } - const addressList = await Promise.all( - (await DRE.ethers.getSigners()).map((signer) => signer.getAddress()) - ); + const addressList = await getEthersSignersAddresses(); const addressIndex = config.EmergencyAdminIndex; return addressList[addressIndex]; }; diff --git a/helpers/constants.ts b/helpers/constants.ts index a0274bcc..f2568ee0 100644 --- a/helpers/constants.ts +++ b/helpers/constants.ts @@ -15,8 +15,8 @@ export const oneEther = new BigNumber(Math.pow(10, 18)); export const oneRay = new BigNumber(Math.pow(10, 27)); export const MAX_UINT_AMOUNT = '115792089237316195423570985008687907853269984665640564039457584007913129639935'; -export const MAX_BORROW_CAP = '281474976710655'; -export const MAX_SUPPLY_CAP = '281474976710655'; +export const MAX_BORROW_CAP = '68719476735'; +export const MAX_SUPPLY_CAP = '68719476735'; export const ONE_YEAR = '31536000'; export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'; export const ONE_ADDRESS = '0x0000000000000000000000000000000000000001'; diff --git a/helpers/contracts-deployments.ts b/helpers/contracts-deployments.ts index 6ae58383..2d764885 100644 --- a/helpers/contracts-deployments.ts +++ b/helpers/contracts-deployments.ts @@ -137,7 +137,9 @@ export const deployGenericLogic = async (reserveLogic: Contract, verify?: boolea linkedGenericLogicByteCode ); - const genericLogic = await (await genericLogicFactory.deploy()).deployed(); + const genericLogic = await ( + await genericLogicFactory.connect(await getFirstSigner()).deploy() + ).deployed(); return withSaveAndVerify(genericLogic, eContractid.GenericLogic, [], verify); }; @@ -158,7 +160,9 @@ export const deployValidationLogic = async ( linkedValidationLogicByteCode ); - const validationLogic = await (await validationLogicFactory.deploy()).deployed(); + const validationLogic = await ( + await validationLogicFactory.connect(await getFirstSigner()).deploy() + ).deployed(); return withSaveAndVerify(validationLogic, eContractid.ValidationLogic, [], verify); }; diff --git a/helpers/contracts-getters.ts b/helpers/contracts-getters.ts index f6a72321..89be0b9f 100644 --- a/helpers/contracts-getters.ts +++ b/helpers/contracts-getters.ts @@ -32,11 +32,11 @@ import { FlashLiquidationAdapterFactory, } from '../types'; import { IERC20DetailedFactory } from '../types/IERC20DetailedFactory'; -import { MockTokenMap } from './contracts-helpers'; +import { getEthersSigners, MockTokenMap } from './contracts-helpers'; import { DRE, getDb, notFalsyOrZeroAddress } from './misc-utils'; import { eContractid, PoolConfiguration, tEthereumAddress, TokenContractId } from './types'; -export const getFirstSigner = async () => (await DRE.ethers.getSigners())[0]; +export const getFirstSigner = async () => (await getEthersSigners())[0]; export const getLendingPoolAddressesProvider = async (address?: tEthereumAddress) => { return await LendingPoolAddressesProviderFactory.connect( diff --git a/helpers/contracts-helpers.ts b/helpers/contracts-helpers.ts index b4ab51c2..cb7c016e 100644 --- a/helpers/contracts-helpers.ts +++ b/helpers/contracts-helpers.ts @@ -23,9 +23,10 @@ import { MintableERC20 } from '../types/MintableERC20'; import { Artifact } from 'hardhat/types'; import { Artifact as BuidlerArtifact } from '@nomiclabs/buidler/types'; import { verifyEtherscanContract } from './etherscan-verification'; -import { getIErc20Detailed } from './contracts-getters'; +import { getFirstSigner, getIErc20Detailed } from './contracts-getters'; import { usingTenderly, verifyAtTenderly } from './tenderly-utils'; import { usingPolygon, verifyAtPolygon } from './polygon-utils'; +import { getDefenderRelaySigner, usingDefender } from './defender-utils'; export type MockTokenMap = { [symbol: string]: MintableERC20 }; @@ -66,11 +67,18 @@ export const rawInsertContractAddressInDb = async (id: string, address: tEthereu }) .write(); -export const getEthersSigners = async (): Promise => - await Promise.all(await DRE.ethers.getSigners()); +export const getEthersSigners = async (): Promise => { + const ethersSigners = await Promise.all(await DRE.ethers.getSigners()); + + if (usingDefender()) { + const [, ...users] = ethersSigners; + return [await getDefenderRelaySigner(), ...users]; + } + return ethersSigners; +}; export const getEthersSignersAddresses = async (): Promise => - await Promise.all((await DRE.ethers.getSigners()).map((signer) => signer.getAddress())); + await Promise.all((await getEthersSigners()).map((signer) => signer.getAddress())); export const getCurrentBlock = async () => { return DRE.ethers.provider.getBlockNumber(); @@ -83,9 +91,9 @@ export const deployContract = async ( contractName: string, args: any[] ): Promise => { - const contract = (await (await DRE.ethers.getContractFactory(contractName)).deploy( - ...args - )) as ContractType; + const contract = (await (await DRE.ethers.getContractFactory(contractName)) + .connect(await getFirstSigner()) + .deploy(...args)) as ContractType; await waitForTx(contract.deployTransaction); await registerContractInJsonDb(contractName, contract); return contract; diff --git a/helpers/defender-utils.ts b/helpers/defender-utils.ts new file mode 100644 index 00000000..8ce0075a --- /dev/null +++ b/helpers/defender-utils.ts @@ -0,0 +1,41 @@ +import { formatEther } from '@ethersproject/units'; +import { DefenderRelaySigner, DefenderRelayProvider } from 'defender-relay-client/lib/ethers'; +import { Signer } from 'ethers'; +import { HardhatRuntimeEnvironment } from 'hardhat/types'; +import { DRE, impersonateAccountsHardhat } from './misc-utils'; +import { usingTenderly } from './tenderly-utils'; + +export const usingDefender = () => process.env.DEFENDER === 'true'; + +export const getDefenderRelaySigner = async () => { + const { DEFENDER_API_KEY, DEFENDER_SECRET_KEY } = process.env; + let defenderSigner: Signer; + + if (!DEFENDER_API_KEY || !DEFENDER_SECRET_KEY) { + throw new Error('Defender secrets required'); + } + + const credentials = { apiKey: DEFENDER_API_KEY, apiSecret: DEFENDER_SECRET_KEY }; + + defenderSigner = new DefenderRelaySigner(credentials, new DefenderRelayProvider(credentials), { + speed: 'fast', + }); + + const defenderAddress = await defenderSigner.getAddress(); + console.log(' - Using Defender Relay: ', defenderAddress); + + // Replace signer if FORK=main is active + if (process.env.FORK === 'main') { + console.log(' - Impersonating Defender Relay'); + await impersonateAccountsHardhat([defenderAddress]); + defenderSigner = await (DRE as HardhatRuntimeEnvironment).ethers.getSigner(defenderAddress); + } + // Replace signer if Tenderly network is active + if (usingTenderly()) { + console.log(' - Impersonating Defender Relay via Tenderly'); + defenderSigner = await (DRE as HardhatRuntimeEnvironment).ethers.getSigner(defenderAddress); + } + console.log(' - Balance: ', formatEther(await defenderSigner.getBalance())); + + return defenderSigner; +}; diff --git a/helpers/misc-utils.ts b/helpers/misc-utils.ts index 54d5fa44..0315dfe0 100644 --- a/helpers/misc-utils.ts +++ b/helpers/misc-utils.ts @@ -115,3 +115,17 @@ export const notFalsyOrZeroAddress = (address: tEthereumAddress | null | undefin } return isAddress(address) && !isZeroAddress(address); }; + +export const impersonateAccountsHardhat = async (accounts: string[]) => { + if (process.env.TENDERLY === 'true') { + return; + } + // eslint-disable-next-line no-restricted-syntax + for (const account of accounts) { + // eslint-disable-next-line no-await-in-loop + await (DRE as HardhatRuntimeEnvironment).network.provider.request({ + method: 'hardhat_impersonateAccount', + params: [account], + }); + } +}; diff --git a/markets/aave/reservesConfigs.ts b/markets/aave/reservesConfigs.ts index c0be1118..f44e4dc8 100644 --- a/markets/aave/reservesConfigs.ts +++ b/markets/aave/reservesConfigs.ts @@ -1,4 +1,3 @@ -import { MAX_BORROW_CAP, MAX_SUPPLY_CAP } from '../../helpers/constants'; import { eContractid, IReserveParams } from '../../helpers/types'; import { @@ -23,8 +22,8 @@ export const strategyBUSD: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyDAI: IReserveParams = { @@ -37,8 +36,8 @@ export const strategyDAI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategySUSD: IReserveParams = { @@ -51,8 +50,8 @@ export const strategySUSD: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyTUSD: IReserveParams = { @@ -65,8 +64,8 @@ export const strategyTUSD: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDC: IReserveParams = { @@ -79,8 +78,8 @@ export const strategyUSDC: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDT: IReserveParams = { @@ -93,8 +92,8 @@ export const strategyUSDT: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyAAVE: IReserveParams = { @@ -107,8 +106,8 @@ export const strategyAAVE: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '0', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyBAT: IReserveParams = { @@ -121,8 +120,8 @@ export const strategyBAT: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyENJ: IReserveParams = { @@ -135,8 +134,8 @@ export const strategyENJ: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWETH: IReserveParams = { @@ -149,8 +148,8 @@ export const strategyWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyKNC: IReserveParams = { @@ -163,8 +162,8 @@ export const strategyKNC: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyLINK: IReserveParams = { @@ -177,8 +176,8 @@ export const strategyLINK: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyMANA: IReserveParams = { @@ -191,8 +190,8 @@ export const strategyMANA: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '3500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyMKR: IReserveParams = { @@ -205,8 +204,8 @@ export const strategyMKR: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyREN: IReserveParams = { @@ -219,8 +218,8 @@ export const strategyREN: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategySNX: IReserveParams = { @@ -233,8 +232,8 @@ export const strategySNX: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '3500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; // Invalid borrow rates in params currently, replaced with snx params @@ -248,8 +247,8 @@ export const strategyUNI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.DelegationAwareAToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWBTC: IReserveParams = { @@ -262,8 +261,8 @@ export const strategyWBTC: IReserveParams = { reserveDecimals: '8', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyYFI: IReserveParams = { @@ -276,8 +275,8 @@ export const strategyYFI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyZRX: IReserveParams = { @@ -290,8 +289,8 @@ export const strategyZRX: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyXSUSHI: IReserveParams = { @@ -304,6 +303,6 @@ export const strategyXSUSHI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '3500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; diff --git a/markets/amm/reservesConfigs.ts b/markets/amm/reservesConfigs.ts index 8f0f06fa..d59f9ad6 100644 --- a/markets/amm/reservesConfigs.ts +++ b/markets/amm/reservesConfigs.ts @@ -1,11 +1,5 @@ -import { MAX_BORROW_CAP, MAX_SUPPLY_CAP } from '../../helpers/constants'; -import { eContractid, IReserveParams} from '../../helpers/types'; -import { - rateStrategyAmmBase, - rateStrategyStable, - rateStrategyBaseOne, -} from './rateStrategies'; - +import { eContractid, IReserveParams } from '../../helpers/types'; +import { rateStrategyAmmBase, rateStrategyStable, rateStrategyBaseOne } from './rateStrategies'; export const strategyWETH: IReserveParams = { strategy: rateStrategyBaseOne, @@ -17,8 +11,8 @@ export const strategyWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWBTC: IReserveParams = { @@ -31,8 +25,8 @@ export const strategyWBTC: IReserveParams = { reserveDecimals: '8', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyDAI: IReserveParams = { @@ -45,8 +39,8 @@ export const strategyDAI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDC: IReserveParams = { @@ -59,8 +53,8 @@ export const strategyUSDC: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDT: IReserveParams = { @@ -73,8 +67,8 @@ export const strategyUSDT: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyDAIWETH: IReserveParams = { @@ -87,8 +81,8 @@ export const strategyDAIWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWBTCWETH: IReserveParams = { @@ -101,8 +95,8 @@ export const strategyWBTCWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyAAVEWETH: IReserveParams = { @@ -115,8 +109,8 @@ export const strategyAAVEWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyBATWETH: IReserveParams = { @@ -129,8 +123,8 @@ export const strategyBATWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyDAIUSDC: IReserveParams = { @@ -143,8 +137,8 @@ export const strategyDAIUSDC: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyCRVWETH: IReserveParams = { @@ -157,8 +151,8 @@ export const strategyCRVWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyLINKWETH: IReserveParams = { @@ -171,8 +165,8 @@ export const strategyLINKWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyMKRWETH: IReserveParams = { @@ -185,8 +179,8 @@ export const strategyMKRWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyRENWETH: IReserveParams = { @@ -199,8 +193,8 @@ export const strategyRENWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategySNXWETH: IReserveParams = { @@ -213,8 +207,8 @@ export const strategySNXWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUNIWETH: IReserveParams = { @@ -227,8 +221,8 @@ export const strategyUNIWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDCWETH: IReserveParams = { @@ -241,8 +235,8 @@ export const strategyUSDCWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWBTCUSDC: IReserveParams = { @@ -255,8 +249,8 @@ export const strategyWBTCUSDC: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyYFIWETH: IReserveParams = { @@ -269,8 +263,8 @@ export const strategyYFIWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyBALWETH: IReserveParams = { @@ -283,6 +277,6 @@ export const strategyBALWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1500', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, -} \ No newline at end of file + borrowCap: '0', + supplyCap: '0', +}; diff --git a/markets/matic/reservesConfigs.ts b/markets/matic/reservesConfigs.ts index babb5b17..cbeba1a6 100644 --- a/markets/matic/reservesConfigs.ts +++ b/markets/matic/reservesConfigs.ts @@ -1,6 +1,5 @@ // import BigNumber from 'bignumber.js'; // import { oneRay } from '../../helpers/constants'; -import { MAX_BORROW_CAP, MAX_SUPPLY_CAP } from '../../helpers/constants'; import { eContractid, IReserveParams } from '../../helpers/types'; import { rateStrategyStableTwo, @@ -21,8 +20,8 @@ export const strategyDAI: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDC: IReserveParams = { @@ -35,8 +34,8 @@ export const strategyUSDC: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyUSDT: IReserveParams = { @@ -49,8 +48,8 @@ export const strategyUSDT: IReserveParams = { reserveDecimals: '6', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWETH: IReserveParams = { @@ -63,8 +62,8 @@ export const strategyWETH: IReserveParams = { reserveDecimals: '18', aTokenImpl: eContractid.AToken, reserveFactor: '1000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyWBTC: IReserveParams = { @@ -77,8 +76,8 @@ export const strategyWBTC: IReserveParams = { reserveDecimals: '8', aTokenImpl: eContractid.AToken, reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', }; export const strategyMATIC: IReserveParams = { @@ -90,9 +89,9 @@ export const strategyMATIC: IReserveParams = { stableBorrowRateEnabled: false, reserveDecimals: '18', aTokenImpl: eContractid.AToken, + borrowCap: '0', + supplyCap: '0', reserveFactor: '2000', - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, }; export const strategyAAVE: IReserveParams = { @@ -104,7 +103,7 @@ export const strategyAAVE: IReserveParams = { stableBorrowRateEnabled: false, reserveDecimals: '18', aTokenImpl: eContractid.AToken, - borrowCap: MAX_BORROW_CAP, - supplyCap: MAX_SUPPLY_CAP, + borrowCap: '0', + supplyCap: '0', reserveFactor: '0', }; diff --git a/package-lock.json b/package-lock.json index 577e1e95..45919623 100644 --- a/package-lock.json +++ b/package-lock.json @@ -24703,18 +24703,18 @@ } }, "@babel/helper-validator-identifier": { - "version": "7.12.11", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz", - "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==", + "version": "7.14.0", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.0.tgz", + "integrity": "sha512-V3ts7zMSu5lfiwWDVWzRDGIN+lnCEUdaXgtVHJgLb1rGaA6jMrtB9EmE7L18foXJIE8Un/A/h6NJfGQp/e1J4A==", "dev": true }, "@babel/highlight": { - "version": "7.13.10", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz", - "integrity": "sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==", + "version": "7.14.0", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.0.tgz", + "integrity": "sha512-YSCOwxvTYEIMSGaBQb5kDDsCopDdiUGsqpatp3fOlI4+2HQSkTmEVWnVuySdAC5EWCqSWWTv0ib63RjR7dTBdg==", "dev": true, "requires": { - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-validator-identifier": "^7.14.0", "chalk": "^2.0.0", "js-tokens": "^4.0.0" } @@ -24967,9 +24967,9 @@ } }, "@ethereum-waffle/ens": { - "version": "3.2.3", - "resolved": "https://registry.npmjs.org/@ethereum-waffle/ens/-/ens-3.2.3.tgz", - "integrity": "sha512-OIfguJu4e+NYJHNnNVaFzvNG5WYPntWU1vnQuAFszBFytOeIkv2hAXv8RmRL+cledcvShtP3gmXU3Lvf0o4Sxw==", + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@ethereum-waffle/ens/-/ens-3.2.4.tgz", + "integrity": "sha512-lkRVPCEkk7KOwH9MqFMB+gL0X8cZNsm+MnKpP9CNbAyhFos2sCDGcY8t6BA12KBK6pdMuuRXPxYL9WfPl9bqSQ==", "dev": true, "requires": { "@ensdomains/ens": "^0.4.4", @@ -24988,14 +24988,14 @@ } }, "@ethereum-waffle/provider": { - "version": "3.3.1", - "resolved": "https://registry.npmjs.org/@ethereum-waffle/provider/-/provider-3.3.1.tgz", - "integrity": "sha512-I7iziCqvkVhfaYKRRjUoEK3JHne5PffLd8dokI9RvDighKn/OA4P8mMb400EGmuDG5NTVTM5hdnTa2jIYwrhyA==", + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/@ethereum-waffle/provider/-/provider-3.3.2.tgz", + "integrity": "sha512-ilz6cXK0ylSKCmZktTMpY4gjo0CN6rb86JfN7+RZYk6tKtZA6sXoOe95skWEQkGf1fZk7G817fTzLb0CmFDp1g==", "dev": true, "requires": { - "@ethereum-waffle/ens": "^3.2.2", + "@ethereum-waffle/ens": "^3.2.4", "ethers": "^5.0.1", - "ganache-core": "^2.10.2", + "ganache-core": "^2.13.2", "patch-package": "^6.2.2", "postinstall-postinstall": "^2.1.0" } @@ -25819,192 +25819,193 @@ } }, "@ethersproject/abi": { - "version": "5.0.13", - "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.0.13.tgz", - "integrity": "sha512-2coOH3D7ra1lwamKEH0HVc+Jbcsw5yfeCgmY8ekhCDualEiyyovD2qDcMBBcY3+kjoLHVTmo7ost6MNClxdOrg==", + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.1.2.tgz", + "integrity": "sha512-uMhoQVPX0UtfzTpekYQSEUcJGDgsJ25ifz+SV6PDETWaUFhcR8RNgb1QPTASP13inW8r6iy0/Xdq9D5hK2pNvA==", "dev": true, "requires": { - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/hash": "^5.0.10", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" + "@ethersproject/address": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/hash": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/strings": "^5.1.0" } }, "@ethersproject/abstract-provider": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.0.10.tgz", - "integrity": "sha512-OSReY5iz94iIaPlRvLiJP8YVIvQLx4aUvMMnHWSaA/vTU8QHZmgNlt4OBdYV1+aFY8Xl+VRYiWBHq72ZDKXXCQ==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.1.0.tgz", + "integrity": "sha512-8dJUnT8VNvPwWhYIau4dwp7qe1g+KgdRm4XTWvjkI9gAT2zZa90WF5ApdZ3vl1r6NDmnn6vUVvyphClRZRteTQ==", "dev": true, "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/networks": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/web": "^5.0.12" + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/networks": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/transactions": "^5.1.0", + "@ethersproject/web": "^5.1.0" } }, "@ethersproject/abstract-signer": { - "version": "5.0.14", - "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.0.14.tgz", - "integrity": "sha512-JztBwVO7o5OHLh2vyjordlS4/1EjRyaECtc8vPdXTF1i4dXN+J0coeRoPN6ZFbBvi/YbaB6br2fvqhst1VQD/g==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.1.0.tgz", + "integrity": "sha512-qQDMkjGZSSJSKl6AnfTgmz9FSnzq3iEoEbHTYwjDlEAv+LNP7zd4ixCcVWlWyk+2siud856M5CRhAmPdupeN9w==", "dev": true, "requires": { - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7" + "@ethersproject/abstract-provider": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0" } }, "@ethersproject/address": { - "version": "5.0.11", - "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.0.11.tgz", - "integrity": "sha512-Et4GBdD8/tsBGjCEOKee9upN29qjL5kbRcmJifb4Penmiuh9GARXL2/xpXvEp5EW+EIW/rfCHFJrkYBgoQFQBw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.1.0.tgz", + "integrity": "sha512-rfWQR12eHn2cpstCFS4RF7oGjfbkZb0oqep+BfrT+gWEGWG2IowJvIsacPOvzyS1jhNF4MQ4BS59B04Mbovteg==", "dev": true, "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/rlp": "^5.0.7" + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/rlp": "^5.1.0" } }, "@ethersproject/base64": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.0.9.tgz", - "integrity": "sha512-37RBz5LEZ9SlTNGiWCYFttnIN9J7qVs9Xo2EbqGqDH5LfW9EIji66S+YDMpXVo1zWDax1FkEldAoatxHK2gfgA==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.1.0.tgz", + "integrity": "sha512-npD1bLvK4Bcxz+m4EMkx+F8Rd7CnqS9DYnhNu0/GlQBXhWjvfoAZzk5HJ0f1qeyp8d+A86PTuzLOGOXf4/CN8g==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9" + "@ethersproject/bytes": "^5.1.0" } }, "@ethersproject/basex": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.0.9.tgz", - "integrity": "sha512-FANswl1IN3PS0eltQxH2aM2+utPrkLUVG4XVFi6SafRG9EpAqXCgycxC8PU90mPGhigYTpg9cnTB5mCZ6ejQjw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.1.0.tgz", + "integrity": "sha512-vBKr39bum7DDbOvkr1Sj19bRMEPA4FnST6Utt6xhDzI7o7L6QNkDn2yrCfP+hnvJGhZFKtLygWwqlTBZoBXYLg==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/properties": "^5.0.7" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/properties": "^5.1.0" } }, "@ethersproject/bignumber": { - "version": "5.0.15", - "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.0.15.tgz", - "integrity": "sha512-MTADqnyacvdRwtKh7o9ujwNDSM1SDJjYDMYAzjIgjoi9rh6TY4suMbhCa3i2vh3SUXiXSICyTI8ui+NPdrZ9Lw==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.1.1.tgz", + "integrity": "sha512-AVz5iqz7+70RIqoQTznsdJ6DOVBYciNlvO+AlQmPTB6ofCvoihI9bQdr6wljsX+d5W7Yc4nyvQvP4JMzg0Agig==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", "bn.js": "^4.4.0" } }, "@ethersproject/bytes": { - "version": "5.0.11", - "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.0.11.tgz", - "integrity": "sha512-D51plLYY5qF05AsoVQwIZVLqlBkaTPVHVP/1WmmBIWyHB0cRW0C9kh0kx5Exo51rB63Hk8PfHxc7SmpoaQFEyg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.1.0.tgz", + "integrity": "sha512-sGTxb+LVjFxJcJeUswAIK6ncgOrh3D8c192iEJd7mLr95V6du119rRfYT/b87WPkZ5I3gRBUYIYXtdgCWACe8g==", "dev": true, "requires": { - "@ethersproject/logger": "^5.0.8" + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/constants": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.0.10.tgz", - "integrity": "sha512-OSo8jxkHLDXieCy8bgOFR7lMfgPxEzKvSDdP+WAWHCDM8+orwch0B6wzkTmiQFgryAtIctrBt5glAdJikZ3hGw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.1.0.tgz", + "integrity": "sha512-0/SuHrxc8R8k+JiLmJymxHJbojUDWBQqO+b+XFdwaP0jGzqC09YDy/CAlSZB6qHsBifY8X3I89HcK/oMqxRdBw==", "dev": true, "requires": { - "@ethersproject/bignumber": "^5.0.13" + "@ethersproject/bignumber": "^5.1.0" } }, "@ethersproject/contracts": { - "version": "5.0.12", - "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.0.12.tgz", - "integrity": "sha512-srijy31idjz8bE+gL1I6IRj2H4I9dUwfQ+QroLrIgNdGArqY8y2iFUKa3QTy+JBX26fJsdYiCQi1kKkaNpnMpQ==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.1.1.tgz", + "integrity": "sha512-6WwktLJ0DFWU8pDkgH4IGttQHhQN4SnwKFu9h+QYVe48VGWtbDu4W8/q/7QA1u/HWlWMrKxqawPiZUJj0UMvOw==", "dev": true, "requires": { - "@ethersproject/abi": "^5.0.10", - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7" + "@ethersproject/abi": "^5.1.0", + "@ethersproject/abstract-provider": "^5.1.0", + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/address": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/transactions": "^5.1.0" } }, "@ethersproject/hash": { - "version": "5.0.12", - "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.0.12.tgz", - "integrity": "sha512-kn4QN+fhNFbUgX3XZTZUaQixi0oyfIEY+hfW+KtkHu+rq7dV76oAIvaLEEynu1/4npOL38E4X4YI42gGZk+C0Q==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.1.0.tgz", + "integrity": "sha512-fNwry20yLLPpnRRwm3fBL+2ksgO+KMadxM44WJmRIoTKzy4269+rbq9KFoe2LTqq2CXJM2CE70beGaNrpuqflQ==", "dev": true, "requires": { - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/address": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/strings": "^5.1.0" } }, "@ethersproject/hdnode": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.0.10.tgz", - "integrity": "sha512-ZLwMtIcXK7xz2lSITDCl40W04CtRq4K9NwBxhCzdzPdaz6XnoJMwGz2YMVLg+8ksseq+RYtTwIIXtlK6vyvQyg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.1.0.tgz", + "integrity": "sha512-obIWdlujloExPHWJGmhJO/sETOOo7SEb6qemV4f8kyFoXg+cJK+Ta9SvBrj7hsUK85n3LZeZJZRjjM7oez3Clg==", "dev": true, "requires": { - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/basex": "^5.0.7", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/pbkdf2": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/sha2": "^5.0.7", - "@ethersproject/signing-key": "^5.0.8", - "@ethersproject/strings": "^5.0.8", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/wordlists": "^5.0.8" + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/basex": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/pbkdf2": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/sha2": "^5.1.0", + "@ethersproject/signing-key": "^5.1.0", + "@ethersproject/strings": "^5.1.0", + "@ethersproject/transactions": "^5.1.0", + "@ethersproject/wordlists": "^5.1.0" } }, "@ethersproject/json-wallets": { - "version": "5.0.12", - "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.0.12.tgz", - "integrity": "sha512-nac553zGZnOewpjlqbfy7WBl8m3y7qudzRsI2dCxrediYtPIVIs9f6Pbnou8vDmmp8X4/U4W788d+Ma88o+Gbg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.1.0.tgz", + "integrity": "sha512-00n2iBy27w8zrGZSiU762UOVuzCQZxUZxopsZC47++js6xUFuI74DHcJ5K/2pddlF1YBskvmMuboEu1geK8mnA==", "dev": true, "requires": { - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/hdnode": "^5.0.8", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/pbkdf2": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/random": "^5.0.7", - "@ethersproject/strings": "^5.0.8", - "@ethersproject/transactions": "^5.0.9", + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/address": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/hdnode": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/pbkdf2": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/random": "^5.1.0", + "@ethersproject/strings": "^5.1.0", + "@ethersproject/transactions": "^5.1.0", "aes-js": "3.0.0", "scrypt-js": "3.0.1" } }, "@ethersproject/keccak256": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.0.9.tgz", - "integrity": "sha512-zhdUTj6RGtCJSgU+bDrWF6cGbvW453LoIC1DSNWrTlXzC7WuH4a+EiPrgc7/kNoRxerKuA/cxYlI8GwNtVtDlw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.1.0.tgz", + "integrity": "sha512-vrTB1W6AEYoadww5c9UyVJ2YcSiyIUTNDRccZIgwTmFFoSHwBtcvG1hqy9RzJ1T0bMdATbM9Hfx2mJ6H0i7Hig==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", + "@ethersproject/bytes": "^5.1.0", "js-sha3": "0.5.7" }, "dependencies": { @@ -26017,62 +26018,62 @@ } }, "@ethersproject/logger": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.0.10.tgz", - "integrity": "sha512-0y2T2NqykDrbPM3Zw9RSbPkDOxwChAL8detXaom76CfYoGxsOnRP/zTX8OUAV+x9LdwzgbWvWmeXrc0M7SuDZw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.1.0.tgz", + "integrity": "sha512-wtUaD1lBX10HBXjjKV9VHCBnTdUaKQnQ2XSET1ezglqLdPdllNOIlLfhyCRqXm5xwcjExVI5ETokOYfjPtaAlw==", "dev": true }, "@ethersproject/networks": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.0.9.tgz", - "integrity": "sha512-L8+VCQwArBLGkxZb/5Ns/OH/OxP38AcaveXIxhUTq+VWpXYjrObG3E7RDQIKkUx1S1IcQl/UWTz5w4DK0UitJg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.1.0.tgz", + "integrity": "sha512-A/NIrIED/G/IgU1XUukOA3WcFRxn2I4O5GxsYGA5nFlIi+UZWdGojs85I1VXkR1gX9eFnDXzjE6OtbgZHjFhIA==", "dev": true, "requires": { - "@ethersproject/logger": "^5.0.8" + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/pbkdf2": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.0.9.tgz", - "integrity": "sha512-ItE/wQ/WVw/ajEHPUVgfu0aEvksPgOQc+278bke8sGKnGO3ppjmqp0MHh17tHc1EBTzJbSms5aLIqc56qZ/oiA==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.1.0.tgz", + "integrity": "sha512-B8cUbHHTgs8OtgJIafrRcz/YPDobVd5Ru8gTnShOiM9EBuFpYHQpq3+8iQJ6pyczDu6HP/oc/njAsIBhwFZYew==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/sha2": "^5.0.7" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/sha2": "^5.1.0" } }, "@ethersproject/properties": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.0.9.tgz", - "integrity": "sha512-ZCjzbHYTw+rF1Pn8FDCEmx3gQttwIHcm/6Xee8g/M3Ga3SfW4tccNMbs5zqnBH0E4RoOPaeNgyg1O68TaF0tlg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.1.0.tgz", + "integrity": "sha512-519KKTwgmH42AQL3+GFV3SX6khYEfHsvI6v8HYejlkigSDuqttdgVygFTDsGlofNFchhDwuclrxQnD5B0YLNMg==", "dev": true, "requires": { - "@ethersproject/logger": "^5.0.8" + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/providers": { - "version": "5.0.24", - "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.0.24.tgz", - "integrity": "sha512-M4Iw1r4gGJkt7ZUa++iREuviKL/DIpmIMsaUlVlXtV+ZrUXeN8xQ3zOTrbz7R4h9W9oljBZM7i4D3Kn1krJ30A==", + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.1.2.tgz", + "integrity": "sha512-GqsS8rd+eyd4eNkcNgzZ4l9IRULBPUZa7JPnv22k4MHflMobUseyhfbVnmoN5bVNNkOxjV1IPTw9i0sV1hwdpg==", "dev": true, "requires": { - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/basex": "^5.0.7", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/hash": "^5.0.10", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/networks": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/random": "^5.0.7", - "@ethersproject/rlp": "^5.0.7", - "@ethersproject/sha2": "^5.0.7", - "@ethersproject/strings": "^5.0.8", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/web": "^5.0.12", + "@ethersproject/abstract-provider": "^5.1.0", + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/address": "^5.1.0", + "@ethersproject/basex": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/hash": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/networks": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/random": "^5.1.0", + "@ethersproject/rlp": "^5.1.0", + "@ethersproject/sha2": "^5.1.0", + "@ethersproject/strings": "^5.1.0", + "@ethersproject/transactions": "^5.1.0", + "@ethersproject/web": "^5.1.0", "bech32": "1.1.4", "ws": "7.2.3" }, @@ -26086,33 +26087,33 @@ } }, "@ethersproject/random": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.0.9.tgz", - "integrity": "sha512-DANG8THsKqFbJOantrxumtG6gyETNE54VfbsWa+SQAT8WKpDo9W/X5Zhh73KuhClaey1UI32uVmISZeq/Zxn1A==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.1.0.tgz", + "integrity": "sha512-+uuczLQZ4+no9cP6TCoCktXx0u2YbNaRT7lRkSt12d8263e702f0u+4JnnRO8Qmv5nylWJebnqCHzyxP+6mLqw==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/rlp": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.0.9.tgz", - "integrity": "sha512-ns1U7ZMVeruUW6JXc4om+1w3w4ynHN/0fpwmeNTsAjwGKoF8SAUgue6ylKpHKWSti2idx7jDxbn8hNNFHk67CA==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.1.0.tgz", + "integrity": "sha512-vDTyHIwNPrecy55gKGZ47eJZhBm8LLBxihzi5ou+zrSvYTpkSTWRcKUlXFDFQVwfWB+P5PGyERAdiDEI76clxw==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/sha2": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.0.9.tgz", - "integrity": "sha512-5FH4s47gM7N1fFAYQ1+m7aX0SbLg0Xr+6tvqndmNqc382/qBIbzXiGlUookrsjlPb6gLNurnTssCXjNM72J6lQ==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.1.0.tgz", + "integrity": "sha512-+fNSeZRstOpdRJpdGUkRONFCaiAqWkc91zXgg76Nlp5ndBQE25Kk5yK8gCPG1aGnCrbariiPr5j9DmrYH78JCA==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", "hash.js": "1.1.3" }, "dependencies": { @@ -26129,116 +26130,117 @@ } }, "@ethersproject/signing-key": { - "version": "5.0.11", - "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.0.11.tgz", - "integrity": "sha512-Jfcru/BGwdkXhLxT+8WCZtFy7LL0TPFZw05FAb5asxB/MyVsEfNdNxGDtjVE9zXfmRSPe/EusXYY4K7wcygOyQ==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.1.0.tgz", + "integrity": "sha512-tE5LFlbmdObG8bY04NpuwPWSRPgEswfxweAI1sH7TbP0ml1elNfqcq7ii/3AvIN05i5U0Pkm3Tf8bramt8MmLw==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "bn.js": "^4.4.0", "elliptic": "6.5.4" } }, "@ethersproject/solidity": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.0.10.tgz", - "integrity": "sha512-8OG3HLqynWXDA6mVIHuHfF/ojTTwBahON7hc9GAKCqglzXCkVA3OpyxOJXPzjHClRIAUUiU7r9oy9Z/nsjtT/g==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.1.0.tgz", + "integrity": "sha512-kPodsGyo9zg1g9XSXp1lGhFaezBAUUsAUB1Vf6OkppE5Wksg4Et+x3kG4m7J/uShDMP2upkJtHNsIBK2XkVpKQ==", "dev": true, "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/sha2": "^5.0.7", - "@ethersproject/strings": "^5.0.8" + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/sha2": "^5.1.0", + "@ethersproject/strings": "^5.1.0" } }, "@ethersproject/strings": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.0.10.tgz", - "integrity": "sha512-KAeoS1tZ9/5ECXiIZA6S6hywbD0so2VmuW+Wfyo5EDXeyZ6Na1nxTPhTnW7voQmjbeYJffCrOc0qLFJeylyg7w==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.1.0.tgz", + "integrity": "sha512-perBZy0RrmmL0ejiFGUOlBVjMsUceqLut3OBP3zP96LhiJWWbS8u1NqQVgN4/Gyrbziuda66DxiQocXhsvx+Sw==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/logger": "^5.0.8" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/transactions": { - "version": "5.0.11", - "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.0.11.tgz", - "integrity": "sha512-ftsRvR9+gQp7L63F6+XmstvsZ4w8GtWvQB08e/zB+oB86Fnhq8+i/tkgpJplSHC8I/qgiCisva+M3u2GVhDFPA==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.1.1.tgz", + "integrity": "sha512-Nwgbp09ttIVN0OoUBatCXaHxR7grWPHbozJN8v7AXDLrl6nnOIBEMDh+yJTnosSQlFhcyjfTGGN+Mx6R8HdvMw==", "dev": true, "requires": { - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/rlp": "^5.0.7", - "@ethersproject/signing-key": "^5.0.8" + "@ethersproject/address": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/rlp": "^5.1.0", + "@ethersproject/signing-key": "^5.1.0" } }, "@ethersproject/units": { - "version": "5.0.11", - "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.0.11.tgz", - "integrity": "sha512-nOSPmcCWyB/dwoBRhhTtPGCsTbiXqmc7Q0Adwvafc432AC7hy3Fj3IFZtnSXsbtJ/GdHCIUIoA8gtvxSsFuBJg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.1.0.tgz", + "integrity": "sha512-isvJrx6qG0nKWfxsGORNjmOq/nh175fStfvRTA2xEKrGqx8JNJY83fswu4GkILowfriEM/eYpretfJnfzi7YhA==", "dev": true, "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/logger": "^5.0.8" + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/constants": "^5.1.0", + "@ethersproject/logger": "^5.1.0" } }, "@ethersproject/wallet": { - "version": "5.0.12", - "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.0.12.tgz", - "integrity": "sha512-rboJebGf47/KPZrKZQdYg9BAYuXbc/OwcUyML1K1f2jnJeo1ObWV11U1PAWTjTbhhSy6/Fg+34GO2yMb5Dt1Rw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.1.0.tgz", + "integrity": "sha512-ULmUtiYQLTUS+y3DgkLzRhFEK10zMwmjOthnjiZxee3Q/MVwr3rnmuAnXIUZrPjna6hvUPnyRIdW5XuF0Ld0YQ==", "dev": true, "requires": { - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/hash": "^5.0.10", - "@ethersproject/hdnode": "^5.0.8", - "@ethersproject/json-wallets": "^5.0.10", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/random": "^5.0.7", - "@ethersproject/signing-key": "^5.0.8", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/wordlists": "^5.0.8" + "@ethersproject/abstract-provider": "^5.1.0", + "@ethersproject/abstract-signer": "^5.1.0", + "@ethersproject/address": "^5.1.0", + "@ethersproject/bignumber": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/hash": "^5.1.0", + "@ethersproject/hdnode": "^5.1.0", + "@ethersproject/json-wallets": "^5.1.0", + "@ethersproject/keccak256": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/random": "^5.1.0", + "@ethersproject/signing-key": "^5.1.0", + "@ethersproject/transactions": "^5.1.0", + "@ethersproject/wordlists": "^5.1.0" } }, "@ethersproject/web": { - "version": "5.0.14", - "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.0.14.tgz", - "integrity": "sha512-QpTgplslwZ0Sp9oKNLoRuS6TKxnkwfaEk3gr7zd7XLF8XBsYejsrQO/03fNfnMx/TAT/RR6WEw/mbOwpRSeVRA==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.1.0.tgz", + "integrity": "sha512-LTeluWgTq04+RNqAkVhpydPcRZK/kKxD2Vy7PYGrAD27ABO9kTqTBKwiOuzTyAHKUQHfnvZbXmxBXJAGViSDcA==", "dev": true, "requires": { - "@ethersproject/base64": "^5.0.7", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" + "@ethersproject/base64": "^5.1.0", + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/strings": "^5.1.0" } }, "@ethersproject/wordlists": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.0.10.tgz", - "integrity": "sha512-jWsEm1iJzpg9SCXnNfFz+tcp4Ofzv0TJb6mj+soCNcar9GcT0yGz62ZsHC3pLQWaF4LkCzGwRJHJTXKjHQfG1A==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.1.0.tgz", + "integrity": "sha512-NsUCi/TpBb+oTFvMSccUkJGtp5o/84eOyqp5q5aBeiNBSLkYyw21znRn9mAmxZgySpxgruVgKbaapnYPgvctPQ==", "dev": true, "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/hash": "^5.0.10", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" + "@ethersproject/bytes": "^5.1.0", + "@ethersproject/hash": "^5.1.0", + "@ethersproject/logger": "^5.1.0", + "@ethersproject/properties": "^5.1.0", + "@ethersproject/strings": "^5.1.0" } }, "@nodelib/fs.scandir": { @@ -26603,6 +26605,24 @@ "integrity": "sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==", "dev": true }, + "@sinonjs/commons": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.3.tgz", + "integrity": "sha512-xkNcLAn/wZaX14RPlwizcKicDk9G3F8m2nU3L7Ukm5zBgTwiT0wsoFAHx9Jq56fJA1z/7uKGtCRu16sOUCLIHQ==", + "dev": true, + "requires": { + "type-detect": "4.0.8" + } + }, + "@sinonjs/fake-timers": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-7.0.5.tgz", + "integrity": "sha512-fUt6b15bjV/VW93UP5opNXJxdwZSbK1EdiwnhN7XrQrcpaOhMJpZ/CjwFpM3THpxwA+YviBUJKSuEqKlCK5alw==", + "dev": true, + "requires": { + "@sinonjs/commons": "^1.7.0" + } + }, "@solidity-parser/parser": { "version": "0.5.2", "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.5.2.tgz", @@ -26672,15 +26692,15 @@ } }, "@truffle/error": { - "version": "0.0.12", - "resolved": "https://registry.npmjs.org/@truffle/error/-/error-0.0.12.tgz", - "integrity": "sha512-kZqqnPR9YDJG7KCDOcN1qH16Qs0oz1PzF0Y93AWdhXuL9S9HYo/RUUeqGKbPpRBEZldQUS8aa4EzfK08u5pu6g==", + "version": "0.0.14", + "resolved": "https://registry.npmjs.org/@truffle/error/-/error-0.0.14.tgz", + "integrity": "sha512-utJx+SZYoMqk8wldQG4gCVKhV8GwMJbWY7sLXFT/D8wWZTnE2peX7URFJh/cxkjTRCO328z1s2qewkhyVsu2HA==", "dev": true }, "@truffle/interface-adapter": { - "version": "0.4.21", - "resolved": "https://registry.npmjs.org/@truffle/interface-adapter/-/interface-adapter-0.4.21.tgz", - "integrity": "sha512-uGU9T0a1S1f1xiTrNksd9ba+55SyU9jaCLNauFGOtppWDmjHD7dorxncEyj7lM9dcKl+w8Y+wHy79bb/LG4XFQ==", + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/@truffle/interface-adapter/-/interface-adapter-0.4.23.tgz", + "integrity": "sha512-mfpwY25Apx36WHHNJMNHWyDQVFZoZYNQ43rOwr/n+5gAMxke7+D7+IR9UW4kuO/Jp0+2848UxMdRV+oqm017kQ==", "dev": true, "requires": { "bn.js": "^5.1.3", @@ -26779,13 +26799,13 @@ } }, "@truffle/provider": { - "version": "0.2.28", - "resolved": "https://registry.npmjs.org/@truffle/provider/-/provider-0.2.28.tgz", - "integrity": "sha512-lowQkQPVSnn1jG3JIrp5iTDxkHZErjjjbLsvpI1kd8sYQ5LcGorgPQVsGlhM5BfYUQCeHLeFwwFb0ghx3hisKw==", + "version": "0.2.30", + "resolved": "https://registry.npmjs.org/@truffle/provider/-/provider-0.2.30.tgz", + "integrity": "sha512-5ScTbWsrm7zmQjw020T41U30/kYA1LppXAtaeucUGN2jvPrSwlh0aTL18makbqftTx1NRuYKw7C8wO4jCKQSUQ==", "dev": true, "requires": { - "@truffle/error": "^0.0.12", - "@truffle/interface-adapter": "^0.4.21", + "@truffle/error": "^0.0.14", + "@truffle/interface-adapter": "^0.4.23", "web3": "1.3.5" } }, @@ -26882,9 +26902,9 @@ } }, "@types/lodash": { - "version": "4.14.168", - "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.168.tgz", - "integrity": "sha512-oVfRvqHV/V6D1yifJbVRU3TMp8OT6o6BG+U9MkwuJ3U8/CsDHvalRpsxBqivn71ztOFZBTfJMvETbqHiaNSj7Q==", + "version": "4.14.169", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.169.tgz", + "integrity": "sha512-DvmZHoHTFJ8zhVYwCLWbQ7uAbYQEk52Ev2/ZiQ7Y7gQGeV9pjBqjnQpECMHfKS1rCYAhMI7LHVxwyZLZinJgdw==", "dev": true }, "@types/lowdb": { @@ -26903,9 +26923,9 @@ "dev": true }, "@types/minimatch": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.3.tgz", - "integrity": "sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==", + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==", "dev": true }, "@types/mkdirp": { @@ -26930,9 +26950,9 @@ "dev": true }, "@types/node-fetch": { - "version": "2.5.8", - "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.8.tgz", - "integrity": "sha512-fbjI6ja0N5ZA8TV53RUqzsKNkl9fv8Oj3T7zxW7FGv1GSH7gwJaNF8dzCjrqKaxKeUpTz4yT1DaJFq/omNpGfw==", + "version": "2.5.10", + "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.5.10.tgz", + "integrity": "sha512-IpkX0AasN44hgEad0gEF/V6EgR5n69VEqPEgnmoM8GsIGro3PowbWs4tR6IhxUTyPLpOn+fiGG6nrQhcmoCuIQ==", "dev": true, "requires": { "@types/node": "*", @@ -26989,21 +27009,21 @@ } }, "@types/secp256k1": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.1.tgz", - "integrity": "sha512-+ZjSA8ELlOp8SlKi0YLB2tz9d5iPNEmOBd+8Rz21wTMdaXQIa9b6TEnD6l5qKOCypE7FSyPyck12qZJxSDNoog==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.2.tgz", + "integrity": "sha512-QMg+9v0bbNJ2peLuHRWxzmy0HRJIG6gFZNhaRSp7S3ggSbCCxiqQB2/ybvhXyhHOCequpNkrx7OavNhrWOsW0A==", "dev": true, "requires": { "@types/node": "*" } }, "@types/sinon": { - "version": "9.0.11", - "resolved": "https://registry.npmjs.org/@types/sinon/-/sinon-9.0.11.tgz", - "integrity": "sha512-PwP4UY33SeeVKodNE37ZlOsR9cReypbMJOhZ7BVE0lB+Hix3efCOxiJWiE5Ia+yL9Cn2Ch72EjFTRze8RZsNtg==", + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/@types/sinon/-/sinon-10.0.0.tgz", + "integrity": "sha512-jDZ55oCKxqlDmoTBBbBBEx+N8ZraUVhggMZ9T5t+6/Dh8/4NiOjSUfpLrPiEwxQDlAe3wpAkoXhWvE6LibtsMQ==", "dev": true, "requires": { - "@types/sinonjs__fake-timers": "*" + "@sinonjs/fake-timers": "^7.0.4" } }, "@types/sinon-chai": { @@ -27016,16 +27036,10 @@ "@types/sinon": "*" } }, - "@types/sinonjs__fake-timers": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-6.0.2.tgz", - "integrity": "sha512-dIPoZ3g5gcx9zZEszaxLSVTvMReD3xxyyDnQUjA6IYDG9Ba2AV0otMPs+77sG9ojB4Qr2N2Vk5RnKeuA0X/0bg==", - "dev": true - }, "@types/underscore": { - "version": "1.11.0", - "resolved": "https://registry.npmjs.org/@types/underscore/-/underscore-1.11.0.tgz", - "integrity": "sha512-ipNAQLgRnG0EWN1cTtfdVHp5AyTW/PAMJ1PxLN4bAKSHbusSZbj48mIHiydQpN7GgQrYqwfnvZ573OVfJm5Nzg==", + "version": "1.11.2", + "resolved": "https://registry.npmjs.org/@types/underscore/-/underscore-1.11.2.tgz", + "integrity": "sha512-Ls2ylbo7++ITrWk2Yc3G/jijwSq5V3GT0tlgVXEl2kKYXY3ImrtmTCoE2uyTWFRI5owMBriloZFWbE1SXOsE7w==", "dev": true }, "@types/web3": { @@ -27125,6 +27139,38 @@ "uri-js": "^4.2.2" } }, + "amazon-cognito-identity-js": { + "version": "4.6.3", + "resolved": "https://registry.npmjs.org/amazon-cognito-identity-js/-/amazon-cognito-identity-js-4.6.3.tgz", + "integrity": "sha512-MPVJfirbdmSGo7l4h7Kbn3ms1eJXT5Xq8ly+mCPPi8yAxaxdg7ouMUUNTqtDykoZxIdDLF/P6F3Zbg3dlGKOWg==", + "dev": true, + "requires": { + "buffer": "4.9.2", + "crypto-js": "^4.0.0", + "fast-base64-decode": "^1.0.0", + "isomorphic-unfetch": "^3.0.0", + "js-cookie": "^2.2.1" + }, + "dependencies": { + "buffer": { + "version": "4.9.2", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.2.tgz", + "integrity": "sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg==", + "dev": true, + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + } + } + }, "amdefine": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", @@ -27139,12 +27185,12 @@ "dev": true }, "ansi-escapes": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz", - "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==", + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", "dev": true, "requires": { - "type-fest": "^0.11.0" + "type-fest": "^0.21.3" } }, "ansi-regex": { @@ -27163,9 +27209,9 @@ } }, "anymatch": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", - "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", + "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", "dev": true, "requires": { "normalize-path": "^3.0.0", @@ -27354,9 +27400,9 @@ "integrity": "sha512-csSsuMyZj1dv1fL0zRPnDAHWrmlISMvK+wx9WJI/igRVDT4VMgbf2AVenaHghFLfI1nQijXUevYEguYV6u5hjA==" }, "balanced-match": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", - "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" }, "base-x": { "version": "3.0.8", @@ -28237,9 +28283,9 @@ "dev": true }, "core-js-pure": { - "version": "3.9.1", - "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.9.1.tgz", - "integrity": "sha512-laz3Zx0avrw9a4QEIdmIblnVuJz8W51leY9iLThatCsFawWxC3sE4guASC78JbCin+DkwMpCdp1AVAuzL/GN7A==", + "version": "3.12.1", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.12.1.tgz", + "integrity": "sha512-1cch+qads4JnDSWsvc7d6nzlKAippwjUlf6vykkTLW53VSV+NkE6muGBToAjEA8pG90cSfcud3JgVmW2ds5TaQ==", "dev": true }, "core-util-is": { @@ -28384,6 +28430,12 @@ "randomfill": "^1.0.3" } }, + "crypto-js": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.0.0.tgz", + "integrity": "sha512-bzHZN8Pn+gS7DQA6n+iUmBfl0hO5DJq++QP3U6uTucDtk/0iGpXd/Gg7CGR0p8tJhofJyaKoWBuJI4eAO00BBg==", + "dev": true + }, "d": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz", @@ -28579,6 +28631,101 @@ "integrity": "sha512-R9hc1Xa/NOBi9WRVUWg19rl1UB7Tt4kuPd+thNJgFZoxXsTz7ncaPaeIm+40oSGuP33DfMb4sZt1QIGiJzC4EA==", "dev": true }, + "defender-base-client": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/defender-base-client/-/defender-base-client-1.7.0.tgz", + "integrity": "sha512-snNyKtxUZn8y0JewVAQDJUam1qESFnkJiOUNtutB07OzldUoA7R/n/xuu5LyM3z4ScvoXu6xeVe67xs2H60KKg==", + "dev": true, + "requires": { + "amazon-cognito-identity-js": "^4.3.3", + "axios": "^0.19.2", + "lodash": "^4.17.19", + "node-fetch": "^2.6.0" + }, + "dependencies": { + "axios": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.19.2.tgz", + "integrity": "sha512-fjgm5MvRHLhx+osE2xoekY70AhARk3a6hkN+3Io1jc00jtquGvxYlKlsFUhmUET0V5te6CcZI7lcv2Ym61mjHA==", + "dev": true, + "requires": { + "follow-redirects": "1.5.10" + } + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "follow-redirects": { + "version": "1.5.10", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.5.10.tgz", + "integrity": "sha512-0V5l4Cizzvqt5D44aTXbFZz+FtyXV1vrDN6qrelxtfYQKW0KO0W2T/hkE8xvGa/540LkZlkaUjO4ailYTFtHVQ==", + "dev": true, + "requires": { + "debug": "=3.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, + "defender-relay-client": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/defender-relay-client/-/defender-relay-client-1.7.0.tgz", + "integrity": "sha512-NYHP0sW/IusDPMMxSxo7DG6mfTs6/up4AFhW5ww7l9uwszzxc5rhvCCfqHCeB9FrqkoX5G1DdDkHWHdSVwANVA==", + "dev": true, + "requires": { + "amazon-cognito-identity-js": "^4.3.3", + "axios": "^0.19.2", + "defender-base-client": "^1.7.0", + "lodash": "^4.17.19", + "node-fetch": "^2.6.0" + }, + "dependencies": { + "axios": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.19.2.tgz", + "integrity": "sha512-fjgm5MvRHLhx+osE2xoekY70AhARk3a6hkN+3Io1jc00jtquGvxYlKlsFUhmUET0V5te6CcZI7lcv2Ym61mjHA==", + "dev": true, + "requires": { + "follow-redirects": "1.5.10" + } + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "follow-redirects": { + "version": "1.5.10", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.5.10.tgz", + "integrity": "sha512-0V5l4Cizzvqt5D44aTXbFZz+FtyXV1vrDN6qrelxtfYQKW0KO0W2T/hkE8xvGa/540LkZlkaUjO4ailYTFtHVQ==", + "dev": true, + "requires": { + "debug": "=3.1.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } + } + }, "defer-to-connect": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz", @@ -28713,9 +28860,9 @@ "dev": true }, "dotenv": { - "version": "8.2.0", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.2.0.tgz", - "integrity": "sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw==", + "version": "8.6.0", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.6.0.tgz", + "integrity": "sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==", "dev": true }, "download": { @@ -29082,9 +29229,9 @@ }, "dependencies": { "@solidity-parser/parser": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.0.tgz", - "integrity": "sha512-DT3f/Aa4tQysZwUsuqBwvr8YRJzKkvPUKV/9o2/o5EVw3xqlbzmtx4O60lTUcZdCawL+N8bBLNUyOGpHjGlJVQ==", + "version": "0.12.2", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.2.tgz", + "integrity": "sha512-d7VS7PxgMosm5NyaiyDJRNID5pK4AWj1l64Dbz0147hJgy5k2C0/ZiKK/9u5c5K+HRUVHmp+RMvGEjGh84oA5Q==", "dev": true }, "ethereumjs-util": { @@ -29582,41 +29729,41 @@ } }, "ethers": { - "version": "5.0.32", - "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.0.32.tgz", - "integrity": "sha512-rORfGWR0HsA4pjKMMcWZorw12DHsXqfIAuPVHJsXt+vI24jvXcVqx+rLsSvgOoLdaCMdxiN5qlIq2+4axKG31g==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.1.4.tgz", + "integrity": "sha512-EAPQ/fgGRu0PoR/VNFnHTMOtG/IZ0AItdW55C9T8ffmVu0rnyllZL404eBF66elJehOLz2kxnUrhXpE7TCpW7g==", "dev": true, "requires": { - "@ethersproject/abi": "5.0.13", - "@ethersproject/abstract-provider": "5.0.10", - "@ethersproject/abstract-signer": "5.0.14", - "@ethersproject/address": "5.0.11", - "@ethersproject/base64": "5.0.9", - "@ethersproject/basex": "5.0.9", - "@ethersproject/bignumber": "5.0.15", - "@ethersproject/bytes": "5.0.11", - "@ethersproject/constants": "5.0.10", - "@ethersproject/contracts": "5.0.12", - "@ethersproject/hash": "5.0.12", - "@ethersproject/hdnode": "5.0.10", - "@ethersproject/json-wallets": "5.0.12", - "@ethersproject/keccak256": "5.0.9", - "@ethersproject/logger": "5.0.10", - "@ethersproject/networks": "5.0.9", - "@ethersproject/pbkdf2": "5.0.9", - "@ethersproject/properties": "5.0.9", - "@ethersproject/providers": "5.0.24", - "@ethersproject/random": "5.0.9", - "@ethersproject/rlp": "5.0.9", - "@ethersproject/sha2": "5.0.9", - "@ethersproject/signing-key": "5.0.11", - "@ethersproject/solidity": "5.0.10", - "@ethersproject/strings": "5.0.10", - "@ethersproject/transactions": "5.0.11", - "@ethersproject/units": "5.0.11", - "@ethersproject/wallet": "5.0.12", - "@ethersproject/web": "5.0.14", - "@ethersproject/wordlists": "5.0.10" + "@ethersproject/abi": "5.1.2", + "@ethersproject/abstract-provider": "5.1.0", + "@ethersproject/abstract-signer": "5.1.0", + "@ethersproject/address": "5.1.0", + "@ethersproject/base64": "5.1.0", + "@ethersproject/basex": "5.1.0", + "@ethersproject/bignumber": "5.1.1", + "@ethersproject/bytes": "5.1.0", + "@ethersproject/constants": "5.1.0", + "@ethersproject/contracts": "5.1.1", + "@ethersproject/hash": "5.1.0", + "@ethersproject/hdnode": "5.1.0", + "@ethersproject/json-wallets": "5.1.0", + "@ethersproject/keccak256": "5.1.0", + "@ethersproject/logger": "5.1.0", + "@ethersproject/networks": "5.1.0", + "@ethersproject/pbkdf2": "5.1.0", + "@ethersproject/properties": "5.1.0", + "@ethersproject/providers": "5.1.2", + "@ethersproject/random": "5.1.0", + "@ethersproject/rlp": "5.1.0", + "@ethersproject/sha2": "5.1.0", + "@ethersproject/signing-key": "5.1.0", + "@ethersproject/solidity": "5.1.0", + "@ethersproject/strings": "5.1.0", + "@ethersproject/transactions": "5.1.1", + "@ethersproject/units": "5.1.0", + "@ethersproject/wallet": "5.1.0", + "@ethersproject/web": "5.1.0", + "@ethersproject/wordlists": "5.1.0" } }, "ethjs-unit": { @@ -29886,6 +30033,12 @@ "checkpoint-store": "^1.1.0" } }, + "fast-base64-decode": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-base64-decode/-/fast-base64-decode-1.0.0.tgz", + "integrity": "sha512-qwaScUgUGBYeDNRnbc/KyllVU88Jk1pRHPStuF/lO7B0/RTRLj7U0lkdTAutlBblY08rwZDff6tNU9cjv6j//Q==", + "dev": true + }, "fast-deep-equal": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", @@ -30076,9 +30229,9 @@ "dev": true }, "follow-redirects": { - "version": "1.13.3", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.13.3.tgz", - "integrity": "sha512-DUgl6+HDzB0iEptNQEXLx/KhTmDb8tZUHSeLqpnjpknR70H0nC2t9N73BK6fN4hOvJ84pKlIQVQ4k5FFlBedKA==", + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz", + "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==", "dev": true }, "for-each": { @@ -32674,9 +32827,9 @@ }, "dependencies": { "bn.js": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.0.tgz", - "integrity": "sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.1.3.tgz", + "integrity": "sha512-GkTiFpjFtUzU9CbMeJ5iazkCzGL3jrhzerzZIuqLABjbwRaFt33I9tUdSNryIptM+RxDet6OKm2WnLXzW51KsQ==", "dev": true, "optional": true } @@ -37789,40 +37942,22 @@ }, "dependencies": { "es-abstract": { - "version": "1.18.0", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.18.0.tgz", - "integrity": "sha512-LJzK7MrQa8TS0ja2w3YNLzUgJCGPdPOV1yVvezjNnS89D+VR08+Szt2mz3YB2Dck/+w5tfIq/RoUAFqJJGM2yw==", + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.7.tgz", + "integrity": "sha512-VBl/gnfcJ7OercKA9MVaegWsBHFjV492syMudcnQZvt/Dw8ezpcOHYZXa/J96O8vx+g4x65YKhxOwDUh63aS5g==", "dev": true, "requires": { - "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", "function-bind": "^1.1.1", - "get-intrinsic": "^1.1.1", "has": "^1.0.3", - "has-symbols": "^1.0.2", - "is-callable": "^1.2.3", - "is-negative-zero": "^2.0.1", - "is-regex": "^1.1.2", - "is-string": "^1.0.5", - "object-inspect": "^1.9.0", + "has-symbols": "^1.0.1", + "is-callable": "^1.2.2", + "is-regex": "^1.1.1", + "object-inspect": "^1.8.0", "object-keys": "^1.1.1", - "object.assign": "^4.1.2", - "string.prototype.trimend": "^1.0.4", - "string.prototype.trimstart": "^1.0.4", - "unbox-primitive": "^1.0.0" - }, - "dependencies": { - "get-intrinsic": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", - "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", - "dev": true, - "requires": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1" - } - } + "object.assign": "^4.1.1", + "string.prototype.trimend": "^1.0.1", + "string.prototype.trimstart": "^1.0.1" } } } @@ -40167,9 +40302,9 @@ } }, "glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", @@ -40308,9 +40443,9 @@ } }, "hardhat": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.2.1.tgz", - "integrity": "sha512-8s7MtGXdh0NDwQKdlA8m8QdloVIN1+hv5aFpn0G5Ljj9vfNY9kUoc0a9pMboeGbd9WrS+XrZs5YlsPgQjaW/Tg==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.3.0.tgz", + "integrity": "sha512-nc4ro2bM4wPaA6/0Y22o5F5QrifQk2KCyPUUKLPUeFFZoGNGYB8vmeW/k9gV9DdMukdWTzfYlKc2Jn4bfb6tDQ==", "dev": true, "requires": { "@ethereumjs/block": "^3.2.1", @@ -40753,9 +40888,9 @@ } }, "hosted-git-info": { - "version": "2.8.8", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz", - "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==", + "version": "2.8.9", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", + "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", "dev": true }, "http-basic": { @@ -40805,9 +40940,9 @@ }, "dependencies": { "@types/node": { - "version": "10.17.55", - "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.55.tgz", - "integrity": "sha512-koZJ89uLZufDvToeWO5BrC4CR4OUfHnUz2qoPs/daQH6qq3IN62QFxCTZ+bKaCE0xaoCAJYE4AXre8AbghCrhg==", + "version": "10.17.60", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz", + "integrity": "sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==", "dev": true } } @@ -40861,9 +40996,9 @@ } }, "chalk": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz", - "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.1.tgz", + "integrity": "sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==", "dev": true, "requires": { "ansi-styles": "^4.1.0", @@ -41035,9 +41170,9 @@ "dev": true }, "is-bigint": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.1.tgz", - "integrity": "sha512-J0ELF4yHFxHy0cmSxZuheDOz2luOdVvqjwmEcj8H/L1JHeuEDSDbeRP+Dk9kFVk5RTFzbucJ2Kb9F7ixY2QaCg==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.2.tgz", + "integrity": "sha512-0JV5+SOCQkIdzjBK9buARcV804Ddu7A0Qet6sHi3FimE9ne6m4BGQZfRn+NZiXbBk4F4XmHfDZIipLj9pX8dSA==", "dev": true }, "is-binary-path": { @@ -41050,12 +41185,12 @@ } }, "is-boolean-object": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.0.tgz", - "integrity": "sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.1.tgz", + "integrity": "sha512-bXdQWkECBUIAcCkeH1unwJLIpZYaa5VvuygSyS/c2lf719mTKZDU5UdDRlpd01UjADgmW8RfqaP+mRaVPdr/Ng==", "dev": true, "requires": { - "call-bind": "^1.0.0" + "call-bind": "^1.0.2" } }, "is-buffer": { @@ -41080,24 +41215,24 @@ } }, "is-core-module": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz", - "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==", + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.4.0.tgz", + "integrity": "sha512-6A2fkfq1rfeQZjxrZJGerpLCTHRNEBiSgnu0+obeJpEPZRUooHgsizvzv0ZjJwOz3iWIHdJtVWJ/tmPr3D21/A==", "dev": true, "requires": { "has": "^1.0.3" } }, "is-date-object": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz", - "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.4.tgz", + "integrity": "sha512-/b4ZVsG7Z5XVtIxs/h9W8nvfLgSAyKYdtGWQLbqy6jA1icmgjf8WCoTKgeS4wy5tYaPePouzFMANbnj94c2Z+A==", "dev": true }, "is-docker": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.1.1.tgz", - "integrity": "sha512-ZOoqiXfEwtGknTiuDEy8pN2CfE3TxMHprvNer1mXiqwkOT77Rw3YVrUQ52EqAOU3QAWDQ+bQdx7HJzrv7LS2Hw==", + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz", + "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==", "dev": true }, "is-extglob": { @@ -41119,9 +41254,9 @@ "dev": true }, "is-generator-function": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.8.tgz", - "integrity": "sha512-2Omr/twNtufVZFr1GhxjOMFPAj2sjc/dKaIqBhvo4qciXfJmITGH6ZGd8eZYNHza8t1y0e01AuqRhJwfWp26WQ==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.9.tgz", + "integrity": "sha512-ZJ34p1uvIfptHCN7sFTjGibB9/oBg17sHqzDLfuwhvmN/qLVvIQXRQ8licZQ35WJ8KuEQt/etnnzQFI9C9Ue/A==", "dev": true }, "is-glob": { @@ -41168,9 +41303,9 @@ "dev": true }, "is-number-object": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.4.tgz", - "integrity": "sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.5.tgz", + "integrity": "sha512-RU0lI/n95pMoUKu9v1BZP5MBcZuNSVJkMkAG2dJqC4z2GlkGUNeH68SuHuBKBD/XFe+LHZ+f9BKkLET60Niedw==", "dev": true }, "is-object": { @@ -41201,13 +41336,13 @@ "dev": true }, "is-regex": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.2.tgz", - "integrity": "sha512-axvdhb5pdhEVThqJzYXwMlVuZwC+FF2DpcOhTS+y/8jVq4trxyPgfcwIxIKiyeuLlSQYKkmUaPQJ8ZE4yNKXDg==", + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.3.tgz", + "integrity": "sha512-qSVXFz28HM7y+IWX6vLCsexdlvzT1PJNFSBuaQLQ5o0IEw8UDYW6/2+eCMVyIsbM8CNLX2a/QWmSpyxYEHY7CQ==", "dev": true, "requires": { "call-bind": "^1.0.2", - "has-symbols": "^1.0.1" + "has-symbols": "^1.0.2" } }, "is-retry-allowed": { @@ -41223,18 +41358,18 @@ "dev": true }, "is-string": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz", - "integrity": "sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==", + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.6.tgz", + "integrity": "sha512-2gdzbKUuqtQ3lYNrUTQYoClPhm7oQu4UdpSZMp1/DGgkHBT8E2Z1l0yMdb6D4zNAxwDiMv8MdulKROJGNl0Q0w==", "dev": true }, "is-symbol": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz", - "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", "dev": true, "requires": { - "has-symbols": "^1.0.1" + "has-symbols": "^1.0.2" } }, "is-typed-array": { @@ -41289,6 +41424,16 @@ "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", "dev": true }, + "isomorphic-unfetch": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/isomorphic-unfetch/-/isomorphic-unfetch-3.1.0.tgz", + "integrity": "sha512-geDJjpoZ8N0kWexiwkX8F9NkTsXhetLPVbZFQ+JTW239QNOwvB0gniuR1Wc6f0AMTn7/mFGyXvHTifrCp/GH8Q==", + "dev": true, + "requires": { + "node-fetch": "^2.6.1", + "unfetch": "^4.2.0" + } + }, "isstream": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", @@ -41311,6 +41456,12 @@ "integrity": "sha512-5IZ7sY9dBAYSV+YjQ0Ovb540Ku7AO9Z5o2Cg789xj167iQuZ2cG+z0f3Uct6WeYLbU6aQiM2pCs7sZ+4dotydw==", "dev": true }, + "js-cookie": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/js-cookie/-/js-cookie-2.2.1.tgz", + "integrity": "sha512-HvdH2LzI/EAZcUwA8+0nKNtWHqS+ZmijLA30RwZA0bo7ToCckjK5MkGhjED9KoRcXO6BaGI3I9UIzSA1FKFPOQ==", + "dev": true + }, "js-sha3": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", @@ -41877,9 +42028,9 @@ "dev": true }, "mcl-wasm": { - "version": "0.7.6", - "resolved": "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.6.tgz", - "integrity": "sha512-cbRl3sUOkBeRY2hsM4t1EIln2TIdQBkSiTOqNTv/4Hu5KOECnMWCgjIf+a9Ebunyn22VKqkMF3zj6ejRzz7YBw==", + "version": "0.7.7", + "resolved": "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.7.tgz", + "integrity": "sha512-jDGiCQA++5hX37gdH6RDZ3ZsA0raet7xyY/R5itj5cbcdf4Gvw+YyxWX/ZZ0Z2UPxJiw1ktRsCJZzpnqlQILdw==", "dev": true }, "md5.js": { @@ -42062,13 +42213,13 @@ "dev": true }, "micromatch": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz", - "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz", + "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==", "dev": true, "requires": { "braces": "^3.0.1", - "picomatch": "^2.0.5" + "picomatch": "^2.2.3" } }, "miller-rabin": { @@ -42088,18 +42239,18 @@ "dev": true }, "mime-db": { - "version": "1.46.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.46.0.tgz", - "integrity": "sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==", + "version": "1.47.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.47.0.tgz", + "integrity": "sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw==", "dev": true }, "mime-types": { - "version": "2.1.29", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.29.tgz", - "integrity": "sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==", + "version": "2.1.30", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.30.tgz", + "integrity": "sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg==", "dev": true, "requires": { - "mime-db": "1.46.0" + "mime-db": "1.47.0" } }, "mimic-fn": { @@ -42647,9 +42798,9 @@ "dev": true }, "object-inspect": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.9.0.tgz", - "integrity": "sha512-i3Bp9iTqwhaLZBxGkRfo5ZbE07BQRT7MGu8+nNgwW9ItGp1TzCTw2DLEoWwjClxBjOFI/hWljTAmYGCEwmtnOw==", + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.10.3.tgz", + "integrity": "sha512-e5mCJlSH7poANfC8z8S9s9S2IN5/4Zb3aZ33f5s8YqoazCFzNLloLU8r5VCG+G7WoqLvAAZoVMcy3tp/3X0Plw==", "dev": true }, "object-keys": { @@ -43004,9 +43155,9 @@ "dev": true }, "pbkdf2": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.1.tgz", - "integrity": "sha512-4Ejy1OPxi9f2tt1rRV7Go7zmfDQ+ZectEQz3VGUQhgq62HtIRPDyG/JtnwIxs6x3uNMwo2V7q1fMvKjb+Tnpqg==", + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz", + "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==", "dev": true, "requires": { "create-hash": "^1.1.2", @@ -43029,9 +43180,9 @@ "dev": true }, "picomatch": { - "version": "2.2.2", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz", - "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==", + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.3.tgz", + "integrity": "sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg==", "dev": true }, "pify": { @@ -43137,31 +43288,31 @@ "dev": true }, "prettier": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.2.1.tgz", - "integrity": "sha512-PqyhM2yCjg/oKkFPtTGUojv7gnZAoG80ttl45O6x2Ug/rMJw4wcc9k6aaf2hibP7BGVCCM33gZoGjyvt9mm16Q==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.3.0.tgz", + "integrity": "sha512-kXtO4s0Lz/DW/IJ9QdWhAf7/NmPWQXkFr/r/WkR3vyI+0v8amTDxiaQSLzs8NBlytfLWX/7uQUMIW677yLKl4w==", "dev": true }, "prettier-plugin-solidity": { - "version": "1.0.0-beta.6", - "resolved": "https://registry.npmjs.org/prettier-plugin-solidity/-/prettier-plugin-solidity-1.0.0-beta.6.tgz", - "integrity": "sha512-WymLqd22Hl93t5+HDNLk08TAWp4i4vZMhpihuVqkwOApjCT7mH1qwhLtvf3m+NdU//qj8vrPDmMoT+xc74skcg==", + "version": "1.0.0-beta.10", + "resolved": "https://registry.npmjs.org/prettier-plugin-solidity/-/prettier-plugin-solidity-1.0.0-beta.10.tgz", + "integrity": "sha512-55UsEbeJfqYKB3RFR7Nvpi+ApEoUfgdKHVg2ZybrbOkRW4RTblyONLL3mEr8Vrxpo7wBbObVLbWodGg4YXIQ7g==", "dev": true, "requires": { - "@solidity-parser/parser": "^0.12.0", + "@solidity-parser/parser": "^0.12.1", "dir-to-object": "^2.0.0", - "emoji-regex": "^9.2.1", + "emoji-regex": "^9.2.2", "escape-string-regexp": "^4.0.0", "prettier": "^2.2.1", - "semver": "^7.3.4", - "solidity-comments-extractor": "^0.0.4", - "string-width": "^4.2.0" + "semver": "^7.3.5", + "solidity-comments-extractor": "^0.0.7", + "string-width": "^4.2.2" }, "dependencies": { "@solidity-parser/parser": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.0.tgz", - "integrity": "sha512-DT3f/Aa4tQysZwUsuqBwvr8YRJzKkvPUKV/9o2/o5EVw3xqlbzmtx4O60lTUcZdCawL+N8bBLNUyOGpHjGlJVQ==", + "version": "0.12.2", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.2.tgz", + "integrity": "sha512-d7VS7PxgMosm5NyaiyDJRNID5pK4AWj1l64Dbz0147hJgy5k2C0/ZiKK/9u5c5K+HRUVHmp+RMvGEjGh84oA5Q==", "dev": true }, "ansi-regex": { @@ -43198,9 +43349,9 @@ } }, "semver": { - "version": "7.3.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz", - "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==", + "version": "7.3.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz", + "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==", "dev": true, "requires": { "lru-cache": "^6.0.0" @@ -44090,9 +44241,9 @@ } }, "solidity-comments-extractor": { - "version": "0.0.4", - "resolved": "https://registry.npmjs.org/solidity-comments-extractor/-/solidity-comments-extractor-0.0.4.tgz", - "integrity": "sha512-58glBODwXIKMaQ7rfcJOrWtFQMMOK28tJ0/LcB5Xhu7WtAxk4UX2fpgKPuaL41XjMp/y0gAa1MTLqk018wuSzA==", + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/solidity-comments-extractor/-/solidity-comments-extractor-0.0.7.tgz", + "integrity": "sha512-wciNMLg/Irp8OKGrh3S2tfvZiZ0NEyILfcRCXCD4mp7SgK/i9gzLfhY2hY7VMCQJ3kH9UB9BzNdibIVMchzyYw==", "dev": true }, "solidity-coverage": { @@ -44123,9 +44274,9 @@ }, "dependencies": { "@solidity-parser/parser": { - "version": "0.12.1", - "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.1.tgz", - "integrity": "sha512-ikxVpwskNxEp2fvYS1BdRImnevHmM97zdPFBa1cVtjtNpoqCm/EmljATTZk0s9G/zsN5ZbPf9OAIAW4gbBJiRA==", + "version": "0.12.2", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.12.2.tgz", + "integrity": "sha512-d7VS7PxgMosm5NyaiyDJRNID5pK4AWj1l64Dbz0147hJgy5k2C0/ZiKK/9u5c5K+HRUVHmp+RMvGEjGh84oA5Q==", "dev": true }, "fs-extra": { @@ -44248,9 +44399,9 @@ } }, "spdx-license-ids": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.7.tgz", - "integrity": "sha512-U+MTEOO0AiDzxwFvoa4JVnMV6mZlJKk2sBLt90s7G0Gd0Mlknc7kxEn3nuDPNZRta7O2uy8oLcZLVT+4sqNZHQ==", + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.8.tgz", + "integrity": "sha512-NDgA96EnaLSvtbM7trJj+t1LUR3pirkDCcz9nOUlPb5DMBGsH7oES6C3hs3j7R9oHEa1EMvReS/BUAIT5Tcr0g==", "dev": true }, "sprintf-js": { @@ -44967,9 +45118,9 @@ "dev": true }, "type-fest": { - "version": "0.11.0", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz", - "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==", + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", "dev": true }, "type-is": { @@ -45021,9 +45172,9 @@ } }, "typescript": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.3.tgz", - "integrity": "sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==", + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz", + "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==", "dev": true }, "typical": { @@ -45033,9 +45184,9 @@ "dev": true }, "uglify-js": { - "version": "3.13.4", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.13.4.tgz", - "integrity": "sha512-kv7fCkIXyQIilD5/yQy8O+uagsYIOt5cZvs890W40/e/rvjMSzJw81o9Bg0tkURxzZBROtDQhW2LFjOGoK3RZw==", + "version": "3.13.6", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.13.6.tgz", + "integrity": "sha512-rRprLwl8RVaS+Qvx3Wh5hPfPBn9++G6xkGlUupya0s5aDmNjI7z3lnRLB3u7sN4OmbB0pWgzhM9BEJyiWAwtAA==", "dev": true, "optional": true }, @@ -45046,15 +45197,15 @@ "dev": true }, "unbox-primitive": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.0.tgz", - "integrity": "sha512-P/51NX+JXyxK/aigg1/ZgyccdAxm5K1+n8+tvqSntjOivPt19gvm1VC49RWYetsiub8WViUchdxl/KWHHB0kzA==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.1.tgz", + "integrity": "sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==", "dev": true, "requires": { "function-bind": "^1.1.1", - "has-bigints": "^1.0.0", - "has-symbols": "^1.0.0", - "which-boxed-primitive": "^1.0.1" + "has-bigints": "^1.0.1", + "has-symbols": "^1.0.2", + "which-boxed-primitive": "^1.0.2" } }, "unbzip2-stream": { @@ -45068,9 +45219,15 @@ } }, "underscore": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", - "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.12.1.tgz", + "integrity": "sha512-hEQt0+ZLDVUMhebKxL4x1BTtDY7bavVofhZ9KZ4aI26X9SRaE+Y3m83XUL1UP2jn8ynjndwCCpEHdUG+9pP1Tw==", + "dev": true + }, + "unfetch": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/unfetch/-/unfetch-4.2.0.tgz", + "integrity": "sha512-F9p7yYCn6cIW9El1zi0HI6vqpeIvBsr3dSuRO6Xuppb1u5rXpCPmMvLSyECLhybr9isec8Ohl0hPekMVrEinDA==", "dev": true }, "universalify": { @@ -45134,9 +45291,9 @@ "dev": true }, "utf-8-validate": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.4.tgz", - "integrity": "sha512-MEF05cPSq3AwJ2C7B7sHAA6i53vONoZbMGX8My5auEVm6W+dJ2Jd/TZPyGJ5CH42V2XtbI5FD28HeHeqlPzZ3Q==", + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.5.tgz", + "integrity": "sha512-+pnxRYsS/axEpkrrEpzYfNZGXp0IjC/9RIxwM5gntY4Koi8SHmUGSfxfWqxZdRxrtaoVstuOzUp/rbs3JSPELQ==", "dev": true, "requires": { "node-gyp-build": "^4.2.0" @@ -45241,6 +45398,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45278,9 +45441,9 @@ "dev": true }, "@types/node": { - "version": "12.20.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.10.tgz", - "integrity": "sha512-TxCmnSSppKBBOzYzPR2BR25YlX5Oay8z2XGwFBInuA/Co0V9xJhLlW4kjbxKtgeNo3NOMbQP1A5Rc03y+XecPw==", + "version": "12.20.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.13.tgz", + "integrity": "sha512-1x8W5OpxPq+T85OUsHRP6BqXeosKmeXRtjoF39STcdf/UWLqUsoehstZKOi0CunhVqHG17AyZgpj20eRVooK6A==", "dev": true }, "cacheable-request": { @@ -45360,6 +45523,12 @@ "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz", "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==", "dev": true + }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true } } }, @@ -45379,9 +45548,15 @@ }, "dependencies": { "@types/node": { - "version": "12.20.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.10.tgz", - "integrity": "sha512-TxCmnSSppKBBOzYzPR2BR25YlX5Oay8z2XGwFBInuA/Co0V9xJhLlW4kjbxKtgeNo3NOMbQP1A5Rc03y+XecPw==", + "version": "12.20.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.13.tgz", + "integrity": "sha512-1x8W5OpxPq+T85OUsHRP6BqXeosKmeXRtjoF39STcdf/UWLqUsoehstZKOi0CunhVqHG17AyZgpj20eRVooK6A==", + "dev": true + }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", "dev": true }, "web3-utils": { @@ -45413,6 +45588,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45445,6 +45626,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45484,6 +45671,14 @@ "web3-providers-http": "1.3.5", "web3-providers-ipc": "1.3.5", "web3-providers-ws": "1.3.5" + }, + "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + } } }, "web3-core-subscriptions": { @@ -45495,6 +45690,14 @@ "eventemitter3": "4.0.4", "underscore": "1.9.1", "web3-core-helpers": "1.3.5" + }, + "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + } } }, "web3-eth": { @@ -45518,6 +45721,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45564,6 +45773,12 @@ "@ethersproject/strings": "^5.0.4" } }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45601,6 +45816,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "uuid": { "version": "3.3.2", "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", @@ -45642,6 +45863,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45677,6 +45904,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45705,6 +45938,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45738,9 +45977,15 @@ }, "dependencies": { "@types/node": { - "version": "12.20.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.10.tgz", - "integrity": "sha512-TxCmnSSppKBBOzYzPR2BR25YlX5Oay8z2XGwFBInuA/Co0V9xJhLlW4kjbxKtgeNo3NOMbQP1A5Rc03y+XecPw==", + "version": "12.20.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.13.tgz", + "integrity": "sha512-1x8W5OpxPq+T85OUsHRP6BqXeosKmeXRtjoF39STcdf/UWLqUsoehstZKOi0CunhVqHG17AyZgpj20eRVooK6A==", + "dev": true + }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", "dev": true }, "web3-utils": { @@ -45772,6 +46017,12 @@ "web3-utils": "1.3.5" }, "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + }, "web3-utils": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.5.tgz", @@ -45809,6 +46060,14 @@ "oboe": "2.1.5", "underscore": "1.9.1", "web3-core-helpers": "1.3.5" + }, + "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + } } }, "web3-providers-ws": { @@ -45821,6 +46080,14 @@ "underscore": "1.9.1", "web3-core-helpers": "1.3.5", "websocket": "^1.0.32" + }, + "dependencies": { + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "dev": true + } } }, "web3-shh": { @@ -45836,9 +46103,9 @@ } }, "web3-utils": { - "version": "1.3.4", - "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.4.tgz", - "integrity": "sha512-/vC2v0MaZNpWooJfpRw63u0Y3ag2gNjAWiLtMSL6QQLmCqCy4SQIndMt/vRyx0uMoeGt1YTwSXEcHjUzOhLg0A==", + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.3.6.tgz", + "integrity": "sha512-hHatFaQpkQgjGVER17gNx8u1qMyaXFZtM0y0XLGH1bzsjMPlkMPLRcYOrZ00rOPfTEuYFOdrpGOqZXVmGrMZRg==", "dev": true, "requires": { "bn.js": "^4.11.9", @@ -45847,7 +46114,7 @@ "ethjs-unit": "0.1.6", "number-to-bn": "1.7.0", "randombytes": "^2.1.0", - "underscore": "1.9.1", + "underscore": "1.12.1", "utf8": "3.0.0" } }, @@ -46003,9 +46270,9 @@ "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" }, "ws": { - "version": "7.4.4", - "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.4.tgz", - "integrity": "sha512-Qm8k8ojNQIMx7S+Zp8u/uHOx7Qazv3Yv4q68MiWWWOJhiwG5W3x7iqmRtJo8xxrciZUY4vRxUTJCKuRnF28ZZw==", + "version": "7.4.5", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.5.tgz", + "integrity": "sha512-xzyu3hFvomRfXKH8vOFMU3OguG6oOvhXMo3xsGy3xWExqaM2dxBbVxuD99O7m3ZUFMvvscsZDqxfgMaRr/Nr1g==", "dev": true }, "xhr": { @@ -46077,9 +46344,9 @@ } }, "y18n": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.1.tgz", - "integrity": "sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", "dev": true }, "yaeti": { diff --git a/package.json b/package.json index 08b1ad91..70ed56fa 100644 --- a/package.json +++ b/package.json @@ -115,6 +115,7 @@ "chai": "4.2.0", "chai-bignumber": "3.0.0", "chai-bn": "^0.2.1", + "defender-relay-client": "^1.7.0", "dotenv": "^8.2.0", "eth-sig-util": "2.5.3", "ethereum-waffle": "3.0.2", diff --git a/tasks/dev/2_address_provider_registry.ts b/tasks/dev/2_address_provider_registry.ts index ed85478f..bfa201d4 100644 --- a/tasks/dev/2_address_provider_registry.ts +++ b/tasks/dev/2_address_provider_registry.ts @@ -3,6 +3,7 @@ import { deployLendingPoolAddressesProvider, deployLendingPoolAddressesProviderRegistry, } from '../../helpers/contracts-deployments'; +import { getEthersSigners } from '../../helpers/contracts-helpers'; import { waitForTx } from '../../helpers/misc-utils'; import { AaveConfig } from '../../markets/aave'; @@ -14,7 +15,7 @@ task( .setAction(async ({ verify }, localBRE) => { await localBRE.run('set-DRE'); - const admin = await (await localBRE.ethers.getSigners())[0].getAddress(); + const admin = await (await getEthersSigners())[0].getAddress(); const addressesProvider = await deployLendingPoolAddressesProvider(AaveConfig.MarketId, verify); await waitForTx(await addressesProvider.setPoolAdmin(admin)); diff --git a/test-suites/test-aave/__setup.spec.ts b/test-suites/test-aave/__setup.spec.ts index f8ff2fbe..dd8ed168 100644 --- a/test-suites/test-aave/__setup.spec.ts +++ b/test-suites/test-aave/__setup.spec.ts @@ -4,6 +4,7 @@ import { insertContractAddressInDb, getEthersSigners, registerContractInJsonDb, + getEthersSignersAddresses, } from '../../helpers/contracts-helpers'; import { deployLendingPoolAddressesProvider, @@ -102,10 +103,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => { await waitForTx(await addressesProvider.setPoolAdmin(aaveAdmin)); //setting users[1] as emergency admin, which is in position 2 in the DRE addresses list - // .. users[2] as risk admin .. position 3 - const addressList: string[] = await Promise.all( - (await DRE.ethers.getSigners()).map((signer) => signer.getAddress()) - ); + const addressList = await getEthersSignersAddresses(); await waitForTx(await addressesProvider.setEmergencyAdmin(addressList[2])); diff --git a/test-suites/test-aave/authorized-flashloan.spec.ts b/test-suites/test-aave/authorized-flashloan.spec.ts index 5aaa2bc1..6178b7ef 100644 --- a/test-suites/test-aave/authorized-flashloan.spec.ts +++ b/test-suites/test-aave/authorized-flashloan.spec.ts @@ -30,6 +30,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { before(async () => { _mockFlashLoanReceiver = await getMockFlashLoanReceiver(); }); + it('Authorize flash borowers', async () => { const { deployer, pool, weth, configurator, users } = testEnv; await configurator.authorizeFlashBorrower(deployer.address); @@ -52,7 +53,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { await pool.deposit(weth.address, amountToDeposit, userAddress, '0'); }); - it('Takes WETH flashloan with mode = 0, returns the funds correctly', async () => { + it('Takes WETH flash loan with mode = 0, returns the funds correctly', async () => { const { pool, helpersContract, weth } = testEnv; await pool.flashLoan( @@ -81,7 +82,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { expect(currentLiquidityIndex.toString()).to.be.equal('1000000000000000000000000000'); }); - it('Takes an ETH flashloan with mode = 0 as big as the available liquidity', async () => { + it('Takes an ETH flash loan with mode = 0 as big as the available liquidity', async () => { const { pool, helpersContract, weth } = testEnv; const reserveDataBefore = await helpersContract.getReserveData(weth.address); @@ -97,7 +98,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { const reserveData = await helpersContract.getReserveData(weth.address); - const currentLiqudityRate = reserveData.liquidityRate; + const currentLiquidityRate = reserveData.liquidityRate; const currentLiquidityIndex = reserveData.liquidityIndex; const totalLiquidity = new BigNumber(reserveData.availableLiquidity.toString()) @@ -105,7 +106,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { .plus(reserveData.totalVariableDebt.toString()); expect(totalLiquidity.toString()).to.be.equal('1000000000000000000'); - expect(currentLiqudityRate.toString()).to.be.equal('0'); + expect(currentLiquidityRate.toString()).to.be.equal('0'); expect(currentLiquidityIndex.toString()).to.be.equal('1000000000000000000000000000'); }); @@ -129,7 +130,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { ).to.be.revertedWith(SAFEERC20_LOWLEVEL_CALL); }); - it('Takes WETH flashloan, simulating a receiver as EOA (revert expected)', async () => { + it('Takes WETH flash loan, simulating a receiver as EOA (revert expected)', async () => { const { pool, weth, users } = testEnv; const caller = users[1]; await _mockFlashLoanReceiver.setFailExecutionTransfer(true); @@ -299,14 +300,14 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => { .add(reserveData.totalStableDebt) .add(reserveData.totalVariableDebt) .toString(); - const currentLiqudityRate = reserveData.liquidityRate.toString(); + const currentLiquidityRate = reserveData.liquidityRate.toString(); const currentLiquidityIndex = reserveData.liquidityIndex.toString(); const currentUserBalance = userData.currentATokenBalance.toString(); const expectedLiquidity = await convertToCurrencyDecimals(usdc.address, '1000'); expect(totalLiquidity).to.be.equal(expectedLiquidity, 'Invalid total liquidity'); - expect(currentLiqudityRate).to.be.equal('0', 'Invalid liquidity rate'); + expect(currentLiquidityRate).to.be.equal('0', 'Invalid liquidity rate'); expect(currentLiquidityIndex).to.be.equal( new BigNumber('1.00000').multipliedBy(oneRay).toFixed(), 'Invalid liquidity index' diff --git a/test-suites/test-aave/borrow-cap.spec.ts b/test-suites/test-aave/borrow-cap.spec.ts index 3b2a894c..15dd0a4d 100644 --- a/test-suites/test-aave/borrow-cap.spec.ts +++ b/test-suites/test-aave/borrow-cap.spec.ts @@ -16,10 +16,9 @@ const { expect } = require('chai'); makeSuite('Borrow Cap', (testEnv: TestEnv) => { const { VL_BORROW_CAP_EXCEEDED, RC_INVALID_BORROW_CAP } = ProtocolErrors; - const miliUnitToPrecision = async (token: WETH9Mocked | MintableERC20, nb: string) => + const unitParse = async (token: WETH9Mocked | MintableERC20, nb: string) => BigNumber.from(nb).mul(BigNumber.from('10').pow((await token.decimals()) - 3)); - - it('Sets the borrow cap for Weth and DAI to 0 Units, deposits weth', async () => { + it('Reserves should initially have borrow cap disabled (borrowCap = 0)', async () => { const { configurator, weth, @@ -30,61 +29,111 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { helpersContract, users: [user1], } = testEnv; - const mintedMiliAmount = '1000000000000'; - const daiMinted = await miliUnitToPrecision(dai, mintedMiliAmount); - const wethMinted = await miliUnitToPrecision(weth, mintedMiliAmount); - const usdcMinted = await miliUnitToPrecision(usdc, mintedMiliAmount); - await dai.mint(daiMinted); - await weth.mint(wethMinted); - await usdc.mint(usdcMinted); - await dai.connect(user1.signer).mint(daiMinted); - await weth.connect(user1.signer).mint(wethMinted); - await usdc.connect(user1.signer).mint(usdcMinted); + + const mintedAmount = parseEther('1000000000'); + // minting for main user + await dai.mint(mintedAmount); + await weth.mint(mintedAmount); + await usdc.mint(mintedAmount); + // minting for lp user + await dai.connect(user1.signer).mint(mintedAmount); + await weth.connect(user1.signer).mint(mintedAmount); + await usdc.connect(user1.signer).mint(mintedAmount); + await dai.approve(pool.address, MAX_UINT_AMOUNT); await weth.approve(pool.address, MAX_UINT_AMOUNT); await usdc.approve(pool.address, MAX_UINT_AMOUNT); await dai.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); await weth.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); await usdc.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); + let usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; let daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; - expect(usdcBorrowCap).to.be.equal(MAX_BORROW_CAP); - expect(daiBorrowCap).to.be.equal(MAX_BORROW_CAP); - let wethBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; - let wethSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(wethBorrowCap).to.be.equal(MAX_BORROW_CAP); - expect(wethSupplyCap).to.be.equal(MAX_SUPPLY_CAP); - const depositedMiliAmount = (1e9).toString(); + expect(usdcBorrowCap).to.be.equal('0'); + expect(daiBorrowCap).to.be.equal('0'); + }); + it('Should be able to borrow 10 Dai stable, 10 USDC variable', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; - await configurator.setBorrowCap(usdc.address, 0); - await configurator.setBorrowCap(dai.address, 0); + const suppliedAmount = 1000; + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); - usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; - daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; - - expect(usdcBorrowCap).to.be.equal(0); - expect(daiBorrowCap).to.be.equal(0); + const borrowedAmount = 10; + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); + // deposit collateral await pool.deposit( weth.address, - await miliUnitToPrecision(weth, depositedMiliAmount), + await unitParse(weth, precisionSuppliedAmount), deployer.address, 0 ); - await pool.connect(user1.signer).deposit(weth.address, wethMinted, user1.address, 0); - await pool.connect(user1.signer).deposit(dai.address, daiMinted, user1.address, 0); - await pool.connect(user1.signer).deposit(usdc.address, usdcMinted, user1.address, 0); + // user 1 deposit more dai and usdc to be able to borrow + await pool + .connect(user1.signer) + .deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), user1.address, 0); + + await pool + .connect(user1.signer) + .deposit(usdc.address, await unitParse(usdc, precisionSuppliedAmount), user1.address, 0); + + // borrow + await pool.borrow( + usdc.address, + await unitParse(usdc, precisionBorrowedAmount), + 2, + 0, + deployer.address + ); + + await pool.borrow( + dai.address, + await unitParse(dai, precisionBorrowedAmount), + 1, + 0, + deployer.address + ); + }); + it('Sets the borrow cap for Weth and DAI to 10 Units', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; + + await configurator.setBorrowCap(usdc.address, 10); + await configurator.setBorrowCap(dai.address, 10); + + const usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; + const daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; + + expect(usdcBorrowCap).to.be.equal(10); + expect(daiBorrowCap).to.be.equal(10); }); it('should fail to borrow any dai or usdc, stable or variable', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 10; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await expect( pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 2, 0, deployer.address @@ -94,7 +143,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await expect( pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 2, 0, deployer.address @@ -104,11 +153,6 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('Should fail to set the borrow cap for usdc and DAI to max cap + 1 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; const newCap = Number(MAX_BORROW_CAP) + 1; - let usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; - let daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; - - expect(usdcBorrowCap).to.be.equal(0); - expect(daiBorrowCap).to.be.equal(0); await expect(configurator.setBorrowCap(usdc.address, newCap)).to.be.revertedWith( RC_INVALID_BORROW_CAP @@ -116,24 +160,16 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await expect(configurator.setBorrowCap(dai.address, newCap)).to.be.revertedWith( RC_INVALID_BORROW_CAP ); - - usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; - daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; }); - it('Sets the borrow cap for usdc and DAI to 110 Units', async () => { + it('Sets the borrow cap for usdc and DAI to 120 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; - const newCap = '110'; - let usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; - let daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; - - expect(usdcBorrowCap).to.be.equal(0); - expect(daiBorrowCap).to.be.equal(0); + const newCap = '120'; await configurator.setBorrowCap(usdc.address, newCap); await configurator.setBorrowCap(dai.address, newCap); - usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; - daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; + const usdcBorrowCap = (await helpersContract.getReserveCaps(usdc.address)).borrowCap; + const daiBorrowCap = (await helpersContract.getReserveCaps(dai.address)).borrowCap; expect(usdcBorrowCap).to.be.equal(newCap); expect(daiBorrowCap).to.be.equal(newCap); @@ -141,10 +177,10 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('Should succeed to borrow 10 stable dai and 10 variable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 10; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 2, 0, deployer.address @@ -152,7 +188,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 1, 0, deployer.address @@ -161,12 +197,12 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('should fail to borrow 100 variable dai and 100 stable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 100; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await expect( pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 1, 0, deployer.address @@ -176,7 +212,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await expect( pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 2, 0, deployer.address @@ -186,10 +222,10 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('Should succeed to borrow 99 variable dai and 99 stable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 99; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 2, 0, deployer.address @@ -197,7 +233,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 1, 0, deployer.address @@ -221,11 +257,11 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('should succeed to borrow 100 variable dai and 100 stable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 100; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 1, 0, deployer.address @@ -233,7 +269,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 2, 0, deployer.address @@ -257,12 +293,12 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('should fail to borrow 100 variable dai and 100 stable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 100; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await expect( pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 1, 0, deployer.address @@ -272,7 +308,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await expect( pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 2, 0, deployer.address @@ -297,11 +333,11 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { it('should succeed to borrow 100 variable dai and 100 stable usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const borrowedAmount = 100; - const borrowedMilimount = (borrowedAmount * 1000).toString(); + const precisionBorrowedAmount = (borrowedAmount * 1000).toString(); await pool.borrow( usdc.address, - await miliUnitToPrecision(usdc, borrowedMilimount), + await unitParse(usdc, precisionBorrowedAmount), 1, 0, deployer.address @@ -309,7 +345,7 @@ makeSuite('Borrow Cap', (testEnv: TestEnv) => { await pool.borrow( dai.address, - await miliUnitToPrecision(dai, borrowedMilimount), + await unitParse(dai, precisionBorrowedAmount), 2, 0, deployer.address diff --git a/test-suites/test-aave/configurator.spec.ts b/test-suites/test-aave/configurator.spec.ts index 4c002dfc..7a49e625 100644 --- a/test-suites/test-aave/configurator.spec.ts +++ b/test-suites/test-aave/configurator.spec.ts @@ -73,7 +73,6 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(await configurator.signer.getAddress()).to.be.equal( await addressesProvider.getPoolAdmin() ); - await configurator.pauseReserve(weth.address); const { decimals, @@ -135,14 +134,150 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(supplyCap).to.be.equal(strategyWETH.supplyCap); }); it('Pauses the ETH reserve by emergency admin', async () => { + const { configurator, weth, helpersContract, addressesProvider, users, emergencyAdmin } = + testEnv; + await configurator.connect(emergencyAdmin.signer).pauseReserve(weth.address); const { - configurator, - weth, - helpersContract, - addressesProvider, - users, - emergencyAdmin, - } = testEnv; + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(true); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + }); + + it('Unpauses the ETH reserve by emergency admin ', async () => { + const { configurator, helpersContract, weth, users, emergencyAdmin } = testEnv; + await configurator.connect(emergencyAdmin.signer).unpauseReserve(weth.address); + + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + }); + + it('Check the only admin or emergency admin can pauseReserve ', async () => { + const { configurator, users, weth, riskAdmin } = testEnv; + await expect( + configurator.connect(riskAdmin.signer).pauseReserve(weth.address), + CALLER_NOT_POOL_ADMIN + ).to.be.revertedWith(LPC_CALLER_NOT_EMERGENCY_OR_POOL_ADMIN); + }); + + it('Check the only admin or emergency admin can unpauseReserve ', async () => { + const { configurator, users, weth, riskAdmin } = testEnv; + await expect( + configurator.connect(riskAdmin.signer).unpauseReserve(weth.address), + CALLER_NOT_POOL_ADMIN + ).to.be.revertedWith(LPC_CALLER_NOT_EMERGENCY_OR_POOL_ADMIN); + }); + it('Pauses the ETH reserve by the pool admin', async () => { + const { configurator, weth, helpersContract, addressesProvider, users, emergencyAdmin } = + testEnv; + await configurator.pauseReserve(weth.address); + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(true); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + }); + + it('Unpauses the ETH reserve by pool admin ', async () => { + const { configurator, helpersContract, weth } = testEnv; + await configurator.unpauseReserve(weth.address); + + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + }); + it('Pauses the ETH reserve by emergency admin', async () => { + const { configurator, weth, helpersContract, addressesProvider, users, emergencyAdmin } = + testEnv; await configurator.connect(emergencyAdmin.signer).pauseReserve(weth.address); const { decimals, @@ -220,7 +355,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { ).to.be.revertedWith(LPC_CALLER_NOT_EMERGENCY_OR_POOL_ADMIN); }); - it('Freezes the ETH reserve', async () => { + it('Freezes the ETH reserve by pool Admin', async () => { const { configurator, weth, helpersContract } = testEnv; await configurator.freezeReserve(weth.address); @@ -252,7 +387,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(supplyCap).to.be.equal(strategyWETH.supplyCap); }); - it('Unfreezes the ETH reserve', async () => { + it('Unfreezes the ETH reserve by Pool admin', async () => { const { configurator, helpersContract, weth } = testEnv; await configurator.unfreezeReserve(weth.address); @@ -283,21 +418,83 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(borrowCap).to.be.equal(strategyWETH.borrowCap); expect(supplyCap).to.be.equal(strategyWETH.supplyCap); }); + it('Freezes the ETH reserve by Risk Admin', async () => { + const { configurator, weth, helpersContract, riskAdmin } = testEnv; + await configurator.connect(riskAdmin.signer).freezeReserve(weth.address); + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); - it('Check the onlyAaveAdmin on freezeReserve ', async () => { - const { configurator, users, weth, riskAdmin } = testEnv; - await expect( - configurator.connect(riskAdmin.signer).freezeReserve(weth.address), - CALLER_NOT_POOL_ADMIN - ).to.be.revertedWith(CALLER_NOT_POOL_ADMIN); + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(true); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); }); - it('Check the onlyAaveAdmin on unfreezeReserve ', async () => { - const { configurator, users, weth, riskAdmin } = testEnv; + it('Unfreezes the ETH reserve by Risk admin', async () => { + const { configurator, helpersContract, weth, riskAdmin } = testEnv; + await configurator.connect(riskAdmin.signer).unfreezeReserve(weth.address); + + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + }); + + it('Check the onlyRiskOrPoolAdmins on freezeReserve ', async () => { + const { configurator, users, weth, emergencyAdmin } = testEnv; await expect( - configurator.connect(riskAdmin.signer).unfreezeReserve(weth.address), - CALLER_NOT_POOL_ADMIN - ).to.be.revertedWith(CALLER_NOT_POOL_ADMIN); + configurator.connect(emergencyAdmin.signer).freezeReserve(weth.address), + LPC_CALLER_NOT_RISK_OR_POOL_ADMIN + ).to.be.revertedWith(LPC_CALLER_NOT_RISK_OR_POOL_ADMIN); + }); + + it('Check the onlyRiskOrPoolAdmins on unfreezeReserve ', async () => { + const { configurator, users, weth, emergencyAdmin } = testEnv; + await expect( + configurator.connect(emergencyAdmin.signer).unfreezeReserve(weth.address), + LPC_CALLER_NOT_RISK_OR_POOL_ADMIN + ).to.be.revertedWith(LPC_CALLER_NOT_RISK_OR_POOL_ADMIN); }); it('Deactivates the ETH reserve for borrowing via pool admin', async () => { @@ -333,7 +530,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { it('Activates the ETH reserve for borrowing via pool admin', async () => { const { configurator, weth, helpersContract } = testEnv; - await configurator.enableBorrowingOnReserve(weth.address, MAX_BORROW_CAP, true); + await configurator.enableBorrowingOnReserve(weth.address, '0', true); const { variableBorrowIndex } = await helpersContract.getReserveData(weth.address); const { @@ -399,9 +596,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { it('Activates the ETH reserve for borrowing via risk admin', async () => { const { configurator, weth, helpersContract, riskAdmin } = testEnv; - await configurator - .connect(riskAdmin.signer) - .enableBorrowingOnReserve(weth.address, MAX_BORROW_CAP, true); + await configurator.connect(riskAdmin.signer).enableBorrowingOnReserve(weth.address, '0', true); const { variableBorrowIndex } = await helpersContract.getReserveData(weth.address); const { @@ -816,15 +1011,45 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(supplyCap).to.be.equal(strategyWETH.supplyCap); expect(reserveFactor).to.be.equal(1000); }); + it('Changes the reserve factor of WETH risk admin', async () => { + const { configurator, helpersContract, weth, riskAdmin } = testEnv; + await configurator.connect(riskAdmin.signer).setReserveFactor(weth.address, '1000'); + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); - it('Fails to change to too high borrowCap', async () => { + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(borrowCap).to.be.equal(strategyWETH.borrowCap); + expect(supplyCap).to.be.equal(strategyWETH.supplyCap); + expect(reserveFactor).to.be.equal(1000); + }); + + it('Check that borrowCap cannot be set to value that exceeds the MAX_BORROW_CAP', async () => { const { configurator, users, weth } = testEnv; await expect( configurator.setBorrowCap(weth.address, BigNumber.from(MAX_BORROW_CAP).add(1)), CALLER_NOT_POOL_ADMIN ).to.be.revertedWith(RC_INVALID_BORROW_CAP); }); - it('Fails to change to too high supplyCap', async () => { + it('Check that supplyCap cannot be set to value that exceeds the MAX_SUPPLY_CAP', async () => { const { configurator, users, weth } = testEnv; await expect( configurator.setSupplyCap(weth.address, BigNumber.from(MAX_BORROW_CAP).add(1)), @@ -953,6 +1178,36 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(borrowCap).to.be.equal('3000000'); expect(supplyCap).to.be.equal('3000000'); }); + it('Changes the supply Cap of WETH via risk admin', async () => { + const { configurator, helpersContract, weth, riskAdmin } = testEnv; + await configurator.connect(riskAdmin.signer).setSupplyCap(weth.address, '3000000'); + const { + decimals, + ltv, + liquidationBonus, + liquidationThreshold, + reserveFactor, + stableBorrowRateEnabled, + borrowingEnabled, + isActive, + isFrozen, + } = await helpersContract.getReserveConfigurationData(weth.address); + const { borrowCap, supplyCap } = await helpersContract.getReserveCaps(weth.address); + const isPaused = await helpersContract.getPaused(weth.address); + + expect(borrowingEnabled).to.be.equal(true); + expect(isActive).to.be.equal(true); + expect(isPaused).to.be.equal(false); + expect(isFrozen).to.be.equal(false); + expect(decimals).to.be.equal(strategyWETH.reserveDecimals); + expect(ltv).to.be.equal(strategyWETH.baseLTVAsCollateral); + expect(liquidationThreshold).to.be.equal(strategyWETH.liquidationThreshold); + expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); + expect(stableBorrowRateEnabled).to.be.equal(strategyWETH.stableBorrowRateEnabled); + expect(reserveFactor).to.be.equal(1000); + expect(borrowCap).to.be.equal('3000000'); + expect(supplyCap).to.be.equal('3000000'); + }); it('Reverts when trying to disable the DAI reserve with liquidity on it', async () => { const { dai, pool, configurator } = testEnv; @@ -1012,14 +1267,14 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { CALLER_NOT_POOL_ADMIN ).to.be.revertedWith(CALLER_NOT_POOL_ADMIN); }); - it('Authorized a new flashborrower', async () => { + it('Authorized a new flash borrower', async () => { const { dai, pool, configurator, users, riskAdmin } = testEnv; await configurator.authorizeFlashBorrower(users[4].address); const isFlashBorrowerAuthorized = await pool.isFlashBorrowerAuthorized(users[4].address); expect(isFlashBorrowerAuthorized).to.be.true; }); - it('Unauthorized flashborrower', async () => { + it('Unauthorized flash borrower', async () => { const { dai, pool, configurator, users } = testEnv; await configurator.unauthorizeFlashBorrower(users[4].address); diff --git a/test-suites/test-aave/pausable-functions.spec.ts b/test-suites/test-aave/pausable-functions.spec.ts index c95aaf3c..24bedb69 100644 --- a/test-suites/test-aave/pausable-functions.spec.ts +++ b/test-suites/test-aave/pausable-functions.spec.ts @@ -12,17 +12,14 @@ const { expect } = require('chai'); makeSuite('Pausable Pool', (testEnv: TestEnv) => { let _mockFlashLoanReceiver = {} as MockFlashLoanReceiver; - const { - LP_IS_PAUSED, - INVALID_FROM_BALANCE_AFTER_TRANSFER, - INVALID_TO_BALANCE_AFTER_TRANSFER, - } = ProtocolErrors; + const { LP_IS_PAUSED, INVALID_FROM_BALANCE_AFTER_TRANSFER, INVALID_TO_BALANCE_AFTER_TRANSFER } = + ProtocolErrors; before(async () => { _mockFlashLoanReceiver = await getMockFlashLoanReceiver(); }); - it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succees', async () => { + it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succeeds', async () => { const { users, pool, dai, aDai, configurator } = testEnv; const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000'); diff --git a/test-suites/test-aave/reserve-pause.spec.ts b/test-suites/test-aave/reserve-pause.spec.ts index 3464a20a..b9686b48 100644 --- a/test-suites/test-aave/reserve-pause.spec.ts +++ b/test-suites/test-aave/reserve-pause.spec.ts @@ -22,7 +22,8 @@ makeSuite('Pause Reserve', (testEnv: TestEnv) => { _mockFlashLoanReceiver = await getMockFlashLoanReceiver(); }); - it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succees', async () => { + + it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succeeds', async () => { const { users, pool, dai, aDai, configurator } = testEnv; const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000'); diff --git a/test-suites/test-aave/supply-cap.spec.ts b/test-suites/test-aave/supply-cap.spec.ts index 8c35d197..6c213682 100644 --- a/test-suites/test-aave/supply-cap.spec.ts +++ b/test-suites/test-aave/supply-cap.spec.ts @@ -15,10 +15,10 @@ const { expect } = require('chai'); makeSuite('supply Cap', (testEnv: TestEnv) => { const { VL_SUPPLY_CAP_EXCEEDED, RC_INVALID_SUPPLY_CAP } = ProtocolErrors; - const miliUnitToPrecision = async (token: WETH9Mocked | MintableERC20, nb: string) => + const unitParse = async (token: WETH9Mocked | MintableERC20, nb: string) => BigNumber.from(nb).mul(BigNumber.from('10').pow((await token.decimals()) - 3)); - it('Sets the supply cap for Weth and DAI to 0 Units, deposits weth', async () => { + it('Reserves should initially have supply cap disabled (supplyCap = 0)', async () => { const { configurator, weth, @@ -29,61 +29,101 @@ makeSuite('supply Cap', (testEnv: TestEnv) => { helpersContract, users: [user1], } = testEnv; + const mintedAmount = parseEther('1000000000'); await dai.mint(mintedAmount); await weth.mint(mintedAmount); await usdc.mint(mintedAmount); + await dai.approve(pool.address, MAX_UINT_AMOUNT); await weth.approve(pool.address, MAX_UINT_AMOUNT); await usdc.approve(pool.address, MAX_UINT_AMOUNT); - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(usdcsupplyCap).to.be.equal(MAX_SUPPLY_CAP); - expect(daisupplyCap).to.be.equal(MAX_SUPPLY_CAP); + let usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + let daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - const depositedMiliAmount = (1e9).toString(); + expect(usdcSupplyCap).to.be.equal('0'); + expect(daiSupplyCap).to.be.equal('0'); + }); + it('Should be able to deposit 1000 Dai, 1000 USDC and 1000 Weth', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; - await configurator.setSupplyCap(usdc.address, 0); - await configurator.setSupplyCap(dai.address, 0); + const suppliedAmount = 1000; + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); - usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + await pool.deposit( + usdc.address, + await unitParse(usdc, precisionSuppliedAmount), + deployer.address, + 0 + ); - expect(usdcsupplyCap).to.be.equal(0); - expect(daisupplyCap).to.be.equal(0); + await pool.deposit( + dai.address, + await unitParse(dai, precisionSuppliedAmount), + deployer.address, + 0 + ); + await pool.deposit( + weth.address, + await unitParse(weth, precisionSuppliedAmount), + deployer.address, + 0 + ); + }); + it('Sets the supply cap for Weth and DAI to 1000 Unit', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; + + const newCap = '1000'; + + await configurator.setSupplyCap(usdc.address, newCap); + await configurator.setSupplyCap(dai.address, newCap); + + const usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + const daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + + expect(usdcSupplyCap).to.be.equal(newCap); + expect(daiSupplyCap).to.be.equal(newCap); }); it('should fail to supply any dai or usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 10; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await expect( pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); await expect( - pool.deposit( - dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), - deployer.address, - 0 - ) + pool.deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), deployer.address, 0) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); }); it('Should fail to set the supply cap for usdc and DAI to max cap + 1 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; const newCap = Number(MAX_SUPPLY_CAP) + 1; - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - - expect(usdcsupplyCap).to.be.equal(0); - expect(daisupplyCap).to.be.equal(0); await expect(configurator.setSupplyCap(usdc.address, newCap)).to.be.revertedWith( RC_INVALID_SUPPLY_CAP @@ -92,38 +132,33 @@ makeSuite('supply Cap', (testEnv: TestEnv) => { RC_INVALID_SUPPLY_CAP ); }); - it('Sets the supply cap for usdc and DAI to 110 Units', async () => { + it('Sets the supply cap for usdc and DAI to 1110 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; - const newCap = '110'; - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - - expect(usdcsupplyCap).to.be.equal(0); - expect(daisupplyCap).to.be.equal(0); + const newCap = '1110'; await configurator.setSupplyCap(usdc.address, newCap); await configurator.setSupplyCap(dai.address, newCap); - usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + const usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + const daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(usdcsupplyCap).to.be.equal(newCap); - expect(daisupplyCap).to.be.equal(newCap); + expect(usdcSupplyCap).to.be.equal(newCap); + expect(daiSupplyCap).to.be.equal(newCap); }); it('Should succeed to supply 10 dai and 10 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 10; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ); await pool.deposit( dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), + await unitParse(dai, precisionSuppliedAmount), deployer.address, 0 ); @@ -131,144 +166,132 @@ makeSuite('supply Cap', (testEnv: TestEnv) => { it('should fail to supply 100 dai and 100 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 100; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await expect( pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); await expect( - pool.deposit( - dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), - deployer.address, - 0 - ) + pool.deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), deployer.address, 0) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); }); it('Should succeed to supply 99 dai and 99 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 99; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ); await pool.deposit( dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), + await unitParse(dai, precisionSuppliedAmount), deployer.address, 0 ); }); - it('Raises the supply cap for usdc and DAI to 1000 Units', async () => { + it('Raises the supply cap for usdc and DAI to 2000 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; - const newCap = '1000'; - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + const newCap = '2000'; await configurator.setSupplyCap(usdc.address, newCap); await configurator.setSupplyCap(dai.address, newCap); - usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + const usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + const daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(usdcsupplyCap).to.be.equal(newCap); - expect(daisupplyCap).to.be.equal(newCap); + expect(usdcSupplyCap).to.be.equal(newCap); + expect(daiSupplyCap).to.be.equal(newCap); }); it('should succeed to supply 100 dai and 100 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 100; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ); await pool.deposit( dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), + await unitParse(dai, precisionSuppliedAmount), deployer.address, 0 ); }); - it('Lowers the supply cap for usdc and DAI to 200 Units', async () => { + it('Lowers the supply cap for usdc and DAI to 1200 Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; - const newCap = '200'; - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + const newCap = '1200'; + let usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + let daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; await configurator.setSupplyCap(usdc.address, newCap); await configurator.setSupplyCap(dai.address, newCap); - usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(usdcsupplyCap).to.be.equal(newCap); - expect(daisupplyCap).to.be.equal(newCap); + expect(usdcSupplyCap).to.be.equal(newCap); + expect(daiSupplyCap).to.be.equal(newCap); }); it('should fail to supply 100 dai and 100 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 100; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await expect( pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); await expect( - pool.deposit( - dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), - deployer.address, - 0 - ) + pool.deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), deployer.address, 0) ).to.be.revertedWith(VL_SUPPLY_CAP_EXCEEDED); }); it('Raises the supply cap for usdc and DAI to max cap Units', async () => { const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; const newCap = MAX_SUPPLY_CAP; - let usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - let daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + let usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + let daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; await configurator.setSupplyCap(usdc.address, newCap); await configurator.setSupplyCap(dai.address, newCap); - usdcsupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; - daisupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; + usdcSupplyCap = (await helpersContract.getReserveCaps(usdc.address)).supplyCap; + daiSupplyCap = (await helpersContract.getReserveCaps(dai.address)).supplyCap; - expect(usdcsupplyCap).to.be.equal(newCap); - expect(daisupplyCap).to.be.equal(newCap); + expect(usdcSupplyCap).to.be.equal(newCap); + expect(daiSupplyCap).to.be.equal(newCap); }); it('should succeed to supply 100 dai and 100 usdc', async () => { const { usdc, pool, dai, deployer, helpersContract } = testEnv; const suppliedAmount = 100; - const suppliedMilimount = (suppliedAmount * 1000).toString(); + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); await pool.deposit( usdc.address, - await miliUnitToPrecision(usdc, suppliedMilimount), + await unitParse(usdc, precisionSuppliedAmount), deployer.address, 0 ); await pool.deposit( dai.address, - await miliUnitToPrecision(dai, suppliedMilimount), + await unitParse(dai, precisionSuppliedAmount), deployer.address, 0 ); diff --git a/test-suites/test-amm/__setup.spec.ts b/test-suites/test-amm/__setup.spec.ts index 3254f2c4..0fae3acd 100644 --- a/test-suites/test-amm/__setup.spec.ts +++ b/test-suites/test-amm/__setup.spec.ts @@ -4,6 +4,7 @@ import { insertContractAddressInDb, getEthersSigners, registerContractInJsonDb, + getEthersSignersAddresses, } from '../../helpers/contracts-helpers'; import { deployLendingPoolAddressesProvider, @@ -101,9 +102,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => { await waitForTx(await addressesProvider.setPoolAdmin(aaveAdmin)); //setting users[1] as emergency admin, which is in position 2 in the DRE addresses list - const addressList = await Promise.all( - (await DRE.ethers.getSigners()).map((signer) => signer.getAddress()) - ); + const addressList = await getEthersSignersAddresses(); await waitForTx(await addressesProvider.setEmergencyAdmin(addressList[2])); diff --git a/test-suites/test-amm/configurator.spec.ts b/test-suites/test-amm/configurator.spec.ts index 4ba20620..6370ce1c 100644 --- a/test-suites/test-amm/configurator.spec.ts +++ b/test-suites/test-amm/configurator.spec.ts @@ -156,7 +156,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { it('Activates the ETH reserve for borrowing', async () => { const { configurator, weth, helpersContract } = testEnv; - await configurator.enableBorrowingOnReserve(weth.address, MAX_BORROW_CAP, true); + await configurator.enableBorrowingOnReserve(weth.address, '0', true); const { variableBorrowIndex } = await helpersContract.getReserveData(weth.address); const { @@ -180,7 +180,6 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => { expect(liquidationBonus).to.be.equal(strategyWETH.liquidationBonus); expect(stableBorrowRateEnabled).to.be.equal(true /*strategyWETH.stableBorrowRateEnabled*/); expect(reserveFactor).to.be.equal(strategyWETH.reserveFactor); - expect(variableBorrowIndex.toString()).to.be.equal(RAY); }); diff --git a/test-suites/test-amm/pausable-functions.spec.ts b/test-suites/test-amm/pausable-functions.spec.ts index 2096b235..f42388a8 100644 --- a/test-suites/test-amm/pausable-functions.spec.ts +++ b/test-suites/test-amm/pausable-functions.spec.ts @@ -22,7 +22,7 @@ makeSuite('Pausable Pool', (testEnv: TestEnv) => { _mockFlashLoanReceiver = await getMockFlashLoanReceiver(); }); - it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succees', async () => { + it('User 0 deposits 1000 DAI. Configurator pauses pool. Transfers to user 1 reverts. Configurator unpauses the network and next transfer succeeds', async () => { const { users, pool, dai, aDai, configurator } = testEnv; const amountDAItoDeposit = await convertToCurrencyDecimals(dai.address, '1000'); diff --git a/tsconfig.json b/tsconfig.json index 9974c3b6..44c4df6f 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -8,7 +8,7 @@ "noImplicitAny": false, "resolveJsonModule": true }, - "include": ["./scripts", "./test", "./tasks", "test-suites/test-aave/uniswapAdapters.repay.spec.ts", "test-suites/test-aave/upgradeability.spec.ts", "test-suites/test-aave/variable-debt-token.spec.ts", "test-suites/test-aave/weth-gateway.spec.ts"], + "include": ["./scripts", "./test", "./tasks", "./helpers", "test-suites/test-aave/uniswapAdapters.repay.spec.ts", "test-suites/test-aave/upgradeability.spec.ts", "test-suites/test-aave/variable-debt-token.spec.ts", "test-suites/test-aave/weth-gateway.spec.ts"], "files": [ "./hardhat.config.ts", "./modules/tenderly/tenderly.d.ts",