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

Merge pull request #14 from aave/feat/light-deployments

Browse Source 
Enable light deployment of the protocol
This commit is contained in:
The-3D 2021-03-05 13:53:35 +01:00 committed by GitHub
commit 7e39178e8f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
181 changed files with 20092 additions and 1952 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contracts/adapters/BaseUniswapAdapter.sol
View File

@ -386,7 +386,6 @@ abstract contract BaseUniswapAdapter is FlashLoanReceiverBase, IBaseUniswapAdapt
}
uint256 bestAmountOut;
try UNISWAP_ROUTER.getAmountsOut(finalAmountIn, simplePath) returns (
uint256[] memory resultAmounts
) {

104
contracts/deployments/ATokensAndRatesHelper.sol
View File

@ -20,6 +20,20 @@ contract ATokensAndRatesHelper is Ownable {
address private poolConfigurator;
event deployedContracts(address aToken, address strategy);
struct InitDeploymentInput {
address asset;
uint256[6] rates;
}
struct ConfigureReserveInput {
address asset;
uint256 baseLTV;
uint256 liquidationThreshold;
uint256 liquidationBonus;
uint256 reserveFactor;
bool stableBorrowingEnabled;
}
constructor(
address payable _pool,
address _addressesProvider,
@ -30,90 +44,40 @@ contract ATokensAndRatesHelper is Ownable {
poolConfigurator = _poolConfigurator;
}
function initDeployment(
address[] calldata assets,
string[] calldata symbols,
uint256[6][] calldata rates,
address treasuryAddress,
address incentivesController
) external onlyOwner {
require(assets.length == symbols.length, 't Arrays not same length');
require(rates.length == symbols.length, 'r Arrays not same length');
for (uint256 i = 0; i < assets.length; i++) {
function initDeployment(InitDeploymentInput[] calldata inputParams) external onlyOwner {
for (uint256 i = 0; i < inputParams.length; i++) {
emit deployedContracts(
address(
new AToken(
LendingPool(pool),
assets[i],
treasuryAddress,
StringLib.concat('Aave interest bearing ', symbols[i]),
StringLib.concat('a', symbols[i]),
incentivesController
)
),
address(new AToken()),
address(
new DefaultReserveInterestRateStrategy(
LendingPoolAddressesProvider(addressesProvider),
rates[i][0],
rates[i][1],
rates[i][2],
rates[i][3],
rates[i][4],
rates[i][5]
inputParams[i].rates[0],
inputParams[i].rates[1],
inputParams[i].rates[2],
inputParams[i].rates[3],
inputParams[i].rates[4],
inputParams[i].rates[5]
)
)
);
}
}
function initReserve(
address[] calldata stables,
address[] calldata variables,
address[] calldata aTokens,
address[] calldata strategies,
uint8[] calldata reserveDecimals
) external onlyOwner {
require(variables.length == stables.length);
require(aTokens.length == stables.length);
require(strategies.length == stables.length);
require(reserveDecimals.length == stables.length);
for (uint256 i = 0; i < stables.length; i++) {
LendingPoolConfigurator(poolConfigurator).initReserve(
aTokens[i],
stables[i],
variables[i],
reserveDecimals[i],
strategies[i]
);
}
}
function configureReserves(
address[] calldata assets,
uint256[] calldata baseLTVs,
uint256[] calldata liquidationThresholds,
uint256[] calldata liquidationBonuses,
uint256[] calldata reserveFactors,
bool[] calldata stableBorrowingEnabled
) external onlyOwner {
require(baseLTVs.length == assets.length);
require(liquidationThresholds.length == assets.length);
require(liquidationBonuses.length == assets.length);
require(stableBorrowingEnabled.length == assets.length);
require(reserveFactors.length == assets.length);
function configureReserves(ConfigureReserveInput[] calldata inputParams) external onlyOwner {
LendingPoolConfigurator configurator = LendingPoolConfigurator(poolConfigurator);
for (uint256 i = 0; i < assets.length; i++) {
for (uint256 i = 0; i < inputParams.length; i++) {
configurator.configureReserveAsCollateral(
assets[i],
baseLTVs[i],
liquidationThresholds[i],
liquidationBonuses[i]
inputParams[i].asset,
inputParams[i].baseLTV,
inputParams[i].liquidationThreshold,
inputParams[i].liquidationBonus
);
configurator.enableBorrowingOnReserve(assets[i], stableBorrowingEnabled[i]);
configurator.setReserveFactor(assets[i], reserveFactors[i]);
configurator.enableBorrowingOnReserve(
inputParams[i].asset,
inputParams[i].stableBorrowingEnabled
);
configurator.setReserveFactor(inputParams[i].asset, inputParams[i].reserveFactor);
}
}
}

27
contracts/deployments/StableAndVariableTokensHelper.sol
View File

@ -18,34 +18,11 @@ contract StableAndVariableTokensHelper is Ownable {
addressesProvider = _addressesProvider;
}
function initDeployment(
address[] calldata tokens,
string[] calldata symbols,
address incentivesController
) external onlyOwner {
function initDeployment(address[] calldata tokens, string[] calldata symbols) external onlyOwner {
require(tokens.length == symbols.length, 'Arrays not same length');
require(pool != address(0), 'Pool can not be zero address');
for (uint256 i = 0; i < tokens.length; i++) {
emit deployedContracts(
address(
new StableDebtToken(
pool,
tokens[i],
StringLib.concat('Aave stable debt bearing ', symbols[i]),
StringLib.concat('stableDebt', symbols[i]),
incentivesController
)
),
address(
new VariableDebtToken(
pool,
tokens[i],
StringLib.concat('Aave variable debt bearing ', symbols[i]),
StringLib.concat('variableDebt', symbols[i]),
incentivesController
)
)
);
emit deployedContracts(address(new StableDebtToken()), address(new VariableDebtToken()));
}
}

18
contracts/interfaces/IAToken.sol
View File

@ -3,8 +3,10 @@ pragma solidity 0.6.12;
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {IScaledBalanceToken} from './IScaledBalanceToken.sol';
import {IInitializableAToken} from './IInitializableAToken.sol';
import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
interface IAToken is IERC20, IScaledBalanceToken {
interface IAToken is IERC20, IScaledBalanceToken, IInitializableAToken {
/**
* @dev Emitted after the mint action
* @param from The address performing the mint
@ -80,9 +82,21 @@ interface IAToken is IERC20, IScaledBalanceToken {
/**
* @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer
* assets in borrow(), withdraw() and flashLoan()
* @param user The recipient of the aTokens
* @param user The recipient of the underlying
* @param amount The amount getting transferred
* @return The amount transferred
**/
function transferUnderlyingTo(address user, uint256 amount) external returns (uint256);
/**
* @dev Invoked to execute actions on the aToken side after a repayment.
* @param user The user executing the repayment
* @param amount The amount getting repaid
**/
function handleRepayment(address user, uint256 amount) external;
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view returns (IAaveIncentivesController);
}

55
contracts/interfaces/IInitializableAToken.sol Normal file
View File

@ -0,0 +1,55 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {ILendingPool} from './ILendingPool.sol';
import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
/**
* @title IInitializableAToken
* @notice Interface for the initialize function on AToken
* @author Aave
**/
interface IInitializableAToken {
/**
* @dev Emitted when an aToken is initialized
* @param underlyingAsset The address of the underlying asset
* @param pool The address of the associated lending pool
* @param treasury The address of the treasury
* @param incentivesController The address of the incentives controller for this aToken
* @param aTokenDecimals the decimals of the underlying
* @param aTokenName the name of the aToken
* @param aTokenSymbol the symbol of the aToken
* @param params A set of encoded parameters for additional initialization
**/
event Initialized(
address indexed underlyingAsset,
address indexed pool,
address treasury,
address incentivesController,
uint8 aTokenDecimals,
string aTokenName,
string aTokenSymbol,
bytes params
);
/**
* @dev Initializes the aToken
* @param pool The address of the lending pool where this aToken will be used
* @param treasury The address of the Aave treasury, receiving the fees on this aToken
* @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
* @param incentivesController The smart contract managing potential incentives distribution
* @param aTokenDecimals The decimals of the aToken, same as the underlying asset's
* @param aTokenName The name of the aToken
* @param aTokenSymbol The symbol of the aToken
*/
function initialize(
ILendingPool pool,
address treasury,
address underlyingAsset,
IAaveIncentivesController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol,
bytes calldata params
) external;
}

51
contracts/interfaces/IInitializableDebtToken.sol Normal file
View File

@ -0,0 +1,51 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {ILendingPool} from './ILendingPool.sol';
import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
/**
* @title IInitializableDebtToken
* @notice Interface for the initialize function common between debt tokens
* @author Aave
**/
interface IInitializableDebtToken {
/**
* @dev Emitted when a debt token is initialized
* @param underlyingAsset The address of the underlying asset
* @param pool The address of the associated lending pool
* @param incentivesController The address of the incentives controller for this aToken
* @param debtTokenDecimals the decimals of the debt token
* @param debtTokenName the name of the debt token
* @param debtTokenSymbol the symbol of the debt token
* @param params A set of encoded parameters for additional initialization
**/
event Initialized(
address indexed underlyingAsset,
address indexed pool,
address incentivesController,
uint8 debtTokenDecimals,
string debtTokenName,
string debtTokenSymbol,
bytes params
);
/**
* @dev Initializes the debt token.
* @param pool The address of the lending pool where this aToken will be used
* @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
* @param incentivesController The smart contract managing potential incentives distribution
* @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
* @param debtTokenName The name of the token
* @param debtTokenSymbol The symbol of the token
*/
function initialize(
ILendingPool pool,
address underlyingAsset,
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol,
bytes calldata params
) external;
}

179
contracts/interfaces/ILendingPoolConfigurator.sol Normal file
View File

@ -0,0 +1,179 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface ILendingPoolConfigurator {
struct InitReserveInput {
address aTokenImpl;
address stableDebtTokenImpl;
address variableDebtTokenImpl;
uint8 underlyingAssetDecimals;
address interestRateStrategyAddress;
address underlyingAsset;
address treasury;
address incentivesController;
string underlyingAssetName;
string aTokenName;
string aTokenSymbol;
string variableDebtTokenName;
string variableDebtTokenSymbol;
string stableDebtTokenName;
string stableDebtTokenSymbol;
bytes params;
}
struct UpdateATokenInput {
address asset;
address treasury;
address incentivesController;
string name;
string symbol;
address implementation;
bytes params;
}
struct UpdateDebtTokenInput {
address asset;
address incentivesController;
string name;
string symbol;
address implementation;
bytes params;
}
/**
* @dev Emitted when a reserve is initialized.
* @param asset The address of the underlying asset of the reserve
* @param aToken The address of the associated aToken contract
* @param stableDebtToken The address of the associated stable rate debt token
* @param variableDebtToken The address of the associated variable rate debt token
* @param interestRateStrategyAddress The address of the interest rate strategy for the reserve
**/
event ReserveInitialized(
address indexed asset,
address indexed aToken,
address stableDebtToken,
address variableDebtToken,
address interestRateStrategyAddress
);
/**
* @dev Emitted when borrowing is enabled on a reserve
* @param asset The address of the underlying asset of the reserve
* @param stableRateEnabled True if stable rate borrowing is enabled, false otherwise
**/
event BorrowingEnabledOnReserve(address indexed asset, bool stableRateEnabled);
/**
* @dev Emitted when borrowing is disabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event BorrowingDisabledOnReserve(address indexed asset);
/**
* @dev Emitted when the collateralization risk parameters for the specified asset are updated.
* @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
**/
event CollateralConfigurationChanged(
address indexed asset,
uint256 ltv,
uint256 liquidationThreshold,
uint256 liquidationBonus
);
/**
* @dev Emitted when stable rate borrowing is enabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event StableRateEnabledOnReserve(address indexed asset);
/**
* @dev Emitted when stable rate borrowing is disabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event StableRateDisabledOnReserve(address indexed asset);
/**
* @dev Emitted when a reserve is activated
* @param asset The address of the underlying asset of the reserve
**/
event ReserveActivated(address indexed asset);
/**
* @dev Emitted when a reserve is deactivated
* @param asset The address of the underlying asset of the reserve
**/
event ReserveDeactivated(address indexed asset);
/**
* @dev Emitted when a reserve is frozen
* @param asset The address of the underlying asset of the reserve
**/
event ReserveFrozen(address indexed asset);
/**
* @dev Emitted when a reserve is unfrozen
* @param asset The address of the underlying asset of the reserve
**/
event ReserveUnfrozen(address indexed asset);
/**
* @dev Emitted when a reserve factor is updated
* @param asset The address of the underlying asset of the reserve
* @param factor The new reserve factor
**/
event ReserveFactorChanged(address indexed asset, uint256 factor);
/**
* @dev Emitted when the reserve decimals are updated
* @param asset The address of the underlying asset of the reserve
* @param decimals The new decimals
**/
event ReserveDecimalsChanged(address indexed asset, uint256 decimals);
/**
* @dev Emitted when a reserve interest strategy contract is updated
* @param asset The address of the underlying asset of the reserve
* @param strategy The new address of the interest strategy contract
**/
event ReserveInterestRateStrategyChanged(address indexed asset, address strategy);
/**
* @dev Emitted when an aToken implementation is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The aToken proxy address
* @param implementation The new aToken implementation
**/
event ATokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
/**
* @dev Emitted when the implementation of a stable debt token is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The stable debt token proxy address
* @param implementation The new aToken implementation
**/
event StableDebtTokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
/**
* @dev Emitted when the implementation of a variable debt token is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The variable debt token proxy address
* @param implementation The new aToken implementation
**/
event VariableDebtTokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
}

20
contracts/interfaces/IReserveInterestRateStrategy.sol
View File

@ -13,7 +13,25 @@ interface IReserveInterestRateStrategy {
function calculateInterestRates(
address reserve,
uint256 utilizationRate,
uint256 availableLiquidity,
uint256 totalStableDebt,
uint256 totalVariableDebt,
uint256 averageStableBorrowRate,
uint256 reserveFactor
)
external
view
returns (
uint256,
uint256,
uint256
);
function calculateInterestRates(
address reserve,
address aToken,
uint256 liquidityAdded,
uint256 liquidityTaken,
uint256 totalStableDebt,
uint256 totalVariableDebt,
uint256 averageStableBorrowRate,

10
contracts/interfaces/IStableDebtToken.sol
View File

@ -1,6 +1,9 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {IInitializableDebtToken} from './IInitializableDebtToken.sol';
import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
/**
* @title IStableDebtToken
* @notice Defines the interface for the stable debt token
@ -8,7 +11,7 @@ pragma solidity 0.6.12;
* @author Aave
**/
interface IStableDebtToken {
interface IStableDebtToken is IInitializableDebtToken {
/**
* @dev Emitted when new stable debt is minted
* @param user The address of the user who triggered the minting
@ -122,4 +125,9 @@ interface IStableDebtToken {
* @return The debt balance of the user since the last burn/mint action
**/
function principalBalanceOf(address user) external view returns (uint256);
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view returns (IAaveIncentivesController);
}

14
contracts/interfaces/ITokenConfiguration.sol
View File

@ -1,14 +0,0 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
/**
* @title ITokenConfiguration
* @author Aave
* @dev Common interface between aTokens and debt tokens to fetch the
* token configuration
**/
interface ITokenConfiguration {
function UNDERLYING_ASSET_ADDRESS() external view returns (address);
function POOL() external view returns (address);
}

9
contracts/interfaces/IVariableDebtToken.sol
View File

@ -2,13 +2,15 @@
pragma solidity 0.6.12;
import {IScaledBalanceToken} from './IScaledBalanceToken.sol';
import {IInitializableDebtToken} from './IInitializableDebtToken.sol';
import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
/**
* @title IVariableDebtToken
* @author Aave
* @notice Defines the basic interface for a variable debt token.
**/
interface IVariableDebtToken is IScaledBalanceToken {
interface IVariableDebtToken is IScaledBalanceToken, IInitializableDebtToken {
/**
* @dev Emitted after the mint action
* @param from The address performing the mint
@ -52,4 +54,9 @@ interface IVariableDebtToken is IScaledBalanceToken {
uint256 amount,
uint256 index
) external;
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view returns (IAaveIncentivesController);
}

65
contracts/misc/WETHGateway.sol
View File

@ -18,39 +18,47 @@ contract WETHGateway is IWETHGateway, Ownable {
using UserConfiguration for DataTypes.UserConfigurationMap;
IWETH internal immutable WETH;
ILendingPool internal immutable POOL;
IAToken internal immutable aWETH;
/**
* @dev Sets the WETH address and the LendingPoolAddressesProvider address. Infinite approves lending pool.
* @param weth Address of the Wrapped Ether contract
* @param pool Address of the LendingPool contract
**/
constructor(address weth, address pool) public {
ILendingPool poolInstance = ILendingPool(pool);
constructor(address weth) public {
WETH = IWETH(weth);
POOL = poolInstance;
aWETH = IAToken(poolInstance.getReserveData(weth).aTokenAddress);
IWETH(weth).approve(pool, uint256(-1));
}
function authorizeLendingPool(address lendingPool) external onlyOwner {
WETH.approve(lendingPool, uint256(-1));
}
/**
* @dev deposits WETH into the reserve, using native ETH. A corresponding amount of the overlying asset (aTokens)
* is minted.
* @param lendingPool address of the targeted underlying lending pool
* @param onBehalfOf address of the user who will receive the aTokens representing the deposit
* @param referralCode integrators are assigned a referral code and can potentially receive rewards.
**/
function depositETH(address onBehalfOf, uint16 referralCode) external payable override {
function depositETH(
address lendingPool,
address onBehalfOf,
uint16 referralCode
) external payable override {
WETH.deposit{value: msg.value}();
POOL.deposit(address(WETH), msg.value, onBehalfOf, referralCode);
ILendingPool(lendingPool).deposit(address(WETH), msg.value, onBehalfOf, referralCode);
}
/**
* @dev withdraws the WETH _reserves of msg.sender.
* @param lendingPool address of the targeted underlying lending pool
* @param amount amount of aWETH to withdraw and receive native ETH
* @param to address of the user who will receive native ETH
*/
function withdrawETH(uint256 amount, address to) external override {
function withdrawETH(
address lendingPool,
uint256 amount,
address to
) external override {
IAToken aWETH = IAToken(ILendingPool(lendingPool).getReserveData(address(WETH)).aTokenAddress);
uint256 userBalance = aWETH.balanceOf(msg.sender);
uint256 amountToWithdraw = amount;
@ -59,24 +67,29 @@ contract WETHGateway is IWETHGateway, Ownable {
amountToWithdraw = userBalance;
}
aWETH.transferFrom(msg.sender, address(this), amountToWithdraw);
POOL.withdraw(address(WETH), amountToWithdraw, address(this));
ILendingPool(lendingPool).withdraw(address(WETH), amountToWithdraw, address(this));
WETH.withdraw(amountToWithdraw);
_safeTransferETH(to, amountToWithdraw);
}
/**
* @dev repays a borrow on the WETH reserve, for the specified amount (or for the whole amount, if uint256(-1) is specified).
* @param lendingPool address of the targeted underlying lending pool
* @param amount the amount to repay, or uint256(-1) if the user wants to repay everything
* @param rateMode the rate mode to repay
* @param onBehalfOf the address for which msg.sender is repaying
*/
function repayETH(
address lendingPool,
uint256 amount,
uint256 rateMode,
address onBehalfOf
) external payable override {
(uint256 stableDebt, uint256 variableDebt) =
Helpers.getUserCurrentDebtMemory(onBehalfOf, POOL.getReserveData(address(WETH)));
Helpers.getUserCurrentDebtMemory(
onBehalfOf,
ILendingPool(lendingPool).getReserveData(address(WETH))
);
uint256 paybackAmount =
DataTypes.InterestRateMode(rateMode) == DataTypes.InterestRateMode.STABLE
@ -88,7 +101,7 @@ contract WETHGateway is IWETHGateway, Ownable {
}
require(msg.value >= paybackAmount, 'msg.value is less than repayment amount');
WETH.deposit{value: paybackAmount}();
POOL.repay(address(WETH), msg.value, rateMode, onBehalfOf);
ILendingPool(lendingPool).repay(address(WETH), msg.value, rateMode, onBehalfOf);
// refund remaining dust eth
if (msg.value > paybackAmount) _safeTransferETH(msg.sender, msg.value - paybackAmount);
@ -96,16 +109,24 @@ contract WETHGateway is IWETHGateway, Ownable {
/**
* @dev borrow WETH, unwraps to ETH and send both the ETH and DebtTokens to msg.sender, via `approveDelegation` and onBehalf argument in `LendingPool.borrow`.
* @param lendingPool address of the targeted underlying lending pool
* @param amount the amount of ETH to borrow
* @param interesRateMode the interest rate mode
* @param referralCode integrators are assigned a referral code and can potentially receive rewards
*/
function borrowETH(
address lendingPool,
uint256 amount,
uint256 interesRateMode,
uint16 referralCode
) external override {
POOL.borrow(address(WETH), amount, interesRateMode, referralCode, msg.sender);
ILendingPool(lendingPool).borrow(
address(WETH),
amount,
interesRateMode,
referralCode,
msg.sender
);
WETH.withdraw(amount);
_safeTransferETH(msg.sender, amount);
}
@ -152,20 +173,6 @@ contract WETHGateway is IWETHGateway, Ownable {
return address(WETH);
}
/**
* @dev Get aWETH address used by WETHGateway
*/
function getAWETHAddress() external view returns (address) {
return address(aWETH);
}
/**
* @dev Get LendingPool address used by WETHGateway
*/
function getLendingPoolAddress() external view returns (address) {
return address(POOL);
}
/**
* @dev Only WETH contract is allowed to transfer ETH here. Prevent other addresses to send Ether to this contract.
*/

14
contracts/misc/interfaces/IWETHGateway.sol
View File

@ -2,17 +2,27 @@
pragma solidity 0.6.12;
interface IWETHGateway {
function depositETH(address onBehalfOf, uint16 referralCode) external payable;
function depositETH(
address lendingPool,
address onBehalfOf,
uint16 referralCode
) external payable;
function withdrawETH(uint256 amount, address onBehalfOf) external;
function withdrawETH(
address lendingPool,
uint256 amount,
address onBehalfOf
) external;
function repayETH(
address lendingPool,
uint256 amount,
uint256 rateMode,
address onBehalfOf
) external payable;
function borrowETH(
address lendingPool,
uint256 amount,
uint256 interesRateMode,
uint16 referralCode

32
contracts/mocks/upgradeability/MockAToken.sol
View File

@ -2,39 +2,11 @@
pragma solidity 0.6.12;
import {AToken} from '../../protocol/tokenization/AToken.sol';
import {LendingPool} from '../../protocol/lendingpool/LendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
contract MockAToken is AToken {
constructor(
LendingPool pool,
address underlyingAssetAddress,
address reserveTreasury,
string memory tokenName,
string memory tokenSymbol,
address incentivesController
)
public
AToken(
pool,
underlyingAssetAddress,
reserveTreasury,
tokenName,
tokenSymbol,
incentivesController
)
{}
function getRevision() internal pure override returns (uint256) {
return 0x2;
}
function initialize(
uint8 _underlyingAssetDecimals,
string calldata _tokenName,
string calldata _tokenSymbol
) external virtual override initializer {
_setName(_tokenName);
_setSymbol(_tokenSymbol);
_setDecimals(_underlyingAssetDecimals);
}
}

11
contracts/mocks/upgradeability/MockStableDebtToken.sol
View File

@ -4,17 +4,6 @@ pragma solidity 0.6.12;
import {StableDebtToken} from '../../protocol/tokenization/StableDebtToken.sol';
contract MockStableDebtToken is StableDebtToken {
constructor(
address _pool,
address _underlyingAssetAddress,
string memory _tokenName,
string memory _tokenSymbol,
address incentivesController
)
public
StableDebtToken(_pool, _underlyingAssetAddress, _tokenName, _tokenSymbol, incentivesController)
{}
function getRevision() internal pure override returns (uint256) {
return 0x2;
}

17
contracts/mocks/upgradeability/MockVariableDebtToken.sol
View File

@ -4,23 +4,6 @@ pragma solidity 0.6.12;
import {VariableDebtToken} from '../../protocol/tokenization/VariableDebtToken.sol';
contract MockVariableDebtToken is VariableDebtToken {
constructor(
address _pool,
address _underlyingAssetAddress,
string memory _tokenName,
string memory _tokenSymbol,
address incentivesController
)
public
VariableDebtToken(
_pool,
_underlyingAssetAddress,
_tokenName,
_tokenSymbol,
incentivesController
)
{}
function getRevision() internal pure override returns (uint256) {
return 0x2;
}

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

@ -7,6 +7,8 @@ import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {ILendingRateOracle} from '../../interfaces/ILendingRateOracle.sol';
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import 'hardhat/console.sol';
/**
* @title DefaultReserveInterestRateStrategy contract
@ -96,6 +98,51 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
return _baseVariableBorrowRate.add(_variableRateSlope1).add(_variableRateSlope2);
}
/**
* @dev Calculates the interest rates depending on the reserve's state and configurations
* @param reserve The address of the reserve
* @param liquidityAdded The liquidity added during the operation
* @param liquidityTaken The liquidity taken during the operation
* @param totalStableDebt The total borrowed from the reserve a stable rate
* @param totalVariableDebt The total borrowed from the reserve at a variable rate
* @param averageStableBorrowRate The weighted average of all the stable rate loans
* @param reserveFactor The reserve portion of the interest that goes to the treasury of the market
* @return The liquidity rate, the stable borrow rate and the variable borrow rate
**/
function calculateInterestRates(
address reserve,
address aToken,
uint256 liquidityAdded,
uint256 liquidityTaken,
uint256 totalStableDebt,
uint256 totalVariableDebt,
uint256 averageStableBorrowRate,
uint256 reserveFactor
)
external
view
override
returns (
uint256,
uint256,
uint256
)
{
uint256 availableLiquidity = IERC20(reserve).balanceOf(aToken);
//avoid stack too deep
availableLiquidity = availableLiquidity.add(liquidityAdded).sub(liquidityTaken);
return
calculateInterestRates(
reserve,
availableLiquidity,
totalStableDebt,
totalVariableDebt,
averageStableBorrowRate,
reserveFactor
);
}
struct CalcInterestRatesLocalVars {
uint256 totalDebt;
uint256 currentVariableBorrowRate;
@ -105,9 +152,11 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
}
/**
* @dev Calculates the interest rates depending on the reserve's state and configurations
* @dev Calculates the interest rates depending on the reserve's state and configurations.
* NOTE This function is kept for compatibility with the previous DefaultInterestRateStrategy interface.
* New protocol implementation uses the new calculateInterestRates() interface
* @param reserve The address of the reserve
* @param availableLiquidity The liquidity available in the reserve
* @param availableLiquidity The liquidity available in the corresponding aToken
* @param totalStableDebt The total borrowed from the reserve a stable rate
* @param totalVariableDebt The total borrowed from the reserve at a variable rate
* @param averageStableBorrowRate The weighted average of all the stable rate loans
@ -122,7 +171,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
uint256 averageStableBorrowRate,
uint256 reserveFactor
)
external
public
view
override
returns (
@ -138,15 +187,16 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
vars.currentStableBorrowRate = 0;
vars.currentLiquidityRate = 0;
uint256 utilizationRate =
vars.totalDebt == 0 ? 0 : vars.totalDebt.rayDiv(availableLiquidity.add(vars.totalDebt));
vars.utilizationRate = vars.totalDebt == 0
? 0
: vars.totalDebt.rayDiv(availableLiquidity.add(vars.totalDebt));
vars.currentStableBorrowRate = ILendingRateOracle(addressesProvider.getLendingRateOracle())
.getMarketBorrowRate(reserve);
if (utilizationRate > OPTIMAL_UTILIZATION_RATE) {
if (vars.utilizationRate > OPTIMAL_UTILIZATION_RATE) {
uint256 excessUtilizationRateRatio =
utilizationRate.sub(OPTIMAL_UTILIZATION_RATE).rayDiv(EXCESS_UTILIZATION_RATE);
vars.utilizationRate.sub(OPTIMAL_UTILIZATION_RATE).rayDiv(EXCESS_UTILIZATION_RATE);
vars.currentStableBorrowRate = vars.currentStableBorrowRate.add(_stableRateSlope1).add(
_stableRateSlope2.rayMul(excessUtilizationRateRatio)
@ -157,10 +207,10 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
);
} else {
vars.currentStableBorrowRate = vars.currentStableBorrowRate.add(
_stableRateSlope1.rayMul(utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE))
_stableRateSlope1.rayMul(vars.utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE))
);
vars.currentVariableBorrowRate = _baseVariableBorrowRate.add(
utilizationRate.rayMul(_variableRateSlope1).rayDiv(OPTIMAL_UTILIZATION_RATE)
vars.utilizationRate.rayMul(_variableRateSlope1).rayDiv(OPTIMAL_UTILIZATION_RATE)
);
}
@ -171,7 +221,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
.currentVariableBorrowRate,
averageStableBorrowRate
)
.rayMul(utilizationRate)
.rayMul(vars.utilizationRate)
.percentMul(PercentageMath.PERCENTAGE_FACTOR.sub(reserveFactor));
return (

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

@ -49,10 +49,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
using PercentageMath for uint256;
using SafeERC20 for IERC20;
//main configuration parameters
uint256 public constant MAX_STABLE_RATE_BORROW_SIZE_PERCENT = 2500;
uint256 public constant FLASHLOAN_PREMIUM_TOTAL = 9;
uint256 public constant MAX_NUMBER_RESERVES = 128;
uint256 public constant LENDINGPOOL_REVISION = 0x2;
modifier whenNotPaused() {
@ -89,6 +85,9 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
**/
function initialize(ILendingPoolAddressesProvider provider) public initializer {
_addressesProvider = provider;
_maxStableRateBorrowSizePercent = 2500;
_flashLoanPremiumTotal = 9;
_maxNumberOfReserves = 128;
}
/**
@ -283,6 +282,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
IERC20(asset).safeTransferFrom(msg.sender, aToken, paybackAmount);
IAToken(aToken).handleRepayment(msg.sender, paybackAmount);
emit Repay(asset, onBehalfOf, msg.sender, paybackAmount);
return paybackAmount;
@ -500,7 +501,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
for (vars.i = 0; vars.i < assets.length; vars.i++) {
aTokenAddresses[vars.i] = _reserves[assets[vars.i]].aTokenAddress;
premiums[vars.i] = amounts[vars.i].mul(FLASHLOAN_PREMIUM_TOTAL).div(10000);
premiums[vars.i] = amounts[vars.i].mul(_flashLoanPremiumTotal).div(10000);
IAToken(aTokenAddresses[vars.i]).transferUnderlyingTo(receiverAddress, amounts[vars.i]);
}
@ -704,6 +705,27 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
return _addressesProvider;
}
/**
* @dev Returns the percentage of available liquidity that can be borrowed at once at stable rate
*/
function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() public view returns (uint256) {
return _maxStableRateBorrowSizePercent;
}
/**
* @dev Returns the fee on flash loans
*/
function FLASHLOAN_PREMIUM_TOTAL() public view returns (uint256) {
return _flashLoanPremiumTotal;
}
/**
* @dev Returns the maximum number of reserves supported to be listed in this LendingPool
*/
function MAX_NUMBER_RESERVES() public view returns (uint256) {
return _maxNumberOfReserves;
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
@ -848,7 +870,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
vars.amount,
amountInETH,
vars.interestRateMode,
MAX_STABLE_RATE_BORROW_SIZE_PERCENT,
_maxStableRateBorrowSizePercent,
_reserves,
userConfig,
_reservesList,
@ -910,7 +932,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
function _addReserveToList(address asset) internal {
uint256 reservesCount = _reservesCount;
require(reservesCount < MAX_NUMBER_RESERVES, Errors.LP_NO_MORE_RESERVES_ALLOWED);
require(reservesCount < _maxNumberOfReserves, Errors.LP_NO_MORE_RESERVES_ALLOWED);
bool reserveAlreadyAdded = _reserves[asset].id != 0 || _reservesList[0] == asset;

377
contracts/protocol/lendingpool/LendingPoolConfigurator.sol
View File

@ -10,11 +10,14 @@ import {
import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {ITokenConfiguration} from '../../interfaces/ITokenConfiguration.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
import {IInitializableDebtToken} from '../../interfaces/IInitializableDebtToken.sol';
import {IInitializableAToken} from '../../interfaces/IInitializableAToken.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
import {ILendingPoolConfigurator} from '../../interfaces/ILendingPoolConfigurator.sol';
/**
* @title LendingPoolConfigurator contract
@ -22,147 +25,11 @@ import {DataTypes} from '../libraries/types/DataTypes.sol';
* @dev Implements the configuration methods for the Aave protocol
**/
contract LendingPoolConfigurator is VersionedInitializable {
contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigurator {
using SafeMath for uint256;
using PercentageMath for uint256;
using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
/**
* @dev Emitted when a reserve is initialized.
* @param asset The address of the underlying asset of the reserve
* @param aToken The address of the associated aToken contract
* @param stableDebtToken The address of the associated stable rate debt token
* @param variableDebtToken The address of the associated variable rate debt token
* @param interestRateStrategyAddress The address of the interest rate strategy for the reserve
**/
event ReserveInitialized(
address indexed asset,
address indexed aToken,
address stableDebtToken,
address variableDebtToken,
address interestRateStrategyAddress
);
/**
* @dev Emitted when borrowing is enabled on a reserve
* @param asset The address of the underlying asset of the reserve
* @param stableRateEnabled True if stable rate borrowing is enabled, false otherwise
**/
event BorrowingEnabledOnReserve(address indexed asset, bool stableRateEnabled);
/**
* @dev Emitted when borrowing is disabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event BorrowingDisabledOnReserve(address indexed asset);
/**
* @dev Emitted when the collateralization risk parameters for the specified asset are updated.
* @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
**/
event CollateralConfigurationChanged(
address indexed asset,
uint256 ltv,
uint256 liquidationThreshold,
uint256 liquidationBonus
);
/**
* @dev Emitted when stable rate borrowing is enabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event StableRateEnabledOnReserve(address indexed asset);
/**
* @dev Emitted when stable rate borrowing is disabled on a reserve
* @param asset The address of the underlying asset of the reserve
**/
event StableRateDisabledOnReserve(address indexed asset);
/**
* @dev Emitted when a reserve is activated
* @param asset The address of the underlying asset of the reserve
**/
event ReserveActivated(address indexed asset);
/**
* @dev Emitted when a reserve is deactivated
* @param asset The address of the underlying asset of the reserve
**/
event ReserveDeactivated(address indexed asset);
/**
* @dev Emitted when a reserve is frozen
* @param asset The address of the underlying asset of the reserve
**/
event ReserveFrozen(address indexed asset);
/**
* @dev Emitted when a reserve is unfrozen
* @param asset The address of the underlying asset of the reserve
**/
event ReserveUnfrozen(address indexed asset);
/**
* @dev Emitted when a reserve factor is updated
* @param asset The address of the underlying asset of the reserve
* @param factor The new reserve factor
**/
event ReserveFactorChanged(address indexed asset, uint256 factor);
/**
* @dev Emitted when the reserve decimals are updated
* @param asset The address of the underlying asset of the reserve
* @param decimals The new decimals
**/
event ReserveDecimalsChanged(address indexed asset, uint256 decimals);
/**
* @dev Emitted when a reserve interest strategy contract is updated
* @param asset The address of the underlying asset of the reserve
* @param strategy The new address of the interest strategy contract
**/
event ReserveInterestRateStrategyChanged(address indexed asset, address strategy);
/**
* @dev Emitted when an aToken implementation is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The aToken proxy address
* @param implementation The new aToken implementation
**/
event ATokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
/**
* @dev Emitted when the implementation of a stable debt token is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The stable debt token proxy address
* @param implementation The new aToken implementation
**/
event StableDebtTokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
/**
* @dev Emitted when the implementation of a variable debt token is upgraded
* @param asset The address of the underlying asset of the reserve
* @param proxy The variable debt token proxy address
* @param implementation The new aToken implementation
**/
event VariableDebtTokenUpgraded(
address indexed asset,
address indexed proxy,
address indexed implementation
);
ILendingPoolAddressesProvider internal addressesProvider;
ILendingPool internal pool;
@ -191,114 +58,189 @@ contract LendingPoolConfigurator is VersionedInitializable {
}
/**
* @dev Initializes a reserve
* @param aTokenImpl The address of the aToken contract implementation
* @param stableDebtTokenImpl The address of the stable debt token contract
* @param variableDebtTokenImpl The address of the variable debt token contract
* @param underlyingAssetDecimals The decimals of the reserve underlying asset
* @param interestRateStrategyAddress The address of the interest rate strategy contract for this reserve
* @dev Initializes reserves in batch
**/
function initReserve(
address aTokenImpl,
address stableDebtTokenImpl,
address variableDebtTokenImpl,
uint8 underlyingAssetDecimals,
address interestRateStrategyAddress
) public onlyPoolAdmin {
address asset = ITokenConfiguration(aTokenImpl).UNDERLYING_ASSET_ADDRESS();
function batchInitReserve(InitReserveInput[] calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
for (uint256 i = 0; i < input.length; i++) {
_initReserve(cachedPool, input[i]);
}
}
require(
address(pool) == ITokenConfiguration(aTokenImpl).POOL(),
Errors.LPC_INVALID_ATOKEN_POOL_ADDRESS
);
require(
address(pool) == ITokenConfiguration(stableDebtTokenImpl).POOL(),
Errors.LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS
);
require(
address(pool) == ITokenConfiguration(variableDebtTokenImpl).POOL(),
Errors.LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS
);
require(
asset == ITokenConfiguration(stableDebtTokenImpl).UNDERLYING_ASSET_ADDRESS(),
Errors.LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS
);
require(
asset == ITokenConfiguration(variableDebtTokenImpl).UNDERLYING_ASSET_ADDRESS(),
Errors.LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS
);
address aTokenProxyAddress = _initTokenWithProxy(aTokenImpl, underlyingAssetDecimals);
function _initReserve(ILendingPool pool, InitReserveInput calldata input) internal {
address aTokenProxyAddress =
_initTokenWithProxy(
input.aTokenImpl,
abi.encodeWithSelector(
IInitializableAToken.initialize.selector,
pool,
input.treasury,
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.aTokenName,
input.aTokenSymbol,
input.params
)
);
address stableDebtTokenProxyAddress =
_initTokenWithProxy(stableDebtTokenImpl, underlyingAssetDecimals);
_initTokenWithProxy(
input.stableDebtTokenImpl,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
pool,
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.stableDebtTokenName,
input.stableDebtTokenSymbol,
input.params
)
);
address variableDebtTokenProxyAddress =
_initTokenWithProxy(variableDebtTokenImpl, underlyingAssetDecimals);
_initTokenWithProxy(
input.variableDebtTokenImpl,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
pool,
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.variableDebtTokenName,
input.variableDebtTokenSymbol,
input.params
)
);
pool.initReserve(
asset,
input.underlyingAsset,
aTokenProxyAddress,
stableDebtTokenProxyAddress,
variableDebtTokenProxyAddress,
interestRateStrategyAddress
input.interestRateStrategyAddress
);
DataTypes.ReserveConfigurationMap memory currentConfig = pool.getConfiguration(asset);
DataTypes.ReserveConfigurationMap memory currentConfig =
pool.getConfiguration(input.underlyingAsset);
currentConfig.setDecimals(underlyingAssetDecimals);
currentConfig.setDecimals(input.underlyingAssetDecimals);
currentConfig.setActive(true);
currentConfig.setFrozen(false);
pool.setConfiguration(asset, currentConfig.data);
pool.setConfiguration(input.underlyingAsset, currentConfig.data);
emit ReserveInitialized(
asset,
input.underlyingAsset,
aTokenProxyAddress,
stableDebtTokenProxyAddress,
variableDebtTokenProxyAddress,
interestRateStrategyAddress
input.interestRateStrategyAddress
);
}
/**
* @dev Updates the aToken implementation for the reserve
* @param asset The address of the underlying asset of the reserve to be updated
* @param implementation The address of the new aToken implementation
**/
function updateAToken(address asset, address implementation) external onlyPoolAdmin {
DataTypes.ReserveData memory reserveData = pool.getReserveData(asset);
function updateAToken(UpdateATokenInput calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
_upgradeTokenImplementation(asset, reserveData.aTokenAddress, implementation);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
emit ATokenUpgraded(asset, reserveData.aTokenAddress, implementation);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
bytes memory encodedCall = abi.encodeWithSelector(
IInitializableAToken.initialize.selector,
cachedPool,
input.treasury,
input.asset,
input.incentivesController,
decimals,
input.name,
input.symbol,
input.params
);
_upgradeTokenImplementation(
reserveData.aTokenAddress,
input.implementation,
encodedCall
);
emit ATokenUpgraded(input.asset, reserveData.aTokenAddress, input.implementation);
}
/**
* @dev Updates the stable debt token implementation for the reserve
* @param asset The address of the underlying asset of the reserve to be updated
* @param implementation The address of the new aToken implementation
**/
function updateStableDebtToken(address asset, address implementation) external onlyPoolAdmin {
DataTypes.ReserveData memory reserveData = pool.getReserveData(asset);
function updateStableDebtToken(UpdateDebtTokenInput calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
_upgradeTokenImplementation(asset, reserveData.stableDebtTokenAddress, implementation);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
emit StableDebtTokenUpgraded(asset, reserveData.stableDebtTokenAddress, implementation);
bytes memory encodedCall = abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
input.asset,
input.incentivesController,
decimals,
input.name,
input.symbol,
input.params
);
_upgradeTokenImplementation(
reserveData.stableDebtTokenAddress,
input.implementation,
encodedCall
);
emit StableDebtTokenUpgraded(
input.asset,
reserveData.stableDebtTokenAddress,
input.implementation
);
}
/**
* @dev Updates the variable debt token implementation for the asset
* @param asset The address of the underlying asset of the reserve to be updated
* @param implementation The address of the new aToken implementation
**/
function updateVariableDebtToken(address asset, address implementation) external onlyPoolAdmin {
DataTypes.ReserveData memory reserveData = pool.getReserveData(asset);
function updateVariableDebtToken(UpdateDebtTokenInput calldata input)
external
onlyPoolAdmin
{
ILendingPool cachedPool = pool;
_upgradeTokenImplementation(asset, reserveData.variableDebtTokenAddress, implementation);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
emit VariableDebtTokenUpgraded(asset, reserveData.variableDebtTokenAddress, implementation);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
bytes memory encodedCall = abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
input.asset,
input.incentivesController,
decimals,
input.name,
input.symbol,
input.params
);
_upgradeTokenImplementation(
reserveData.variableDebtTokenAddress,
input.implementation,
encodedCall
);
emit VariableDebtTokenUpgraded(
input.asset,
reserveData.variableDebtTokenAddress,
input.implementation
);
}
/**
@ -509,44 +451,27 @@ contract LendingPoolConfigurator is VersionedInitializable {
pool.setPause(val);
}
function _initTokenWithProxy(address implementation, uint8 decimals) internal returns (address) {
function _initTokenWithProxy(address implementation, bytes memory initParams)
internal
returns (address)
{
InitializableImmutableAdminUpgradeabilityProxy proxy =
new InitializableImmutableAdminUpgradeabilityProxy(address(this));
bytes memory params =
abi.encodeWithSignature(
'initialize(uint8,string,string)',
decimals,
IERC20Detailed(implementation).name(),
IERC20Detailed(implementation).symbol()
);
proxy.initialize(implementation, params);
proxy.initialize(implementation, initParams);
return address(proxy);
}
function _upgradeTokenImplementation(
address asset,
address proxyAddress,
address implementation
address implementation,
bytes memory initParams
) internal {
InitializableImmutableAdminUpgradeabilityProxy proxy =
InitializableImmutableAdminUpgradeabilityProxy(payable(proxyAddress));
DataTypes.ReserveConfigurationMap memory configuration = pool.getConfiguration(asset);
(, , , uint256 decimals, ) = configuration.getParamsMemory();
bytes memory params =
abi.encodeWithSignature(
'initialize(uint8,string,string)',
uint8(decimals),
IERC20Detailed(implementation).name(),
IERC20Detailed(implementation).symbol()
);
proxy.upgradeToAndCall(implementation, params);
proxy.upgradeToAndCall(implementation, initParams);
}
function _checkNoLiquidity(address asset) internal view {

6
contracts/protocol/lendingpool/LendingPoolStorage.sol
View File

@ -23,4 +23,10 @@ contract LendingPoolStorage {
uint256 internal _reservesCount;
bool internal _paused;
uint256 internal _maxStableRateBorrowSizePercent;
uint256 internal _flashLoanPremiumTotal;
uint256 internal _maxNumberOfReserves;
}

6
contracts/protocol/libraries/logic/ReserveLogic.sol
View File

@ -216,15 +216,15 @@ library ReserveLogic {
.scaledTotalSupply()
.rayMul(reserve.variableBorrowIndex);
vars.availableLiquidity = IERC20(reserveAddress).balanceOf(aTokenAddress);
(
vars.newLiquidityRate,
vars.newStableRate,
vars.newVariableRate
) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates(
reserveAddress,
vars.availableLiquidity.add(liquidityAdded).sub(liquidityTaken),
aTokenAddress,
liquidityAdded,
liquidityTaken,
vars.totalStableDebt,
vars.totalVariableDebt,
vars.avgStableRate,

152
contracts/protocol/tokenization/AToken.sol
View File

@ -9,13 +9,18 @@ import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol';
import {IncentivizedERC20} from './IncentivizedERC20.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
/**
* @title Aave ERC20 AToken
* @dev Implementation of the interest bearing token for the Aave protocol
* @author Aave
*/
contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
contract AToken is
VersionedInitializable,
IncentivizedERC20('ATOKEN_IMPL', 'ATOKEN_IMPL', 0),
IAToken
{
using WadRayMath for uint256;
using SafeERC20 for IERC20;
@ -25,44 +30,47 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
bytes32 public constant PERMIT_TYPEHASH =
keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)');
uint256 public constant UINT_MAX_VALUE = uint256(-1);
uint256 public constant ATOKEN_REVISION = 0x1;
address public immutable UNDERLYING_ASSET_ADDRESS;
address public immutable RESERVE_TREASURY_ADDRESS;
ILendingPool public immutable POOL;
/// @dev owner => next valid nonce to submit with permit()
mapping(address => uint256) public _nonces;
bytes32 public DOMAIN_SEPARATOR;
modifier onlyLendingPool {
require(_msgSender() == address(POOL), Errors.CT_CALLER_MUST_BE_LENDING_POOL);
_;
}
ILendingPool internal _pool;
address internal _treasury;
address internal _underlyingAsset;
IAaveIncentivesController internal _incentivesController;
constructor(
ILendingPool pool,
address underlyingAssetAddress,
address reserveTreasuryAddress,
string memory tokenName,
string memory tokenSymbol,
address incentivesController
) public IncentivizedERC20(tokenName, tokenSymbol, 18, incentivesController) {
POOL = pool;
UNDERLYING_ASSET_ADDRESS = underlyingAssetAddress;
RESERVE_TREASURY_ADDRESS = reserveTreasuryAddress;
modifier onlyLendingPool {
require(_msgSender() == address(_pool), Errors.CT_CALLER_MUST_BE_LENDING_POOL);
_;
}
function getRevision() internal pure virtual override returns (uint256) {
return ATOKEN_REVISION;
}
/**
* @dev Initializes the aToken
* @param pool The address of the lending pool where this aToken will be used
* @param treasury The address of the Aave treasury, receiving the fees on this aToken
* @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
* @param incentivesController The smart contract managing potential incentives distribution
* @param aTokenDecimals The decimals of the aToken, same as the underlying asset's
* @param aTokenName The name of the aToken
* @param aTokenSymbol The symbol of the aToken
*/
function initialize(
uint8 underlyingAssetDecimals,
string calldata tokenName,
string calldata tokenSymbol
) external virtual initializer {
ILendingPool pool,
address treasury,
address underlyingAsset,
IAaveIncentivesController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol,
bytes calldata params
) external override initializer {
uint256 chainId;
//solium-disable-next-line
@ -73,16 +81,32 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
DOMAIN_SEPARATOR = keccak256(
abi.encode(
EIP712_DOMAIN,
keccak256(bytes(tokenName)),
keccak256(bytes(aTokenName)),
keccak256(EIP712_REVISION),
chainId,
address(this)
)
);
_setName(tokenName);
_setSymbol(tokenSymbol);
_setDecimals(underlyingAssetDecimals);
_setName(aTokenName);
_setSymbol(aTokenSymbol);
_setDecimals(aTokenDecimals);
_pool = pool;
_treasury = treasury;
_underlyingAsset = underlyingAsset;
_incentivesController = incentivesController;
emit Initialized(
underlyingAsset,
address(pool),
treasury,
address(incentivesController),
aTokenDecimals,
aTokenName,
aTokenSymbol,
params
);
}
/**
@ -103,7 +127,7 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
require(amountScaled != 0, Errors.CT_INVALID_BURN_AMOUNT);
_burn(user, amountScaled);
IERC20(UNDERLYING_ASSET_ADDRESS).safeTransfer(receiverOfUnderlying, amount);
IERC20(_underlyingAsset).safeTransfer(receiverOfUnderlying, amount);
emit Transfer(user, address(0), amount);
emit Burn(user, receiverOfUnderlying, amount, index);
@ -145,14 +169,16 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
return;
}
address treasury = _treasury;
// Compared to the normal mint, we don't check for rounding errors.
// The amount to mint can easily be very small since it is a fraction of the interest ccrued.
// In that case, the treasury will experience a (very small) loss, but it
// wont cause potentially valid transactions to fail.
_mint(RESERVE_TREASURY_ADDRESS, amount.rayDiv(index));
_mint(treasury, amount.rayDiv(index));
emit Transfer(address(0), RESERVE_TREASURY_ADDRESS, amount);
emit Mint(RESERVE_TREASURY_ADDRESS, amount, index);
emit Transfer(address(0), treasury, amount);
emit Mint(treasury, amount, index);
}
/**
@ -185,7 +211,7 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
override(IncentivizedERC20, IERC20)
returns (uint256)
{
return super.balanceOf(user).rayMul(POOL.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS));
return super.balanceOf(user).rayMul(_pool.getReserveNormalizedIncome(_underlyingAsset));
}
/**
@ -226,7 +252,7 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
return 0;
}
return currentSupplyScaled.rayMul(POOL.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS));
return currentSupplyScaled.rayMul(_pool.getReserveNormalizedIncome(_underlyingAsset));
}
/**
@ -237,6 +263,41 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
return super.totalSupply();
}
/**
* @dev Returns the address of the Aave treasury, receiving the fees on this aToken
**/
function RESERVE_TREASURY_ADDRESS() public view returns (address) {
return _treasury;
}
/**
* @dev Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
**/
function UNDERLYING_ASSET_ADDRESS() public view returns (address) {
return _underlyingAsset;
}
/**
* @dev Returns the address of the lending pool where this aToken is used
**/
function POOL() public view returns (ILendingPool) {
return _pool;
}
/**
* @dev For internal usage in the logic of the parent contract IncentivizedERC20
**/
function _getIncentivesController() internal view override returns (IAaveIncentivesController) {
return _incentivesController;
}
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view override returns (IAaveIncentivesController) {
return _getIncentivesController();
}
/**
* @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer
* assets in borrow(), withdraw() and flashLoan()
@ -250,10 +311,17 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
onlyLendingPool
returns (uint256)
{
IERC20(UNDERLYING_ASSET_ADDRESS).safeTransfer(target, amount);
IERC20(_underlyingAsset).safeTransfer(target, amount);
return amount;
}
/**
* @dev Invoked to execute actions on the aToken side after a repayment.
* @param user The user executing the repayment
* @param amount The amount getting repaid
**/
function handleRepayment(address user, uint256 amount) external override onlyLendingPool {}
/**
* @dev implements the permit function as for
* https://github.com/ethereum/EIPs/blob/8a34d644aacf0f9f8f00815307fd7dd5da07655f/EIPS/eip-2612.md
@ -305,7 +373,10 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
uint256 amount,
bool validate
) internal {
uint256 index = POOL.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
address underlyingAsset = _underlyingAsset;
ILendingPool pool = _pool;
uint256 index = pool.getReserveNormalizedIncome(underlyingAsset);
uint256 fromBalanceBefore = super.balanceOf(from).rayMul(index);
uint256 toBalanceBefore = super.balanceOf(to).rayMul(index);
@ -313,14 +384,7 @@ contract AToken is VersionedInitializable, IncentivizedERC20, IAToken {
super._transfer(from, to, amount.rayDiv(index));
if (validate) {
POOL.finalizeTransfer(
UNDERLYING_ASSET_ADDRESS,
from,
to,
amount,
fromBalanceBefore,
toBalanceBefore
);
pool.finalizeTransfer(underlyingAsset, from, to, amount, fromBalanceBefore, toBalanceBefore);
}
emit BalanceTransfer(from, to, amount, index);

23
contracts/protocol/tokenization/DelegationAwareAToken.sol
View File

@ -14,36 +14,17 @@ import {AToken} from './AToken.sol';
contract DelegationAwareAToken is AToken {
modifier onlyPoolAdmin {
require(
_msgSender() == ILendingPool(POOL).getAddressesProvider().getPoolAdmin(),
_msgSender() == ILendingPool(_pool).getAddressesProvider().getPoolAdmin(),
Errors.CALLER_NOT_POOL_ADMIN
);
_;
}
constructor(
ILendingPool pool,
address underlyingAssetAddress,
address reserveTreasury,
string memory tokenName,
string memory tokenSymbol,
address incentivesController
)
public
AToken(
pool,
underlyingAssetAddress,
reserveTreasury,
tokenName,
tokenSymbol,
incentivesController
)
{}
/**
* @dev Delegates voting power of the underlying asset to a `delegatee` address
* @param delegatee The address that will receive the delegation
**/
function delegateUnderlyingTo(address delegatee) external onlyPoolAdmin {
IDelegationToken(UNDERLYING_ASSET_ADDRESS).delegate(delegatee);
IDelegationToken(_underlyingAsset).delegate(delegatee);
}
}

28
contracts/protocol/tokenization/IncentivizedERC20.sol
View File

@ -12,11 +12,9 @@ import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesControl
* @notice Basic ERC20 implementation
* @author Aave, inspired by the Openzeppelin ERC20 implementation
**/
contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
abstract contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
using SafeMath for uint256;
IAaveIncentivesController internal immutable _incentivesController;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) private _allowances;
@ -28,13 +26,11 @@ contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
constructor(
string memory name,
string memory symbol,
uint8 decimals,
address incentivesController
uint8 decimals
) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_incentivesController = IAaveIncentivesController(incentivesController);
}
/**
@ -72,6 +68,12 @@ contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
return _balances[account];
}
/**
* @return Abstract function implemented by the child aToken/debtToken.
* Done this way in order to not break compatibility with previous versions of aTokens/debtTokens
**/
function _getIncentivesController() internal view virtual returns(IAaveIncentivesController);
/**
* @dev Executes a transfer of tokens from _msgSender() to recipient
* @param recipient The recipient of the tokens
@ -180,11 +182,11 @@ contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
uint256 oldRecipientBalance = _balances[recipient];
_balances[recipient] = _balances[recipient].add(amount);
if (address(_incentivesController) != address(0)) {
if (address(_getIncentivesController()) != address(0)) {
uint256 currentTotalSupply = _totalSupply;
_incentivesController.handleAction(sender, currentTotalSupply, oldSenderBalance);
_getIncentivesController().handleAction(sender, currentTotalSupply, oldSenderBalance);
if (sender != recipient) {
_incentivesController.handleAction(recipient, currentTotalSupply, oldRecipientBalance);
_getIncentivesController().handleAction(recipient, currentTotalSupply, oldRecipientBalance);
}
}
}
@ -200,8 +202,8 @@ contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
uint256 oldAccountBalance = _balances[account];
_balances[account] = oldAccountBalance.add(amount);
if (address(_incentivesController) != address(0)) {
_incentivesController.handleAction(account, oldTotalSupply, oldAccountBalance);
if (address(_getIncentivesController()) != address(0)) {
_getIncentivesController().handleAction(account, oldTotalSupply, oldAccountBalance);
}
}
@ -216,8 +218,8 @@ contract IncentivizedERC20 is Context, IERC20, IERC20Detailed {
uint256 oldAccountBalance = _balances[account];
_balances[account] = oldAccountBalance.sub(amount, 'ERC20: burn amount exceeds balance');
if (address(_incentivesController) != address(0)) {
_incentivesController.handleAction(account, oldTotalSupply, oldAccountBalance);
if (address(_getIncentivesController()) != address(0)) {
_getIncentivesController().handleAction(account, oldTotalSupply, oldAccountBalance);
}
}

89
contracts/protocol/tokenization/StableDebtToken.sol
View File

@ -5,6 +5,8 @@ import {DebtTokenBase} from './base/DebtTokenBase.sol';
import {MathUtils} from '../libraries/math/MathUtils.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {IStableDebtToken} from '../../interfaces/IStableDebtToken.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
/**
@ -23,13 +25,46 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
mapping(address => uint256) internal _usersStableRate;
uint40 internal _totalSupplyTimestamp;
constructor(
address pool,
ILendingPool internal _pool;
address internal _underlyingAsset;
IAaveIncentivesController internal _incentivesController;
/**
* @dev Initializes the debt token.
* @param pool The address of the lending pool where this aToken will be used
* @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
* @param incentivesController The smart contract managing potential incentives distribution
* @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
* @param debtTokenName The name of the token
* @param debtTokenSymbol The symbol of the token
*/
function initialize(
ILendingPool pool,
address underlyingAsset,
string memory name,
string memory symbol,
address incentivesController
) public DebtTokenBase(pool, underlyingAsset, name, symbol, incentivesController) {}
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol,
bytes calldata params
) public override initializer {
_setName(debtTokenName);
_setSymbol(debtTokenSymbol);
_setDecimals(debtTokenDecimals);
_pool = pool;
_underlyingAsset = underlyingAsset;
_incentivesController = incentivesController;
emit Initialized(
underlyingAsset,
address(pool),
address(incentivesController),
debtTokenDecimals,
debtTokenName,
debtTokenSymbol,
params
);
}
/**
* @dev Gets the revision of the stable debt token implementation
@ -300,6 +335,48 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
return super.balanceOf(user);
}
/**
* @dev Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
**/
function UNDERLYING_ASSET_ADDRESS() public view returns (address) {
return _underlyingAsset;
}
/**
* @dev Returns the address of the lending pool where this aToken is used
**/
function POOL() public view returns (ILendingPool) {
return _pool;
}
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view override returns (IAaveIncentivesController) {
return _getIncentivesController();
}
/**
* @dev For internal usage in the logic of the parent contracts
**/
function _getIncentivesController() internal view override returns (IAaveIncentivesController) {
return _incentivesController;
}
/**
* @dev For internal usage in the logic of the parent contracts
**/
function _getUnderlyingAssetAddress() internal view override returns (address) {
return _underlyingAsset;
}
/**
* @dev For internal usage in the logic of the parent contracts
**/
function _getLendingPool() internal view override returns (ILendingPool) {
return _pool;
}
/**
* @dev Calculates the total supply
* @param avgRate The average rate at which the total supply increases

85
contracts/protocol/tokenization/VariableDebtToken.sol
View File

@ -5,6 +5,8 @@ import {IVariableDebtToken} from '../../interfaces/IVariableDebtToken.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DebtTokenBase} from './base/DebtTokenBase.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
/**
* @title VariableDebtToken
@ -17,13 +19,46 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
uint256 public constant DEBT_TOKEN_REVISION = 0x1;
constructor(
address pool,
ILendingPool internal _pool;
address internal _underlyingAsset;
IAaveIncentivesController internal _incentivesController;
/**
* @dev Initializes the debt token.
* @param pool The address of the lending pool where this aToken will be used
* @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
* @param incentivesController The smart contract managing potential incentives distribution
* @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
* @param debtTokenName The name of the token
* @param debtTokenSymbol The symbol of the token
*/
function initialize(
ILendingPool pool,
address underlyingAsset,
string memory name,
string memory symbol,
address incentivesController
) public DebtTokenBase(pool, underlyingAsset, name, symbol, incentivesController) {}
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol,
bytes calldata params
) public override initializer {
_setName(debtTokenName);
_setSymbol(debtTokenSymbol);
_setDecimals(debtTokenDecimals);
_pool = pool;
_underlyingAsset = underlyingAsset;
_incentivesController = incentivesController;
emit Initialized(
underlyingAsset,
address(pool),
address(incentivesController),
debtTokenDecimals,
debtTokenName,
debtTokenSymbol,
params
);
}
/**
* @dev Gets the revision of the stable debt token implementation
@ -44,7 +79,7 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
return 0;
}
return scaledBalance.rayMul(POOL.getReserveNormalizedVariableDebt(UNDERLYING_ASSET_ADDRESS));
return scaledBalance.rayMul(_pool.getReserveNormalizedVariableDebt(_underlyingAsset));
}
/**
@ -113,8 +148,7 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
* @return The total supply
**/
function totalSupply() public view virtual override returns (uint256) {
return
super.totalSupply().rayMul(POOL.getReserveNormalizedVariableDebt(UNDERLYING_ASSET_ADDRESS));
return super.totalSupply().rayMul(_pool.getReserveNormalizedVariableDebt(_underlyingAsset));
}
/**
@ -139,4 +173,37 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
{
return (super.balanceOf(user), super.totalSupply());
}
/**
* @dev Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
**/
function UNDERLYING_ASSET_ADDRESS() public view returns (address) {
return _underlyingAsset;
}
/**
* @dev Returns the address of the incentives controller contract
**/
function getIncentivesController() external view override returns (IAaveIncentivesController) {
return _getIncentivesController();
}
/**
* @dev Returns the address of the lending pool where this aToken is used
**/
function POOL() public view returns (ILendingPool) {
return _pool;
}
function _getIncentivesController() internal view override returns (IAaveIncentivesController) {
return _incentivesController;
}
function _getUnderlyingAssetAddress() internal view override returns (address) {
return _underlyingAsset;
}
function _getLendingPool() internal view override returns (ILendingPool) {
return _pool;
}
}

46
contracts/protocol/tokenization/base/DebtTokenBase.sol
View File

@ -16,54 +16,20 @@ import {Errors} from '../../libraries/helpers/Errors.sol';
*/
abstract contract DebtTokenBase is
IncentivizedERC20,
IncentivizedERC20('DEBTTOKEN_IMPL', 'DEBTTOKEN_IMPL', 0),
VersionedInitializable,
ICreditDelegationToken
{
address public immutable UNDERLYING_ASSET_ADDRESS;
ILendingPool public immutable POOL;
mapping(address => mapping(address => uint256)) internal _borrowAllowances;
/**
* @dev Only lending pool can call functions marked by this modifier
**/
modifier onlyLendingPool {
require(_msgSender() == address(POOL), Errors.CT_CALLER_MUST_BE_LENDING_POOL);
require(_msgSender() == address(_getLendingPool()), Errors.CT_CALLER_MUST_BE_LENDING_POOL);
_;
}
/**
* @dev The metadata of the token will be set on the proxy, that the reason of
* passing "NULL" and 0 as metadata
*/
constructor(
address pool,
address underlyingAssetAddress,
string memory name,
string memory symbol,
address incentivesController
) public IncentivizedERC20(name, symbol, 18, incentivesController) {
POOL = ILendingPool(pool);
UNDERLYING_ASSET_ADDRESS = underlyingAssetAddress;
}
/**
* @dev Initializes the debt token.
* @param name The name of the token
* @param symbol The symbol of the token
* @param decimals The decimals of the token
*/
function initialize(
uint8 decimals,
string memory name,
string memory symbol
) public initializer {
_setName(name);
_setSymbol(symbol);
_setDecimals(decimals);
}
/**
* @dev delegates borrowing power to a user on the specific debt token
* @param delegatee the address receiving the delegated borrowing power
@ -73,7 +39,7 @@ abstract contract DebtTokenBase is
**/
function approveDelegation(address delegatee, uint256 amount) external override {
_borrowAllowances[_msgSender()][delegatee] = amount;
emit BorrowAllowanceDelegated(_msgSender(), delegatee, UNDERLYING_ASSET_ADDRESS, amount);
emit BorrowAllowanceDelegated(_msgSender(), delegatee, _getUnderlyingAssetAddress(), amount);
}
/**
@ -162,6 +128,10 @@ abstract contract DebtTokenBase is
_borrowAllowances[delegator][delegatee] = newAllowance;
emit BorrowAllowanceDelegated(delegator, delegatee, UNDERLYING_ASSET_ADDRESS, newAllowance);
emit BorrowAllowanceDelegated(delegator, delegatee, _getUnderlyingAssetAddress(), newAllowance);
}
function _getUnderlyingAssetAddress() internal view virtual returns (address);
function _getLendingPool() internal view virtual returns (ILendingPool);
}

2
docker-compose.yml
View File

@ -19,3 +19,5 @@ services:
TENDERLY_PROJECT: ${TENDERLY_PROJECT}
TENDERLY_USERNAME: ${TENDERLY_USERNAME}
ALCHEMY_KEY: ${ALCHEMY_KEY}
TENDERLY_FORK_ID: ${TENDERLY_FORK_ID}
TENDERLY_HEAD_ID: ${TENDERLY_HEAD_ID}

50
hardhat.config.ts
View File

@ -3,8 +3,9 @@ import fs from 'fs';
import { HardhatUserConfig } from 'hardhat/types';
// @ts-ignore
import { accounts } from './test-wallets.js';
import { eEthereumNetwork } from './helpers/types';
import { eEthereumNetwork, eNetwork, ePolygonNetwork, eXDaiNetwork } from './helpers/types';
import { BUIDLEREVM_CHAINID, COVERAGE_CHAINID } from './helpers/buidler-constants';
import { NETWORKS_RPC_URL, NETWORKS_DEFAULT_GAS } from './helper-hardhat-config';
require('dotenv').config();
@ -18,10 +19,7 @@ import '@tenderly/hardhat-tenderly';
const SKIP_LOAD = process.env.SKIP_LOAD === 'true';
const DEFAULT_BLOCK_GAS_LIMIT = 12450000;
const DEFAULT_GAS_MUL = 5;
const DEFAULT_GAS_PRICE = 65000000000;
const HARDFORK = 'istanbul';
const INFURA_KEY = process.env.INFURA_KEY || '';
const ALCHEMY_KEY = process.env.ALCHEMY_KEY || '';
const ETHERSCAN_KEY = process.env.ETHERSCAN_KEY || '';
const MNEMONIC_PATH = "m/44'/60'/0'/0";
const MNEMONIC = process.env.MNEMONIC || '';
@ -43,32 +41,25 @@ if (!SKIP_LOAD) {
require(`${path.join(__dirname, 'tasks/misc')}/set-bre.ts`);
const getCommonNetworkConfig = (networkName: eEthereumNetwork, networkId: number) => {
const net = networkName === 'main' ? 'mainnet' : networkName;
return {
url: ALCHEMY_KEY
? `https://eth-${net}.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://${net}.infura.io/v3/${INFURA_KEY}`,
hardfork: HARDFORK,
blockGasLimit: DEFAULT_BLOCK_GAS_LIMIT,
gasMultiplier: DEFAULT_GAS_MUL,
gasPrice: DEFAULT_GAS_PRICE,
chainId: networkId,
accounts: {
mnemonic: MNEMONIC,
path: MNEMONIC_PATH,
initialIndex: 0,
count: 20,
},
};
};
const getCommonNetworkConfig = (networkName: eNetwork, networkId: number) => ({
url: NETWORKS_RPC_URL[networkName],
hardfork: HARDFORK,
blockGasLimit: DEFAULT_BLOCK_GAS_LIMIT,
gasMultiplier: DEFAULT_GAS_MUL,
gasPrice: NETWORKS_DEFAULT_GAS[networkName],
chainId: networkId,
accounts: {
mnemonic: MNEMONIC,
path: MNEMONIC_PATH,
initialIndex: 0,
count: 20,
},
});
const mainnetFork = MAINNET_FORK
? {
blockNumber: 11608298,
url: ALCHEMY_KEY
? `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://mainnet.infura.io/v3/${INFURA_KEY}`,
blockNumber: 11739065,
url: NETWORKS_RPC_URL['main'],
}
: undefined;
@ -103,7 +94,10 @@ const buidlerConfig: HardhatUserConfig = {
kovan: getCommonNetworkConfig(eEthereumNetwork.kovan, 42),
ropsten: getCommonNetworkConfig(eEthereumNetwork.ropsten, 3),
main: getCommonNetworkConfig(eEthereumNetwork.main, 1),
tenderlyMain: getCommonNetworkConfig(eEthereumNetwork.main, 1),
tenderlyMain: getCommonNetworkConfig(eEthereumNetwork.tenderlyMain, 3030),
matic: getCommonNetworkConfig(ePolygonNetwork.matic, 137),
mumbai: getCommonNetworkConfig(ePolygonNetwork.mumbai, 80001),
xdai: getCommonNetworkConfig(eXDaiNetwork.xdai, 100),
hardhat: {
hardfork: 'istanbul',
blockGasLimit: DEFAULT_BLOCK_GAS_LIMIT,

47
helper-hardhat-config.ts Normal file
View File

@ -0,0 +1,47 @@
// @ts-ignore
import {
eEthereumNetwork,
ePolygonNetwork,
eXDaiNetwork,
iParamsPerNetwork,
} from './helpers/types';
require('dotenv').config();
const INFURA_KEY = process.env.INFURA_KEY || '';
const ALCHEMY_KEY = process.env.ALCHEMY_KEY || '';
const TENDERLY_FORK_ID = process.env.TENDERLY_FORK_ID || '';
const GWEI = 1000 * 1000 * 1000;
export const NETWORKS_RPC_URL: iParamsPerNetwork<string> = {
[eEthereumNetwork.kovan]: ALCHEMY_KEY
? `https://eth-kovan.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://kovan.infura.io/v3/${INFURA_KEY}`,
[eEthereumNetwork.ropsten]: ALCHEMY_KEY
? `https://eth-ropsten.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://ropsten.infura.io/v3/${INFURA_KEY}`,
[eEthereumNetwork.main]: ALCHEMY_KEY
? `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://mainnet.infura.io/v3/${INFURA_KEY}`,
[eEthereumNetwork.coverage]: 'http://localhost:8555',
[eEthereumNetwork.hardhat]: 'http://localhost:8545',
[eEthereumNetwork.buidlerevm]: 'http://localhost:8545',
[eEthereumNetwork.tenderlyMain]: `https://rpc.tenderly.co/fork/${TENDERLY_FORK_ID}`,
[ePolygonNetwork.mumbai]: 'https://rpc-mumbai.maticvigil.com',
[ePolygonNetwork.matic]: 'https://rpc-mainnet.matic.network',
[eXDaiNetwork.xdai]: 'https://rpc.xdaichain.com/',
};
export const NETWORKS_DEFAULT_GAS: iParamsPerNetwork<number> = {
[eEthereumNetwork.kovan]: 65 * GWEI,
[eEthereumNetwork.ropsten]: 65 * GWEI,
[eEthereumNetwork.main]: 65 * GWEI,
[eEthereumNetwork.coverage]: 65 * GWEI,
[eEthereumNetwork.hardhat]: 65 * GWEI,
[eEthereumNetwork.buidlerevm]: 65 * GWEI,
[eEthereumNetwork.tenderlyMain]: 0.01 * GWEI,
[ePolygonNetwork.mumbai]: 1 * GWEI,
[ePolygonNetwork.matic]: 2 * GWEI,
[eXDaiNetwork.xdai]: 1 * GWEI,
};

27
helpers/configuration.ts
View File

@ -4,10 +4,12 @@ import {
IReserveParams,
PoolConfiguration,
ICommonConfiguration,
eEthereumNetwork,
eNetwork,
} from './types';
import { getParamPerPool } from './contracts-helpers';
import AaveConfig from '../markets/aave';
import MaticConfig from '../markets/matic';
import AmmConfig from '../markets/amm';
import { CommonsConfig } from '../markets/aave/commons';
import { DRE, filterMapBy } from './misc-utils';
import { tEthereumAddress } from './types';
@ -17,13 +19,18 @@ import { deployWETHMocked } from './contracts-deployments';
export enum ConfigNames {
Commons = 'Commons',
Aave = 'Aave',
Uniswap = 'Uniswap',
Matic = 'Matic',
Amm = 'Amm',
}
export const loadPoolConfig = (configName: ConfigNames): PoolConfiguration => {
switch (configName) {
case ConfigNames.Aave:
return AaveConfig;
case ConfigNames.Matic:
return MaticConfig;
case ConfigNames.Amm:
return AmmConfig;
case ConfigNames.Commons:
return CommonsConfig;
default:
@ -41,6 +48,12 @@ export const getReservesConfigByPool = (pool: AavePools): iMultiPoolsAssets<IRes
[AavePools.proto]: {
...AaveConfig.ReservesConfig,
},
[AavePools.amm]: {
...AmmConfig.ReservesConfig,
},
[AavePools.matic]: {
...MaticConfig.ReservesConfig,
},
},
pool
);
@ -49,7 +62,7 @@ export const getGenesisPoolAdmin = async (
config: ICommonConfiguration
): Promise<tEthereumAddress> => {
const currentNetwork = process.env.MAINNET_FORK === 'true' ? 'main' : DRE.network.name;
const targetAddress = getParamPerNetwork(config.PoolAdmin, <eEthereumNetwork>currentNetwork);
const targetAddress = getParamPerNetwork(config.PoolAdmin, <eNetwork>currentNetwork);
if (targetAddress) {
return targetAddress;
}
@ -64,7 +77,7 @@ export const getEmergencyAdmin = async (
config: ICommonConfiguration
): Promise<tEthereumAddress> => {
const currentNetwork = process.env.MAINNET_FORK === 'true' ? 'main' : DRE.network.name;
const targetAddress = getParamPerNetwork(config.EmergencyAdmin, <eEthereumNetwork>currentNetwork);
const targetAddress = getParamPerNetwork(config.EmergencyAdmin, <eNetwork>currentNetwork);
if (targetAddress) {
return targetAddress;
}
@ -79,17 +92,17 @@ export const getTreasuryAddress = async (
config: ICommonConfiguration
): Promise<tEthereumAddress> => {
const currentNetwork = process.env.MAINNET_FORK === 'true' ? 'main' : DRE.network.name;
return getParamPerNetwork(config.ReserveFactorTreasuryAddress, <eEthereumNetwork>currentNetwork);
return getParamPerNetwork(config.ReserveFactorTreasuryAddress, <eNetwork>currentNetwork);
};
export const getATokenDomainSeparatorPerNetwork = (
network: eEthereumNetwork,
network: eNetwork,
config: ICommonConfiguration
): tEthereumAddress => getParamPerNetwork<tEthereumAddress>(config.ATokenDomainSeparator, network);
export const getWethAddress = async (config: ICommonConfiguration) => {
const currentNetwork = process.env.MAINNET_FORK === 'true' ? 'main' : DRE.network.name;
const wethAddress = getParamPerNetwork(config.WETH, <eEthereumNetwork>currentNetwork);
const wethAddress = getParamPerNetwork(config.WETH, <eNetwork>currentNetwork);
if (wethAddress) {
return wethAddress;
}

43
helpers/constants.ts
View File

@ -28,3 +28,46 @@ export const TOKEN_DISTRIBUTOR_PERCENTAGE_BASE = '10000';
export const MOCK_USD_PRICE_IN_WEI = '5848466240000000';
export const USD_ADDRESS = '0x10F7Fc1F91Ba351f9C629c5947AD69bD03C05b96';
export const AAVE_REFERRAL = '0';
export const MOCK_CHAINLINK_AGGREGATORS_PRICES = {
AAVE: oneEther.multipliedBy('0.003620948469').toFixed(),
BAT: oneEther.multipliedBy('0.00137893825230').toFixed(),
BUSD: oneEther.multipliedBy('0.00736484').toFixed(),
DAI: oneEther.multipliedBy('0.00369068412860').toFixed(),
ENJ: oneEther.multipliedBy('0.00029560').toFixed(),
KNC: oneEther.multipliedBy('0.001072').toFixed(),
LINK: oneEther.multipliedBy('0.009955').toFixed(),
MANA: oneEther.multipliedBy('0.000158').toFixed(),
MKR: oneEther.multipliedBy('2.508581').toFixed(),
REN: oneEther.multipliedBy('0.00065133').toFixed(),
SNX: oneEther.multipliedBy('0.00442616').toFixed(),
SUSD: oneEther.multipliedBy('0.00364714136416').toFixed(),
TUSD: oneEther.multipliedBy('0.00364714136416').toFixed(),
UNI: oneEther.multipliedBy('0.00536479').toFixed(),
USDC: oneEther.multipliedBy('0.00367714136416').toFixed(),
USDT: oneEther.multipliedBy('0.00369068412860').toFixed(),
WETH: oneEther.toFixed(),
WBTC: oneEther.multipliedBy('47.332685').toFixed(),
YFI: oneEther.multipliedBy('22.407436').toFixed(),
ZRX: oneEther.multipliedBy('0.001151').toFixed(),
UniDAIWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniWBTCWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniAAVEWETH: oneEther.multipliedBy('0.003620948469').toFixed(),
UniBATWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniDAIUSDC: oneEther.multipliedBy('22.407436').toFixed(),
UniCRVWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniLINKWETH: oneEther.multipliedBy('0.009955').toFixed(),
UniMKRWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniRENWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniSNXWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniUNIWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniUSDCWETH: oneEther.multipliedBy('22.407436').toFixed(),
UniWBTCUSDC: oneEther.multipliedBy('22.407436').toFixed(),
UniYFIWETH: oneEther.multipliedBy('22.407436').toFixed(),
BptWBTCWETH: oneEther.multipliedBy('22.407436').toFixed(),
BptBALWETH: oneEther.multipliedBy('22.407436').toFixed(),
WMATIC: oneEther.multipliedBy('0.003620948469').toFixed(),
STAKE: oneEther.multipliedBy('0.003620948469').toFixed(),
xSUSHI: oneEther.multipliedBy('0.00913428586').toFixed(),
USD: '5848466240000000',
};

192
helpers/contracts-deployments.ts
View File

@ -11,7 +11,6 @@ import {
PoolConfiguration,
eEthereumNetwork,
} from './types';
import { MintableERC20 } from '../types/MintableERC20';
import { MockContract } from 'ethereum-waffle';
import { getReservesConfigByPool } from './configuration';
@ -69,6 +68,7 @@ const readArtifact = async (id: string) => {
}
return (DRE as HardhatRuntimeEnvironment).artifacts.readArtifact(id);
};
export const deployLendingPoolAddressesProvider = async (marketId: string, verify?: boolean) =>
withSaveAndVerify(
await new LendingPoolAddressesProviderFactory(await getFirstSigner()).deploy(marketId),
@ -300,82 +300,133 @@ export const deployDefaultReserveInterestRateStrategy = async (
);
export const deployStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify: boolean
) =>
withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.StableDebtToken,
args,
[],
verify
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4], '0x10');
return instance;
};
export const deployVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify: boolean
) =>
withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.VariableDebtToken,
args,
[],
verify
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4], '0x10');
return instance;
};
export const deployGenericStableDebtToken = async () =>
withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.StableDebtToken,
[],
false
);
export const deployGenericVariableDebtToken = async () =>
withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.VariableDebtToken,
[],
false
);
export const deployGenericAToken = async (
[poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController]: [
[poolAddress, underlyingAssetAddress, treasuryAddress, incentivesController, name, symbol]: [
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress
string
],
verify: boolean
) => {
const args: [
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress,
tEthereumAddress
] = [poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController];
return withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(...args),
const instance = await withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(),
eContractid.AToken,
args,
[],
verify
);
await instance.initialize(
poolAddress,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
'18',
name,
symbol,
'0x10'
);
return instance;
};
export const deployGenericATokenImpl = async (verify: boolean) =>
withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(),
eContractid.AToken,
[],
verify
);
export const deployDelegationAwareAToken = async (
[poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController]: [
[pool, underlyingAssetAddress, treasuryAddress, incentivesController, name, symbol]: [
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress
string
],
verify: boolean
) => {
const args: [
tEthereumAddress,
tEthereumAddress,
string,
string,
tEthereumAddress,
tEthereumAddress
] = [poolAddress, underlyingAssetAddress, treasuryAddress, name, symbol, incentivesController];
return withSaveAndVerify(
await new DelegationAwareATokenFactory(await getFirstSigner()).deploy(...args),
const instance = await withSaveAndVerify(
await new DelegationAwareATokenFactory(await getFirstSigner()).deploy(),
eContractid.DelegationAwareAToken,
args,
[],
verify
);
await instance.initialize(
pool,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
'18',
name,
symbol,
'0x10'
);
return instance;
};
export const deployDelegationAwareATokenImpl = async (verify: boolean) =>
withSaveAndVerify(
await new DelegationAwareATokenFactory(await getFirstSigner()).deploy(),
eContractid.DelegationAwareAToken,
[],
verify
);
export const deployAllMockTokens = async (verify?: boolean) => {
const tokens: { [symbol: string]: MockContract | MintableERC20 } = {};
@ -390,6 +441,7 @@ export const deployAllMockTokens = async (verify?: boolean) => {
[tokenSymbol, tokenSymbol, configData ? configData.reserveDecimals : decimals],
verify
);
await registerContractInJsonDb(tokenSymbol.toUpperCase(), tokens[tokenSymbol]);
}
return tokens;
};
@ -437,10 +489,7 @@ export const deployATokensAndRatesHelper = async (
verify
);
export const deployWETHGateway = async (
args: [tEthereumAddress, tEthereumAddress],
verify?: boolean
) =>
export const deployWETHGateway = async (args: [tEthereumAddress], verify?: boolean) =>
withSaveAndVerify(
await new WETHGatewayFactory(await getFirstSigner()).deploy(...args),
eContractid.WETHGateway,
@ -448,17 +497,30 @@ export const deployWETHGateway = async (
verify
);
export const deployMockStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
verify?: boolean
export const authorizeWETHGateway = async (
wethGateWay: tEthereumAddress,
lendingPool: tEthereumAddress
) =>
withSaveAndVerify(
await new MockStableDebtTokenFactory(await getFirstSigner()).deploy(...args),
await new WETHGatewayFactory(await getFirstSigner())
.attach(wethGateWay)
.authorizeLendingPool(lendingPool);
export const deployMockStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) => {
const instance = await withSaveAndVerify(
await new MockStableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.MockStableDebtToken,
args,
[],
verify
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4], args[5]);
return instance;
};
export const deployWETHMocked = async (verify?: boolean) =>
withSaveAndVerify(
await new WETH9MockedFactory(await getFirstSigner()).deploy(),
@ -468,27 +530,37 @@ export const deployWETHMocked = async (verify?: boolean) =>
);
export const deployMockVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) =>
withSaveAndVerify(
await new MockVariableDebtTokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new MockVariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.MockVariableDebtToken,
args,
[],
verify
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4], args[5]);
return instance;
};
export const deployMockAToken = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) =>
withSaveAndVerify(
await new MockATokenFactory(await getFirstSigner()).deploy(...args),
) => {
const instance = await withSaveAndVerify(
await new MockATokenFactory(await getFirstSigner()).deploy(),
eContractid.MockAToken,
args,
[],
verify
);
await instance.initialize(args[0], args[2], args[1], args[3], '18', args[4], args[5], args[6]);
return instance;
};
export const deploySelfdestructTransferMock = async (verify?: boolean) =>
withSaveAndVerify(
await new SelfdestructTransferFactory(await getFirstSigner()).deploy(),

20
helpers/contracts-getters.ts
View File

@ -175,16 +175,16 @@ export const getPairsTokenAggregator = (
const { ETH, USD, WETH, ...assetsAddressesWithoutEth } = allAssetsAddresses;
const pairs = Object.entries(assetsAddressesWithoutEth).map(([tokenSymbol, tokenAddress]) => {
if (tokenSymbol !== 'WETH' && tokenSymbol !== 'ETH') {
const aggregatorAddressIndex = Object.keys(aggregatorsAddresses).findIndex(
(value) => value === tokenSymbol
);
const [, aggregatorAddress] = (Object.entries(aggregatorsAddresses) as [
string,
tEthereumAddress
][])[aggregatorAddressIndex];
return [tokenAddress, aggregatorAddress];
}
//if (true/*tokenSymbol !== 'WETH' && tokenSymbol !== 'ETH' && tokenSymbol !== 'LpWETH'*/) {
const aggregatorAddressIndex = Object.keys(aggregatorsAddresses).findIndex(
(value) => value === tokenSymbol
);
const [, aggregatorAddress] = (Object.entries(aggregatorsAddresses) as [
string,
tEthereumAddress
][])[aggregatorAddressIndex];
return [tokenAddress, aggregatorAddress];
//}
}) as [string, string][];
const mappedPairs = pairs.map(([asset]) => asset);

39
helpers/contracts-helpers.ts
View File

@ -11,6 +11,13 @@ import {
AavePools,
iParamsPerNetwork,
iParamsPerPool,
ePolygonNetwork,
eXDaiNetwork,
eNetwork,
iParamsPerNetworkAll,
iEthereumParamsPerNetwork,
iPolygonParamsPerNetwork,
iXDaiParamsPerNetwork,
} from './types';
import { MintableERC20 } from '../types/MintableERC20';
import { Artifact } from 'hardhat/types';
@ -92,11 +99,14 @@ export const withSaveAndVerify = async <ContractType extends Contract>(
await waitForTx(instance.deployTransaction);
await registerContractInJsonDb(id, instance);
if (usingTenderly()) {
console.log('doing verify of', id);
console.log();
console.log('Doing Tenderly contract verification of', id);
await (DRE as any).tenderlyRPC.verify({
name: id,
address: instance.address,
});
console.log(`Verified ${id} at Tenderly!`);
console.log();
}
if (verify) {
await verifyContract(instance.address, args);
@ -132,10 +142,17 @@ export const linkBytecode = (artifact: BuidlerArtifact | Artifact, libraries: an
return bytecode;
};
export const getParamPerNetwork = <T>(
{ kovan, ropsten, main, buidlerevm, coverage, tenderlyMain }: iParamsPerNetwork<T>,
network: eEthereumNetwork
) => {
export const getParamPerNetwork = <T>(param: iParamsPerNetwork<T>, network: eNetwork) => {
const {
main,
ropsten,
kovan,
coverage,
buidlerevm,
tenderlyMain,
} = param as iEthereumParamsPerNetwork<T>;
const { matic, mumbai } = param as iPolygonParamsPerNetwork<T>;
const { xdai } = param as iXDaiParamsPerNetwork<T>;
const MAINNET_FORK = process.env.MAINNET_FORK === 'true';
if (MAINNET_FORK) {
return main;
@ -156,13 +173,23 @@ export const getParamPerNetwork = <T>(
return main;
case eEthereumNetwork.tenderlyMain:
return tenderlyMain;
case ePolygonNetwork.matic:
return matic;
case ePolygonNetwork.mumbai:
return mumbai;
case eXDaiNetwork.xdai:
return xdai;
}
};
export const getParamPerPool = <T>({ proto }: iParamsPerPool<T>, pool: AavePools) => {
export const getParamPerPool = <T>({ proto, amm, matic }: iParamsPerPool<T>, pool: AavePools) => {
switch (pool) {
case AavePools.proto:
return proto;
case AavePools.amm:
return amm;
case AavePools.matic:
return matic;
default:
return proto;
}

508
helpers/init-helpers.ts
View File

@ -1,6 +1,7 @@
import {
eContractid,
eEthereumNetwork,
eNetwork,
iMultiPoolsAssets,
IReserveParams,
tEthereumAddress,
@ -12,6 +13,7 @@ import {
getAToken,
getATokensAndRatesHelper,
getLendingPoolAddressesProvider,
getLendingPoolConfiguratorProxy,
getStableAndVariableTokensHelper,
} from './contracts-getters';
import { rawInsertContractAddressInDb } from './contracts-helpers';
@ -19,12 +21,17 @@ import { BigNumber, BigNumberish, Signer } from 'ethers';
import {
deployDefaultReserveInterestRateStrategy,
deployDelegationAwareAToken,
deployDelegationAwareATokenImpl,
deployGenericAToken,
deployGenericATokenImpl,
deployGenericStableDebtToken,
deployGenericVariableDebtToken,
deployStableDebtToken,
deployVariableDebtToken,
} from './contracts-deployments';
import { ZERO_ADDRESS } from './constants';
import { isZeroAddress } from 'ethereumjs-util';
import { DefaultReserveInterestRateStrategy, DelegationAwareAToken } from '../types';
export const chooseATokenDeployment = (id: eContractid) => {
switch (id) {
@ -40,6 +47,10 @@ export const chooseATokenDeployment = (id: eContractid) => {
export const initReservesByHelper = async (
reservesParams: iMultiPoolsAssets<IReserveParams>,
tokenAddresses: { [symbol: string]: tEthereumAddress },
aTokenNamePrefix: string,
stableDebtTokenNamePrefix: string,
variableDebtTokenNamePrefix: string,
symbolPrefix: string,
admin: tEthereumAddress,
treasuryAddress: tEthereumAddress,
incentivesController: tEthereumAddress,
@ -47,139 +58,93 @@ export const initReservesByHelper = async (
): Promise<BigNumber> => {
let gasUsage = BigNumber.from('0');
const stableAndVariableDeployer = await getStableAndVariableTokensHelper();
const atokenAndRatesDeployer = await getATokensAndRatesHelper();
const addressProvider = await getLendingPoolAddressesProvider();
const poolAddress = await addressProvider.getLendingPool();
// Set aTokenAndRatesDeployer as temporal admin
await waitForTx(await addressProvider.setPoolAdmin(atokenAndRatesDeployer.address));
// CHUNK CONFIGURATION
const tokensChunks = 2;
const initChunks = 4;
// Deploy tokens and rates that uses common aToken in chunks
const reservesChunks = chunk(
Object.entries(reservesParams).filter(
([_, { aTokenImpl }]) => aTokenImpl === eContractid.AToken
) as [string, IReserveParams][],
tokensChunks
);
// Initialize variables for future reserves initialization
let deployedStableTokens: string[] = [];
let deployedVariableTokens: string[] = [];
let deployedATokens: string[] = [];
let deployedRates: string[] = [];
let reserveTokens: string[] = [];
let reserveInitDecimals: string[] = [];
let reserveSymbols: string[] = [];
console.log(
`- Token deployments in ${reservesChunks.length * 2} txs instead of ${
Object.entries(reservesParams).length * 4
} txs`
);
for (let reservesChunk of reservesChunks) {
// Prepare data
const tokens: string[] = [];
const symbols: string[] = [];
const strategyRates: [
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish
][] = [];
const reservesDecimals: string[] = [];
let initInputParams: {
aTokenImpl: string;
stableDebtTokenImpl: string;
variableDebtTokenImpl: string;
underlyingAssetDecimals: BigNumberish;
interestRateStrategyAddress: string;
underlyingAsset: string;
treasury: string;
incentivesController: string;
underlyingAssetName: string;
aTokenName: string;
aTokenSymbol: string;
variableDebtTokenName: string;
variableDebtTokenSymbol: string;
stableDebtTokenName: string;
stableDebtTokenSymbol: string;
params: string;
}[] = [];
for (let [assetSymbol, { reserveDecimals }] of reservesChunk) {
const assetAddressIndex = Object.keys(tokenAddresses).findIndex(
(value) => value === assetSymbol
);
const [, tokenAddress] = (Object.entries(tokenAddresses) as [string, string][])[
assetAddressIndex
];
let strategyRates: [
string, // addresses provider
string,
string,
string,
string,
string,
string
];
let rateStrategies: Record<string, typeof strategyRates> = {};
let strategyAddresses: Record<string, tEthereumAddress> = {};
let strategyAddressPerAsset: Record<string, string> = {};
let aTokenType: Record<string, string> = {};
let delegationAwareATokenImplementationAddress = '';
let aTokenImplementationAddress = '';
let stableDebtTokenImplementationAddress = '';
let variableDebtTokenImplementationAddress = '';
const reserveParamIndex = Object.keys(reservesParams).findIndex(
(value) => value === assetSymbol
);
const [
,
{
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
},
] = (Object.entries(reservesParams) as [string, IReserveParams][])[reserveParamIndex];
// Add to lists
tokens.push(tokenAddress);
symbols.push(assetSymbol);
strategyRates.push([
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
]);
reservesDecimals.push(reserveDecimals);
}
// NOT WORKING ON MATIC, DEPLOYING INDIVIDUAL IMPLs INSTEAD
// const tx1 = await waitForTx(
// await stableAndVariableDeployer.initDeployment([ZERO_ADDRESS], ["1"])
// );
// console.log(tx1.events);
// tx1.events?.forEach((event, index) => {
// stableDebtTokenImplementationAddress = event?.args?.stableToken;
// variableDebtTokenImplementationAddress = event?.args?.variableToken;
// rawInsertContractAddressInDb(`stableDebtTokenImpl`, stableDebtTokenImplementationAddress);
// rawInsertContractAddressInDb(`variableDebtTokenImpl`, variableDebtTokenImplementationAddress);
// });
//gasUsage = gasUsage.add(tx1.gasUsed);
stableDebtTokenImplementationAddress = await (await deployGenericStableDebtToken()).address;
variableDebtTokenImplementationAddress = await (await deployGenericVariableDebtToken()).address;
// Deploy stable and variable deployers and save implementations
const tx1 = await waitForTx(
await stableAndVariableDeployer.initDeployment(tokens, symbols, incentivesController)
);
tx1.events?.forEach((event, index) => {
rawInsertContractAddressInDb(`stableDebt${symbols[index]}`, event?.args?.stableToken);
rawInsertContractAddressInDb(`variableDebt${symbols[index]}`, event?.args?.variableToken);
});
const aTokenImplementation = await deployGenericATokenImpl(verify);
aTokenImplementationAddress = aTokenImplementation.address;
rawInsertContractAddressInDb(`aTokenImpl`, aTokenImplementationAddress);
// Deploy atokens and rate strategies and save implementations
const tx2 = await waitForTx(
await atokenAndRatesDeployer.initDeployment(
tokens,
symbols,
strategyRates,
treasuryAddress,
incentivesController
)
);
tx2.events?.forEach((event, index) => {
rawInsertContractAddressInDb(`a${symbols[index]}`, event?.args?.aToken);
rawInsertContractAddressInDb(`strategy${symbols[index]}`, event?.args?.strategy);
});
console.log(` - Deployed aToken, DebtTokens and Strategy for: ${symbols.join(', ')} `);
console.log(' * gasUsed: debtTokens batch', tx1.gasUsed.toString());
console.log(' * gasUsed: aTokens and Strategy batch', tx2.gasUsed.toString());
gasUsage = gasUsage.add(tx1.gasUsed).add(tx2.gasUsed);
const stableTokens: string[] = tx1.events?.map((e) => e.args?.stableToken) || [];
const variableTokens: string[] = tx1.events?.map((e) => e.args?.variableToken) || [];
const aTokens: string[] = tx2.events?.map((e) => e.args?.aToken) || [];
const strategies: string[] = tx2.events?.map((e) => e.args?.strategy) || [];
deployedStableTokens = [...deployedStableTokens, ...stableTokens];
deployedVariableTokens = [...deployedVariableTokens, ...variableTokens];
deployedATokens = [...deployedATokens, ...aTokens];
deployedRates = [...deployedRates, ...strategies];
reserveInitDecimals = [...reserveInitDecimals, ...reservesDecimals];
reserveTokens = [...reserveTokens, ...tokens];
reserveSymbols = [...reserveSymbols, ...symbols];
}
// Deploy delegated aware reserves tokens
const delegatedAwareReserves = Object.entries(reservesParams).filter(
([_, { aTokenImpl }]) => aTokenImpl === eContractid.DelegationAwareAToken
) as [string, IReserveParams][];
for (let [symbol, params] of delegatedAwareReserves) {
console.log(` - Deploy ${symbol} delegation aware aToken, debts tokens, and strategy`);
if (delegatedAwareReserves.length > 0) {
const delegationAwareATokenImplementation = await deployDelegationAwareATokenImpl(verify);
delegationAwareATokenImplementationAddress = delegationAwareATokenImplementation.address;
rawInsertContractAddressInDb(
`delegationAwareATokenImpl`,
delegationAwareATokenImplementationAddress
);
}
const reserves = Object.entries(reservesParams).filter(
([_, { aTokenImpl }]) =>
aTokenImpl === eContractid.DelegationAwareAToken || aTokenImpl === eContractid.AToken
) as [string, IReserveParams][];
for (let [symbol, params] of reserves) {
const { strategy, aTokenImpl, reserveDecimals } = params;
const {
optimalUtilizationRate,
baseVariableBorrowRate,
@ -187,89 +152,86 @@ export const initReservesByHelper = async (
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
} = params;
const deployCustomAToken = chooseATokenDeployment(params.aTokenImpl);
const aToken = await deployCustomAToken(
[
poolAddress,
tokenAddresses[symbol],
treasuryAddress,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
],
verify
);
const stableDebt = await deployStableDebtToken(
[
poolAddress,
tokenAddresses[symbol],
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
const variableDebt = await deployVariableDebtToken(
[
poolAddress,
tokenAddresses[symbol],
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
const rates = await deployDefaultReserveInterestRateStrategy(
[
tokenAddresses[symbol],
} = strategy;
if (!strategyAddresses[strategy.name]) {
// Strategy does not exist, create a new one
rateStrategies[strategy.name] = [
addressProvider.address,
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
],
verify
);
];
strategyAddresses[strategy.name] = (
await deployDefaultReserveInterestRateStrategy(rateStrategies[strategy.name], verify)
).address;
// This causes the last strategy to be printed twice, once under "DefaultReserveInterestRateStrategy"
// and once under the actual `strategyASSET` key.
rawInsertContractAddressInDb(strategy.name, strategyAddresses[strategy.name]);
}
strategyAddressPerAsset[symbol] = strategyAddresses[strategy.name];
console.log('Strategy address for asset %s: %s', symbol, strategyAddressPerAsset[symbol]);
deployedStableTokens.push(stableDebt.address);
deployedVariableTokens.push(variableDebt.address);
deployedATokens.push(aToken.address);
deployedRates.push(rates.address);
reserveInitDecimals.push(params.reserveDecimals);
if (aTokenImpl === eContractid.AToken) {
aTokenType[symbol] = 'generic';
} else if (aTokenImpl === eContractid.DelegationAwareAToken) {
aTokenType[symbol] = 'delegation aware';
}
reserveInitDecimals.push(reserveDecimals);
reserveTokens.push(tokenAddresses[symbol]);
reserveSymbols.push(symbol);
}
// Deploy init reserves per chunks
const chunkedStableTokens = chunk(deployedStableTokens, initChunks);
const chunkedVariableTokens = chunk(deployedVariableTokens, initChunks);
const chunkedAtokens = chunk(deployedATokens, initChunks);
const chunkedRates = chunk(deployedRates, initChunks);
const chunkedDecimals = chunk(reserveInitDecimals, initChunks);
const chunkedSymbols = chunk(reserveSymbols, initChunks);
for (let i = 0; i < reserveSymbols.length; i++) {
let aTokenToUse: string;
if (aTokenType[reserveSymbols[i]] === 'generic') {
aTokenToUse = aTokenImplementationAddress;
} else {
aTokenToUse = delegationAwareATokenImplementationAddress;
}
console.log(`- Reserves initialization in ${chunkedStableTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedDecimals.length; chunkIndex++) {
initInputParams.push({
aTokenImpl: aTokenToUse,
stableDebtTokenImpl: stableDebtTokenImplementationAddress,
variableDebtTokenImpl: variableDebtTokenImplementationAddress,
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: strategyAddressPerAsset[reserveSymbols[i]],
underlyingAsset: reserveTokens[i],
treasury: treasuryAddress,
incentivesController: ZERO_ADDRESS,
underlyingAssetName: reserveSymbols[i],
aTokenName: `${aTokenNamePrefix} ${reserveSymbols[i]}`,
aTokenSymbol: `a${symbolPrefix}${reserveSymbols[i]}`,
variableDebtTokenName: `${variableDebtTokenNamePrefix} ${symbolPrefix}${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${symbolPrefix}${reserveSymbols[i]}`,
stableDebtTokenName: `${stableDebtTokenNamePrefix} ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${symbolPrefix}${reserveSymbols[i]}`,
params: '0x10'
});
}
// Deploy init reserves per chunks
const chunkedSymbols = chunk(reserveSymbols, initChunks);
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
//await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
const tx3 = await waitForTx(
await atokenAndRatesDeployer.initReserve(
chunkedStableTokens[chunkIndex],
chunkedVariableTokens[chunkIndex],
chunkedAtokens[chunkIndex],
chunkedRates[chunkIndex],
chunkedDecimals[chunkIndex]
)
await configurator.batchInitReserve(chunkedInitInputParams[chunkIndex])
);
console.log(` - Reserve ready for: ${chunkedSymbols[chunkIndex].join(', ')}`);
console.log(' * gasUsed', tx3.gasUsed.toString());
gasUsage = gasUsage.add(tx3.gasUsed);
//gasUsage = gasUsage.add(tx3.gasUsed);
}
// Set deployer back as admin
await waitForTx(await addressProvider.setPoolAdmin(admin));
return gasUsage;
return gasUsage; // Deprecated
};
export const getPairsTokenAggregator = (
@ -315,6 +277,15 @@ export const configureReservesByHelper = async (
const reserveFactors: string[] = [];
const stableRatesEnabled: boolean[] = [];
const inputParams: {
asset: string;
baseLTV: BigNumberish;
liquidationThreshold: BigNumberish;
liquidationBonus: BigNumberish;
reserveFactor: BigNumberish;
stableBorrowingEnabled: boolean;
}[] = [];
for (const [
assetSymbol,
{
@ -342,6 +313,16 @@ export const configureReservesByHelper = async (
continue;
}
// Push data
inputParams.push({
asset: tokenAddress,
baseLTV: baseLTVAsCollateral,
liquidationThreshold: liquidationThreshold,
liquidationBonus: liquidationBonus,
reserveFactor: reserveFactor,
stableBorrowingEnabled: stableBorrowRateEnabled,
});
tokens.push(tokenAddress);
symbols.push(assetSymbol);
baseLTVA.push(baseLTVAsCollateral);
@ -356,26 +337,15 @@ export const configureReservesByHelper = async (
// Deploy init per chunks
const enableChunks = 20;
const chunkedTokens = chunk(tokens, enableChunks);
const chunkedSymbols = chunk(symbols, enableChunks);
const chunkedBase = chunk(baseLTVA, enableChunks);
const chunkedliquidationThresholds = chunk(liquidationThresholds, enableChunks);
const chunkedliquidationBonuses = chunk(liquidationBonuses, enableChunks);
const chunkedReserveFactors = chunk(reserveFactors, enableChunks);
const chunkedStableRatesEnabled = chunk(stableRatesEnabled, enableChunks);
const chunkedInputParams = chunk(inputParams, enableChunks);
console.log(`- Configure reserves in ${chunkedTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedTokens.length; chunkIndex++) {
console.log(`- Configure reserves in ${chunkedInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInputParams.length; chunkIndex++) {
await waitForTx(
await atokenAndRatesDeployer.configureReserves(
chunkedTokens[chunkIndex],
chunkedBase[chunkIndex],
chunkedliquidationThresholds[chunkIndex],
chunkedliquidationBonuses[chunkIndex],
chunkedReserveFactors[chunkIndex],
chunkedStableRatesEnabled[chunkIndex],
{ gasLimit: 12000000 }
)
await atokenAndRatesDeployer.configureReserves(chunkedInputParams[chunkIndex], {
gasLimit: 12000000,
})
);
console.log(` - Init for: ${chunkedSymbols[chunkIndex].join(', ')}`);
}
@ -386,10 +356,13 @@ export const configureReservesByHelper = async (
const getAddressById = async (
id: string,
network: eEthereumNetwork
network: eNetwork
): Promise<tEthereumAddress | undefined> =>
(await getDb().get(`${id}.${network}`).value())?.address || undefined;
// Function deprecated? Updated but untested, script is not updated on package.json.
// This is not called during regular deployment, only in the "full:initialize-tokens"
// hardhat task.
export const initTokenReservesByHelper = async (
reservesParams: iMultiPoolsAssets<IReserveParams>,
tokenAddresses: { [symbol: string]: tEthereumAddress },
@ -415,7 +388,7 @@ export const initTokenReservesByHelper = async (
const poolAddress = await addressProvider.getLendingPool();
// Set aTokenAndRatesDeployer as temporal admin
await waitForTx(await addressProvider.setPoolAdmin(atokenAndRatesDeployer.address));
//await waitForTx(await addressProvider.setPoolAdmin(atokenAndRatesDeployer.address));
// CHUNK CONFIGURATION
const initChunks = 4;
@ -425,12 +398,31 @@ export const initTokenReservesByHelper = async (
let deployedVariableTokens: string[] = [];
let deployedATokens: string[] = [];
let deployedRates: string[] = [];
//let reserveTokens: string[] = [];
let reserveInitDecimals: string[] = [];
let reserveSymbols: string[] = [];
let initInputParams: {
aTokenImpl: string;
stableDebtTokenImpl: string;
variableDebtTokenImpl: string;
underlyingAssetDecimals: BigNumberish;
interestRateStrategyAddress: string;
underlyingAsset: string;
treasury: string;
incentivesController: string;
underlyingAssetName: string;
aTokenName: string;
aTokenSymbol: string;
variableDebtTokenName: string;
variableDebtTokenSymbol: string;
stableDebtTokenName: string;
stableDebtTokenSymbol: string;
params: string;
}[] = [];
const network =
process.env.MAINNET_FORK === 'true'
? eEthereumNetwork.main
: (DRE.network.name as eEthereumNetwork);
process.env.MAINNET_FORK === 'true' ? eEthereumNetwork.main : (DRE.network.name as eNetwork);
// Grab config from DB
for (const [symbol, address] of Object.entries(tokenAddresses)) {
const { aTokenAddress } = await protocolDataProvider.getReserveTokensAddresses(address);
@ -444,19 +436,29 @@ export const initTokenReservesByHelper = async (
console.log(`- Skipping ${symbol} due already initialized`);
continue;
}
let stableTokenImpl = await getAddressById(`stableDebt${symbol}`, network);
let variableTokenImpl = await getAddressById(`variableDebt${symbol}`, network);
let aTokenImplementation = await getAddressById(`a${symbol}`, network);
let strategyImpl = await getAddressById(`strategy${symbol}`, network);
let stableTokenImpl = await getAddressById(`stableDebtTokenImpl`, network);
let variableTokenImpl = await getAddressById(`variableDebtTokenImpl`, network);
let aTokenImplementation: string | undefined = '';
const [, { aTokenImpl, strategy }] = (Object.entries(reservesParams) as [
string,
IReserveParams
][])[reserveParamIndex];
if (aTokenImpl === eContractid.AToken) {
aTokenImplementation = await getAddressById(`aTokenImpl`, network);
} else if (aTokenImpl === eContractid.DelegationAwareAToken) {
aTokenImplementation = await getAddressById(`delegationAwareATokenImpl`, network);
}
let strategyImpl = await getAddressById(strategy.name, network);
if (!stableTokenImpl) {
const stableDebt = await deployStableDebtToken(
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -467,9 +469,9 @@ export const initTokenReservesByHelper = async (
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives Controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -485,26 +487,26 @@ export const initTokenReservesByHelper = async (
poolAddress,
tokenAddresses[symbol],
treasuryAddress,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
],
verify
);
aTokenImplementation = aToken.address;
}
if (!strategyImpl) {
const [
,
{
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
},
] = (Object.entries(reservesParams) as [string, IReserveParams][])[reserveParamIndex];
const [, { strategy }] = (Object.entries(reservesParams) as [string, IReserveParams][])[
reserveParamIndex
];
const {
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
} = strategy;
const rates = await deployDefaultReserveInterestRateStrategy(
[
tokenAddresses[symbol],
@ -519,53 +521,69 @@ export const initTokenReservesByHelper = async (
);
strategyImpl = rates.address;
}
const symbols = [`a${symbol}`, `variableDebt${symbol}`, `stableDebt${symbol}`];
const tokens = [aTokenImplementation, variableTokenImpl, stableTokenImpl];
for (let index = 0; index < symbols.length; index++) {
if (!(await isErc20SymbolCorrect(tokens[index], symbols[index]))) {
console.error(`${symbol} and implementation does not match: ${tokens[index]}`);
throw Error('Symbol does not match implementation.');
}
}
// --- REMOVED BECAUSE WE NOW USE THE SAME IMPLEMENTATIONS ---
// const symbols = [`a${symbol}`, `variableDebt${symbol}`, `stableDebt${symbol}`];
// const tokens = [aTokenImplementation, variableTokenImpl, stableTokenImpl];
// for (let index = 0; index < symbols.length; index++) {
// if (!(await isErc20SymbolCorrect(tokens[index], symbols[index]))) {
// console.error(`${symbol} and implementation does not match: ${tokens[index]}`);
// throw Error('Symbol does not match implementation.');
// }
// }
console.log(`- Added ${symbol} to the initialize batch`);
deployedStableTokens.push(stableTokenImpl);
deployedVariableTokens.push(variableTokenImpl);
deployedATokens.push(aTokenImplementation);
//reserveTokens.push();
deployedRates.push(strategyImpl);
reserveInitDecimals.push(decimals.toString());
reserveSymbols.push(symbol);
}
// Deploy init reserves per chunks
const chunkedStableTokens = chunk(deployedStableTokens, initChunks);
const chunkedVariableTokens = chunk(deployedVariableTokens, initChunks);
const chunkedAtokens = chunk(deployedATokens, initChunks);
const chunkedRates = chunk(deployedRates, initChunks);
const chunkedDecimals = chunk(reserveInitDecimals, initChunks);
const chunkedSymbols = chunk(reserveSymbols, initChunks);
for (let i = 0; i < deployedATokens.length; i++) {
initInputParams.push({
aTokenImpl: deployedATokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
variableDebtTokenImpl: deployedVariableTokens[i],
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: deployedRates[i],
underlyingAsset: tokenAddresses[reserveSymbols[i]],
treasury: treasuryAddress,
incentivesController: ZERO_ADDRESS,
underlyingAssetName: reserveSymbols[i],
aTokenName: `Aave interest bearing ${reserveSymbols[i]}`,
aTokenSymbol: `a${reserveSymbols[i]}`,
variableDebtTokenName: `Aave variable debt bearing ${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${reserveSymbols[i]}`,
stableDebtTokenName: `Aave stable debt bearing ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`,
params: '0x10'
});
}
console.log(`- Reserves initialization in ${chunkedStableTokens.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedDecimals.length; chunkIndex++) {
// Deploy init reserves per chunks
const chunkedSymbols = chunk(reserveSymbols, initChunks);
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
//await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
const tx3 = await waitForTx(
await atokenAndRatesDeployer.initReserve(
chunkedStableTokens[chunkIndex],
chunkedVariableTokens[chunkIndex],
chunkedAtokens[chunkIndex],
chunkedRates[chunkIndex],
chunkedDecimals[chunkIndex]
)
await configurator.batchInitReserve(chunkedInitInputParams[chunkIndex])
);
console.log(` - Reserve ready for: ${chunkedSymbols[chunkIndex].join(', ')}`);
console.log(' * gasUsed', tx3.gasUsed.toString());
gasUsage = gasUsage.add(tx3.gasUsed);
}
// Set deployer back as admin
await waitForTx(await addressProvider.setPoolAdmin(admin));
return gasUsage;
//await waitForTx(await addressProvider.setPoolAdmin(admin));
return gasUsage; // No longer relevant
};
// Function deprecated
const isErc20SymbolCorrect = async (token: tEthereumAddress, symbol: string) => {
const erc20 = await getAToken(token); // using aToken for ERC20 interface
const erc20Symbol = await erc20.symbol();

3
helpers/oracles-helpers.ts
View File

@ -72,6 +72,9 @@ export const setInitialAssetPricesInOracle = async (
priceOracleInstance: PriceOracle
) => {
for (const [assetSymbol, price] of Object.entries(prices) as [string, string][]) {
console.log("Trying for ", assetsAddresses, assetSymbol);
const assetAddressIndex = Object.keys(assetsAddresses).findIndex(
(value) => value === assetSymbol
);

153
helpers/types.ts
View File

@ -4,6 +4,8 @@ export interface SymbolMap<T> {
[symbol: string]: T;
}
export type eNetwork = eEthereumNetwork | ePolygonNetwork | eXDaiNetwork;
export enum eEthereumNetwork {
buidlerevm = 'buidlerevm',
kovan = 'kovan',
@ -14,14 +16,28 @@ export enum eEthereumNetwork {
tenderlyMain = 'tenderlyMain',
}
export enum ePolygonNetwork {
matic = 'matic',
mumbai = 'mumbai',
}
export enum eXDaiNetwork {
xdai = 'xdai',
}
export enum EthereumNetworkNames {
kovan = 'kovan',
ropsten = 'ropsten',
main = 'main',
matic = 'matic',
mumbai = 'mumbai',
xdai = 'xdai',
}
export enum AavePools {
proto = 'proto',
matic = 'matic',
amm = 'amm',
}
export enum eContractid {
@ -204,6 +220,24 @@ export interface iAssetBase<T> {
USD: T;
REN: T;
ENJ: T;
UniDAIWETH: T;
UniWBTCWETH: T;
UniAAVEWETH: T;
UniBATWETH: T;
UniDAIUSDC: T;
UniCRVWETH: T;
UniLINKWETH: T;
UniMKRWETH: T;
UniRENWETH: T;
UniSNXWETH: T;
UniUNIWETH: T;
UniUSDCWETH: T;
UniWBTCUSDC: T;
UniYFIWETH: T;
BptWBTCWETH: T;
BptBALWETH: T;
WMATIC: T;
STAKE: T;
xSUSHI: T;
}
@ -236,6 +270,41 @@ export type iAavePoolAssets<T> = Pick<
| 'xSUSHI'
>;
export type iLpPoolAssets<T> = Pick<
iAssetsWithoutUSD<T>,
| 'DAI'
| 'USDC'
| 'USDT'
| 'WBTC'
| 'WETH'
| 'UniDAIWETH'
| 'UniWBTCWETH'
| 'UniAAVEWETH'
| 'UniBATWETH'
| 'UniDAIUSDC'
| 'UniCRVWETH'
| 'UniLINKWETH'
| 'UniMKRWETH'
| 'UniRENWETH'
| 'UniSNXWETH'
| 'UniUNIWETH'
| 'UniUSDCWETH'
| 'UniWBTCUSDC'
| 'UniYFIWETH'
| 'BptWBTCWETH'
| 'BptBALWETH'
>;
export type iMaticPoolAssets<T> = Pick<
iAssetsWithoutUSD<T>,
'DAI' | 'USDC' | 'USDT' | 'WBTC' | 'WETH' | 'WMATIC'
>;
export type iXDAIPoolAssets<T> = Pick<
iAssetsWithoutUSD<T>,
'DAI' | 'USDC' | 'USDT' | 'WBTC' | 'WETH' | 'STAKE'
>;
export type iMultiPoolsAssets<T> = iAssetCommon<T> | iAavePoolAssets<T>;
export type iAavePoolTokens<T> = Omit<iAavePoolAssets<T>, 'ETH'>;
@ -264,21 +333,50 @@ export enum TokenContractId {
YFI = 'YFI',
UNI = 'UNI',
ENJ = 'ENJ',
UniDAIWETH = 'UniDAIWETH',
UniWBTCWETH = 'UniWBTCWETH',
UniAAVEWETH = 'UniAAVEWETH',
UniBATWETH = 'UniBATWETH',
UniDAIUSDC = 'UniDAIUSDC',
UniCRVWETH = 'UniCRVWETH',
UniLINKWETH = 'UniLINKWETH',
UniMKRWETH = 'UniMKRWETH',
UniRENWETH = 'UniRENWETH',
UniSNXWETH = 'UniSNXWETH',
UniUNIWETH = 'UniUNIWETH',
UniUSDCWETH = 'UniUSDCWETH',
UniWBTCUSDC = 'UniWBTCUSDC',
UniYFIWETH = 'UniYFIWETH',
BptWBTCWETH = 'BptWBTCWETH',
BptBALWETH = 'BptBALWETH',
WMATIC = 'WMATIC',
STAKE = 'STAKE',
xSUSHI = 'xSUSHI'
}
export interface IReserveParams extends IReserveBorrowParams, IReserveCollateralParams {
aTokenImpl: eContractid;
reserveFactor: string;
strategy: IInterestRateStrategyParams;
}
export interface IReserveBorrowParams {
export interface IInterestRateStrategyParams {
name: string;
optimalUtilizationRate: string;
baseVariableBorrowRate: string;
variableRateSlope1: string;
variableRateSlope2: string;
stableRateSlope1: string;
stableRateSlope2: string;
}
export interface IReserveBorrowParams {
// optimalUtilizationRate: string;
// baseVariableBorrowRate: string;
// variableRateSlope1: string;
// variableRateSlope2: string;
// stableRateSlope1: string;
// stableRateSlope2: string;
borrowingEnabled: boolean;
stableBorrowRateEnabled: boolean;
reserveDecimals: string;
@ -293,7 +391,17 @@ export interface IMarketRates {
borrowRate: string;
}
export interface iParamsPerNetwork<T> {
export type iParamsPerNetwork<T> =
| iEthereumParamsPerNetwork<T>
| iPolygonParamsPerNetwork<T>
| iXDaiParamsPerNetwork<T>;
export interface iParamsPerNetworkAll<T>
extends iEthereumParamsPerNetwork<T>,
iPolygonParamsPerNetwork<T>,
iXDaiParamsPerNetwork<T> {}
export interface iEthereumParamsPerNetwork<T> {
[eEthereumNetwork.coverage]: T;
[eEthereumNetwork.buidlerevm]: T;
[eEthereumNetwork.kovan]: T;
@ -303,8 +411,19 @@ export interface iParamsPerNetwork<T> {
[eEthereumNetwork.tenderlyMain]: T;
}
export interface iPolygonParamsPerNetwork<T> {
[ePolygonNetwork.matic]: T;
[ePolygonNetwork.mumbai]: T;
}
export interface iXDaiParamsPerNetwork<T> {
[eXDaiNetwork.xdai]: T;
}
export interface iParamsPerPool<T> {
[AavePools.proto]: T;
[AavePools.matic]: T;
[AavePools.amm]: T;
}
export interface iBasicDistributionParams {
@ -322,15 +441,6 @@ export interface ObjectString {
[key: string]: string;
}
export enum EthereumNetwork {
kovan = 'kovan',
ropsten = 'ropsten',
development = 'development',
main = 'main',
coverage = 'soliditycoverage',
tenderlyMain = 'tenderlyMain',
}
export interface IProtocolGlobalConfig {
TokenDistributorPercentageBase: string;
MockUsdPriceInWei: string;
@ -354,11 +464,18 @@ export interface ILendingRate {
export interface ICommonConfiguration {
MarketId: string;
ATokenNamePrefix: string;
StableDebtTokenNamePrefix: string;
VariableDebtTokenNamePrefix: string;
SymbolPrefix: string;
ProviderId: number;
ProtocolGlobalParams: IProtocolGlobalConfig;
Mocks: IMocksConfig;
ProviderRegistry: iParamsPerNetwork<tEthereumAddress | undefined>;
ProviderRegistryOwner: iParamsPerNetwork<tEthereumAddress | undefined>;
LendingPoolCollateralManager: iParamsPerNetwork<tEthereumAddress>;
LendingPoolConfigurator: iParamsPerNetwork<tEthereumAddress>;
LendingPool: iParamsPerNetwork<tEthereumAddress>;
LendingRateOracleRatesCommon: iMultiPoolsAssets<IMarketRates>;
LendingRateOracle: iParamsPerNetwork<tEthereumAddress>;
TokenDistributor: iParamsPerNetwork<tEthereumAddress>;
@ -373,12 +490,26 @@ export interface ICommonConfiguration {
ReservesConfig: iMultiPoolsAssets<IReserveParams>;
ATokenDomainSeparator: iParamsPerNetwork<string>;
WETH: iParamsPerNetwork<tEthereumAddress>;
WethGateway: iParamsPerNetwork<tEthereumAddress>;
ReserveFactorTreasuryAddress: iParamsPerNetwork<tEthereumAddress>;
}
export interface IAaveConfiguration extends ICommonConfiguration {
ReservesConfig: iAavePoolAssets<IReserveParams>;
}
export interface IAmmConfiguration extends ICommonConfiguration {
ReservesConfig: iLpPoolAssets<IReserveParams>;
}
export interface IMaticConfiguration extends ICommonConfiguration {
ReservesConfig: iMaticPoolAssets<IReserveParams>;
}
export interface IXDAIConfiguration extends ICommonConfiguration {
ReservesConfig: iXDAIPoolAssets<IReserveParams>;
}
export interface ITokenAddress {
[token: string]: tEthereumAddress;
}

114
markets/aave/commons.ts
View File

@ -1,38 +1,18 @@
import BigNumber from 'bignumber.js';
import { oneEther, oneRay, RAY, ZERO_ADDRESS } from '../../helpers/constants';
import { ICommonConfiguration, EthereumNetwork, eEthereumNetwork } from '../../helpers/types';
import { oneEther, oneRay, RAY, ZERO_ADDRESS, MOCK_CHAINLINK_AGGREGATORS_PRICES } from '../../helpers/constants';
import { ICommonConfiguration, eEthereumNetwork } from '../../helpers/types';
const MOCK_CHAINLINK_AGGREGATORS_PRICES = {
AAVE: oneEther.multipliedBy('0.003620948469').toFixed(),
BAT: oneEther.multipliedBy('0.00137893825230').toFixed(),
BUSD: oneEther.multipliedBy('0.00736484').toFixed(),
DAI: oneEther.multipliedBy('0.00369068412860').toFixed(),
ENJ: oneEther.multipliedBy('0.00029560').toFixed(),
KNC: oneEther.multipliedBy('0.001072').toFixed(),
LINK: oneEther.multipliedBy('0.009955').toFixed(),
MANA: oneEther.multipliedBy('0.000158').toFixed(),
MKR: oneEther.multipliedBy('2.508581').toFixed(),
REN: oneEther.multipliedBy('0.00065133').toFixed(),
SNX: oneEther.multipliedBy('0.00442616').toFixed(),
SUSD: oneEther.multipliedBy('0.00364714136416').toFixed(),
TUSD: oneEther.multipliedBy('0.00364714136416').toFixed(),
UNI: oneEther.multipliedBy('0.00536479').toFixed(),
USDC: oneEther.multipliedBy('0.00367714136416').toFixed(),
USDT: oneEther.multipliedBy('0.00369068412860').toFixed(),
WETH: oneEther.toFixed(),
WBTC: oneEther.multipliedBy('47.332685').toFixed(),
YFI: oneEther.multipliedBy('22.407436').toFixed(),
ZRX: oneEther.multipliedBy('0.001151').toFixed(),
xSUSHI: oneEther.multipliedBy('0.00913428586').toFixed(),
USD: '5848466240000000',
};
// ----------------
// PROTOCOL GLOBAL PARAMS
// ----------------
export const CommonsConfig: ICommonConfiguration = {
MarketId: 'Commons',
ProviderId: 0,
ATokenNamePrefix: 'Aave interest bearing',
StableDebtTokenNamePrefix: 'Aave stable debt bearing',
VariableDebtTokenNamePrefix: 'Aave variable debt bearing',
SymbolPrefix: '',
ProviderId: 0, // Overriden in index.ts
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
@ -159,43 +139,79 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0xdCde9Bb6a49e37fA433990832AB541AE2d4FEB4a',
[eEthereumNetwork.kovan]: '',//'0xdCde9Bb6a49e37fA433990832AB541AE2d4FEB4a',
[eEthereumNetwork.ropsten]: '0x05dcca805a6562c1bdd0423768754acb6993241b',
[eEthereumNetwork.main]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
[eEthereumNetwork.main]: '',//'0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
[eEthereumNetwork.tenderlyMain]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
},
LendingPoolCollateralManager: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x9269b6453d0d75370c4c85e5a42977a53efdb72a',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderlyMain]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
},
LendingPoolConfigurator: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
LendingPool: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
WethGateway: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0xf99b8E67a0E044734B01EC4586D1c88C9a869718',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
TokenDistributor: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.hardhat]: '',
[EthereumNetwork.kovan]: '0x971efe90088f21dc6a36f610ffed77fc19710708',
[EthereumNetwork.ropsten]: '0xeba2ea67942b8250d870b12750b594696d02fc9c',
[EthereumNetwork.main]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[EthereumNetwork.tenderlyMain]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.kovan]: '0x971efe90088f21dc6a36f610ffed77fc19710708',
[eEthereumNetwork.ropsten]: '0xeba2ea67942b8250d870b12750b594696d02fc9c',
[eEthereumNetwork.main]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderlyMain]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
},
AaveOracle: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[EthereumNetwork.kovan]: '0xB8bE51E6563BB312Cbb2aa26e352516c25c26ac1',
[EthereumNetwork.ropsten]: ZERO_ADDRESS,
[EthereumNetwork.main]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
[EthereumNetwork.tenderlyMain]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
[eEthereumNetwork.kovan]: '',//'0xB8bE51E6563BB312Cbb2aa26e352516c25c26ac1',
[eEthereumNetwork.ropsten]: ZERO_ADDRESS,
[eEthereumNetwork.main]: '',//'0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
[eEthereumNetwork.tenderlyMain]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
},
FallbackOracle: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[EthereumNetwork.kovan]: '0x50913E8E1c650E790F8a1E741FF9B1B1bB251dfe',
[EthereumNetwork.ropsten]: '0xAD1a978cdbb8175b2eaeC47B01404f8AEC5f4F0d',
[EthereumNetwork.main]: ZERO_ADDRESS,
[EthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
[eEthereumNetwork.kovan]: '0x50913E8E1c650E790F8a1E741FF9B1B1bB251dfe',
[eEthereumNetwork.ropsten]: '0xAD1a978cdbb8175b2eaeC47B01404f8AEC5f4F0d',
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[eEthereumNetwork.coverage]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.buidlerevm]: {},
[EthereumNetwork.kovan]: {
[eEthereumNetwork.kovan]: {
AAVE: '0xd04647B7CB523bb9f26730E9B6dE1174db7591Ad',
BAT: '0x0e4fcEC26c9f85c3D714370c98f43C4E02Fc35Ae',
BUSD: '0xbF7A18ea5DE0501f7559144e702b29c55b055CcB',
@ -217,7 +233,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0xBc3f28Ccc21E9b5856E81E6372aFf57307E2E883',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[EthereumNetwork.ropsten]: {
[eEthereumNetwork.ropsten]: {
AAVE: ZERO_ADDRESS,
BAT: '0xafd8186c962daf599f171b8600f3e19af7b52c92',
BUSD: '0x0A32D96Ff131cd5c3E0E5AAB645BF009Eda61564',
@ -239,7 +255,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0x1d0052e4ae5b4ae4563cbac50edc3627ca0460d7',
USD: '0x8468b2bDCE073A157E560AA4D9CcF6dB1DB98507',
},
[EthereumNetwork.main]: {
[eEthereumNetwork.main]: {
AAVE: '0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012',
BAT: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
BUSD: '0x614715d2Af89E6EC99A233818275142cE88d1Cfd',
@ -261,7 +277,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0x2Da4983a622a8498bb1a21FaE9D8F6C664939962',
USD: '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419',
},
[EthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderlyMain]: {
AAVE: '0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012',
BAT: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
BUSD: '0x614715d2Af89E6EC99A233818275142cE88d1Cfd',
@ -288,10 +304,10 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.buidlerevm]: {},
[EthereumNetwork.main]: {},
[EthereumNetwork.kovan]: {},
[EthereumNetwork.ropsten]: {},
[EthereumNetwork.tenderlyMain]: {},
[eEthereumNetwork.main]: {},
[eEthereumNetwork.kovan]: {},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.tenderlyMain]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {

10
markets/aave/index.ts
View File

@ -1,5 +1,5 @@
import { oneRay, ZERO_ADDRESS } from '../../helpers/constants';
import { IAaveConfiguration, EthereumNetwork, eEthereumNetwork } from '../../helpers/types';
import { IAaveConfiguration, eEthereumNetwork } from '../../helpers/types';
import { CommonsConfig } from './commons';
import {
@ -60,7 +60,7 @@ export const AaveConfig: IAaveConfiguration = {
[eEthereumNetwork.buidlerevm]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.coverage]: {},
[EthereumNetwork.kovan]: {
[eEthereumNetwork.kovan]: {
AAVE: '0xB597cd8D3217ea6477232F9217fa70837ff667Af',
BAT: '0x2d12186Fbb9f9a8C28B3FfdD4c42920f8539D738',
BUSD: '0x4c6E1EFC12FDfD568186b7BAEc0A43fFfb4bCcCf',
@ -82,7 +82,7 @@ export const AaveConfig: IAaveConfiguration = {
YFI: '0xb7c325266ec274fEb1354021D27FA3E3379D840d',
ZRX: '0xD0d76886cF8D952ca26177EB7CfDf83bad08C00C',
},
[EthereumNetwork.ropsten]: {
[eEthereumNetwork.ropsten]: {
AAVE: '',
BAT: '0x85B24b3517E3aC7bf72a14516160541A60cFF19d',
BUSD: '0xFA6adcFf6A90c11f31Bc9bb59eC0a6efB38381C6',
@ -104,7 +104,7 @@ export const AaveConfig: IAaveConfiguration = {
YFI: ZERO_ADDRESS,
ZRX: '0x02d7055704EfF050323A2E5ee4ba05DB2A588959',
},
[EthereumNetwork.main]: {
[eEthereumNetwork.main]: {
AAVE: '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
BAT: '0x0d8775f648430679a709e98d2b0cb6250d2887ef',
BUSD: '0x4Fabb145d64652a948d72533023f6E7A623C7C53',
@ -127,7 +127,7 @@ export const AaveConfig: IAaveConfiguration = {
ZRX: '0xE41d2489571d322189246DaFA5ebDe1F4699F498',
xSUSHI: '0x8798249c2E607446EfB7Ad49eC89dD1865Ff4272',
},
[EthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderlyMain]: {
AAVE: '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
BAT: '0x0d8775f648430679a709e98d2b0cb6250d2887ef',
BUSD: '0x4Fabb145d64652a948d72533023f6E7A623C7C53',

105
markets/aave/rateStrategies.ts Normal file
View File

@ -0,0 +1,105 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
import { IInterestRateStrategyParams } from '../../helpers/types';
// BUSD SUSD
export const rateStrategyStableOne: IInterestRateStrategyParams = {
name: "rateStrategyStableOne",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
};
// DAI TUSD
export const rateStrategyStableTwo: IInterestRateStrategyParams = {
name: "rateStrategyStableTwo",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
}
// USDC USDT
export const rateStrategyStableThree: IInterestRateStrategyParams = {
name: "rateStrategyStableThree",
optimalUtilizationRate: new BigNumber(0.9).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
}
// WETH
export const rateStrategyWETH: IInterestRateStrategyParams = {
name: "rateStrategyWETH",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
}
// AAVE
export const rateStrategyAAVE: IInterestRateStrategyParams = {
name: "rateStrategyAAVE",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: '0',
variableRateSlope2: '0',
stableRateSlope1: '0',
stableRateSlope2: '0',
}
// BAT ENJ LINK MANA MKR REN YFI ZRX
export const rateStrategyVolatileOne: IInterestRateStrategyParams = {
name: "rateStrategyVolatileOne",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// KNC WBTC
export const rateStrategyVolatileTwo: IInterestRateStrategyParams = {
name: "rateStrategyVolatileTwo",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// SNX
export const rateStrategyVolatileThree: IInterestRateStrategyParams = {
name: "rateStrategyVolatileThree",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
export const rateStrategyVolatileFour: IInterestRateStrategyParams = {
name: "rateStrategyVolatileFour",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
}

162
markets/aave/reservesConfigs.ts
View File

@ -1,14 +1,19 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
import { eContractid, IReserveParams } from '../../helpers/types';
import {
rateStrategyStableOne,
rateStrategyStableTwo,
rateStrategyStableThree,
rateStrategyWETH,
rateStrategyAAVE,
rateStrategyVolatileOne,
rateStrategyVolatileTwo,
rateStrategyVolatileThree,
rateStrategyVolatileFour,
} from './rateStrategies';
export const strategyBUSD: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyStableOne,
baseLTVAsCollateral: '0',
liquidationThreshold: '0',
liquidationBonus: '0',
@ -20,12 +25,7 @@ export const strategyBUSD: IReserveParams = {
};
export const strategyDAI: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyStableTwo,
baseLTVAsCollateral: '7500',
liquidationThreshold: '8000',
liquidationBonus: '10500',
@ -37,12 +37,7 @@ export const strategyDAI: IReserveParams = {
};
export const strategySUSD: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyStableOne,
baseLTVAsCollateral: '0',
liquidationThreshold: '0',
liquidationBonus: '0',
@ -54,12 +49,7 @@ export const strategySUSD: IReserveParams = {
};
export const strategyTUSD: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyStableTwo,
baseLTVAsCollateral: '7500',
liquidationThreshold: '8000',
liquidationBonus: '10500',
@ -71,12 +61,7 @@ export const strategyTUSD: IReserveParams = {
};
export const strategyUSDC: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.9).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
@ -88,12 +73,7 @@ export const strategyUSDC: IReserveParams = {
};
export const strategyUSDT: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.9).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
@ -105,12 +85,7 @@ export const strategyUSDT: IReserveParams = {
};
export const strategyAAVE: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: '0',
variableRateSlope2: '0',
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyAAVE,
baseLTVAsCollateral: '5000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -122,12 +97,7 @@ export const strategyAAVE: IReserveParams = {
};
export const strategyBAT: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
@ -139,12 +109,7 @@ export const strategyBAT: IReserveParams = {
};
export const strategyENJ: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '5500',
liquidationThreshold: '6000',
liquidationBonus: '11000',
@ -156,12 +121,7 @@ export const strategyENJ: IReserveParams = {
};
export const strategyWETH: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyWETH,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8250',
liquidationBonus: '10500',
@ -173,12 +133,7 @@ export const strategyWETH: IReserveParams = {
};
export const strategyKNC: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileTwo,
baseLTVAsCollateral: '6000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -190,12 +145,7 @@ export const strategyKNC: IReserveParams = {
};
export const strategyLINK: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
@ -207,12 +157,7 @@ export const strategyLINK: IReserveParams = {
};
export const strategyMANA: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '6000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -224,12 +169,7 @@ export const strategyMANA: IReserveParams = {
};
export const strategyMKR: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '6000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -241,12 +181,7 @@ export const strategyMKR: IReserveParams = {
};
export const strategyREN: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '5500',
liquidationThreshold: '6000',
liquidationBonus: '11000',
@ -258,12 +193,7 @@ export const strategyREN: IReserveParams = {
};
export const strategySNX: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0.03).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.12).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyVolatileThree,
baseLTVAsCollateral: '1500',
liquidationThreshold: '4000',
liquidationBonus: '11000',
@ -274,13 +204,9 @@ export const strategySNX: IReserveParams = {
reserveFactor: '3500'
};
// Invalid borrow rates in params currently, replaced with snx params
export const strategyUNI: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: '0',
variableRateSlope2: '0',
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyVolatileThree,
baseLTVAsCollateral: '6000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -292,12 +218,7 @@ export const strategyUNI: IReserveParams = {
};
export const strategyWBTC: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileTwo,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
@ -309,12 +230,7 @@ export const strategyWBTC: IReserveParams = {
};
export const strategyYFI: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '4000',
liquidationThreshold: '5500',
liquidationBonus: '11500',
@ -326,12 +242,7 @@ export const strategyYFI: IReserveParams = {
};
export const strategyZRX: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
strategy: rateStrategyVolatileOne,
baseLTVAsCollateral: '6000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
@ -343,12 +254,7 @@ export const strategyZRX: IReserveParams = {
};
export const strategyXSUSHI: IReserveParams = {
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
strategy: rateStrategyVolatileFour,
baseLTVAsCollateral: '2500',
liquidationThreshold: '4500',
liquidationBonus: '11500',

338
markets/amm/commons.ts Normal file
View File

@ -0,0 +1,338 @@
import BigNumber from 'bignumber.js';
import {
oneEther,
oneRay,
RAY,
ZERO_ADDRESS,
MOCK_CHAINLINK_AGGREGATORS_PRICES,
} from '../../helpers/constants';
import { ICommonConfiguration, eEthereumNetwork } from '../../helpers/types';
// ----------------
// PROTOCOL GLOBAL PARAMS
// ----------------
export const CommonsConfig: ICommonConfiguration = {
MarketId: 'Commons',
ATokenNamePrefix: 'Aave AMM Market',
StableDebtTokenNamePrefix: 'Aave AMM Market stable debt',
VariableDebtTokenNamePrefix: 'Aave AMM Market variable debt',
SymbolPrefix: 'Amm',
ProviderId: 0, // Overriden in index.ts
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
UsdAddress: '0x10F7Fc1F91Ba351f9C629c5947AD69bD03C05b96',
NilAddress: '0x0000000000000000000000000000000000000000',
OneAddress: '0x0000000000000000000000000000000000000001',
AaveReferral: '0',
},
// ----------------
// COMMON PROTOCOL PARAMS ACROSS POOLS AND NETWORKS
// ----------------
Mocks: {
AllAssetsInitialPrices: {
...MOCK_CHAINLINK_AGGREGATORS_PRICES,
},
},
// TODO: reorg alphabetically, checking the reason of tests failing
LendingRateOracleRatesCommon: {
WETH: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
DAI: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDC: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDT: {
borrowRate: oneRay.multipliedBy(0.035).toFixed(),
},
WBTC: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
UniDAIWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniWBTCWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniAAVEWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniBATWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniDAIUSDC: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniCRVWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniLINKWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniMKRWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniRENWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniSNXWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniUNIWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniUSDCWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniWBTCUSDC: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
UniYFIWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
BptWBTCWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
BptBALWETH: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(),
},
},
// ----------------
// COMMON PROTOCOL ADDRESSES ACROSS POOLS
// ----------------
// If PoolAdmin/emergencyAdmin is set, will take priority over PoolAdminIndex/emergencyAdminIndex
PoolAdmin: {
[eEthereumNetwork.coverage]: undefined,
[eEthereumNetwork.buidlerevm]: undefined,
[eEthereumNetwork.coverage]: undefined,
[eEthereumNetwork.hardhat]: undefined,
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
},
PoolAdminIndex: 0,
EmergencyAdmin: {
[eEthereumNetwork.hardhat]: undefined,
[eEthereumNetwork.coverage]: undefined,
[eEthereumNetwork.buidlerevm]: undefined,
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
},
EmergencyAdminIndex: 1,
ProviderRegistry: {
[eEthereumNetwork.kovan]: '0x1E40B561EC587036f9789aF83236f057D1ed2A90',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
},
ProviderRegistryOwner: {
// DEPLOYED WITH CORRECT ADDRESS
[eEthereumNetwork.kovan]: '0x85e4A467343c0dc4aDAB74Af84448D9c45D8ae6F',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0xbd723fc4f1d737dcfc48a07fe7336766d34cad5f',
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0xbd723fc4f1d737dcfc48a07fe7336766d34cad5f',
},
LendingRateOracle: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '', // Updated to match Kovan deployment
[eEthereumNetwork.kovan]: '0xd00Bd28FAdDa9d5658D1D4e0c151973146C7A533', //'0xE48F95873855bfd97BF89572DDf5cBC44D9c545b'
[eEthereumNetwork.ropsten]: '0x05dcca805a6562c1bdd0423768754acb6993241b',
[eEthereumNetwork.main]: '', //'0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D', // Need to re-deploy because of onlyOwner
[eEthereumNetwork.tenderlyMain]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
},
LendingPoolCollateralManager: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x9269b6453d0d75370c4c85e5a42977a53efdb72a',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderlyMain]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
},
LendingPoolConfigurator: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x36eB31800aa67a9c50df1d56EE01981A6E14Cce5',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
LendingPool: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x78142De7a1930412E9e50dEB3b80dB284c2dFa3A',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
WethGateway: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x1c4A1cC35A477aa1cF35DF671d93ACc04d8131E0',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
TokenDistributor: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.kovan]: '0x971efe90088f21dc6a36f610ffed77fc19710708',
[eEthereumNetwork.ropsten]: '0xeba2ea67942b8250d870b12750b594696d02fc9c',
[eEthereumNetwork.main]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderlyMain]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
},
AaveOracle: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x8fb777d67e9945e2c01936e319057f9d41d559e6', // Need to re-deploy because of onlyOwner
[eEthereumNetwork.ropsten]: ZERO_ADDRESS,
[eEthereumNetwork.main]: '', //'0xA50ba011c48153De246E5192C8f9258A2ba79Ca9', // Need to re-deploy because of onlyOwner
[eEthereumNetwork.tenderlyMain]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
},
FallbackOracle: {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.kovan]: '0x50913E8E1c650E790F8a1E741FF9B1B1bB251dfe',
[eEthereumNetwork.ropsten]: '0xAD1a978cdbb8175b2eaeC47B01404f8AEC5f4F0d',
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[eEthereumNetwork.coverage]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.buidlerevm]: {},
[eEthereumNetwork.kovan]: {
USDT: '0x0bF499444525a23E7Bb61997539725cA2e928138',
WBTC: '0xF7904a295A029a3aBDFFB6F12755974a958C7C25',
USDC: '0x64EaC61A2DFda2c3Fa04eED49AA33D021AeC8838',
DAI: '0x22B58f1EbEDfCA50feF632bD73368b2FdA96D541',
UniDAIWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F', // Mock oracles
UniWBTCWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniAAVEWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniBATWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniDAIUSDC: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniCRVWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniLINKWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniMKRWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniRENWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniSNXWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniUNIWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniUSDCWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniWBTCUSDC: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
UniYFIWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
BptWBTCWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
BptBALWETH: '0x5699302154A020FB1DE2B1d39f4c73785A235d8F',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.main]: {
USDT: '0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46',
WBTC: '0xdeb288F737066589598e9214E782fa5A8eD689e8',
USDC: '0x986b5E1e1755e3C2440e960477f25201B0a8bbD4',
DAI: '0x773616E4d11A78F511299002da57A0a94577F1f4',
UniDAIWETH: '0xf4071801C4421Db7e63DaC15B9432e50C44a7F42',
UniWBTCWETH: '0x55EF7F1226507cFd846DE009C2f097c2211b6Fb8',
UniAAVEWETH: '0x5671387d56eAB334A2D65d6D0BB4D907898C7abA',
UniBATWETH: '0xA61ca04DF33B72b235a8A28CfB535bb7A5271B70',
UniDAIUSDC: '0xFd8dFc92B030e6BA957336e9f08C2a711e19069A',
UniCRVWETH: '0xd4D344D076256Fdf806375983b2cab2Db52FD506',
UniLINKWETH: '0x8C0e5df19B998F06e57A1Db1a38232F7590abe4b',
UniMKRWETH: '0x92f2A28fE33E0b6Ea218057EEe004E3B2B6de45d',
UniRENWETH: '0xFc0398b247107138dB494395600fB0d075b72C9A',
UniSNXWETH: '0xF5CB13c859383B5fb070bd111Cae7a900c00BA07',
UniUNIWETH: '0xE50e47E37DCF55dE1c5F2c32d346BB52064f7CE6',
UniUSDCWETH: '0xBE6ac123799572c98eFdE48895465AB392534AFD',
UniWBTCUSDC: '0xd6b8b08a0d13994A5f4a1949F4870DE57e9B40d9',
UniYFIWETH: '0x94daB35789f05f54224F6851921160DE21318072',
BptWBTCWETH: '0x4a2731c9f3B4355922c676f9b538278D79C299C5',
BptBALWETH: '0xD9400999f38E1877a6dDDb0090A327F19257f9AE',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[eEthereumNetwork.tenderlyMain]: {
USDT: '0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46',
WBTC: '0xdeb288F737066589598e9214E782fa5A8eD689e8',
USDC: '0x986b5E1e1755e3C2440e960477f25201B0a8bbD4',
DAI: '0x773616E4d11A78F511299002da57A0a94577F1f4',
UniDAIWETH: '0xf4071801C4421Db7e63DaC15B9432e50C44a7F42',
UniWBTCWETH: '0x55EF7F1226507cFd846DE009C2f097c2211b6Fb8',
UniAAVEWETH: '0x5671387d56eAB334A2D65d6D0BB4D907898C7abA',
UniBATWETH: '0xA61ca04DF33B72b235a8A28CfB535bb7A5271B70',
UniDAIUSDC: '0xFd8dFc92B030e6BA957336e9f08C2a711e19069A',
UniCRVWETH: '0xd4D344D076256Fdf806375983b2cab2Db52FD506',
UniLINKWETH: '0x8C0e5df19B998F06e57A1Db1a38232F7590abe4b',
UniMKRWETH: '0x92f2A28fE33E0b6Ea218057EEe004E3B2B6de45d',
UniRENWETH: '0xFc0398b247107138dB494395600fB0d075b72C9A',
UniSNXWETH: '0xF5CB13c859383B5fb070bd111Cae7a900c00BA07',
UniUNIWETH: '0xE50e47E37DCF55dE1c5F2c32d346BB52064f7CE6',
UniUSDCWETH: '0xBE6ac123799572c98eFdE48895465AB392534AFD',
UniWBTCUSDC: '0xd6b8b08a0d13994A5f4a1949F4870DE57e9B40d9',
UniYFIWETH: '0x94daB35789f05f54224F6851921160DE21318072',
BptWBTCWETH: '0x4a2731c9f3B4355922c676f9b538278D79C299C5',
BptBALWETH: '0xD9400999f38E1877a6dDDb0090A327F19257f9AE',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
},
ReserveAssets: {
[eEthereumNetwork.coverage]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.buidlerevm]: {},
[eEthereumNetwork.main]: {},
[eEthereumNetwork.kovan]: {},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.tenderlyMain]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {
[eEthereumNetwork.coverage]:
'0x95b73a72c6ecf4ccbbba5178800023260bad8e75cdccdb8e4827a2977a37c820',
[eEthereumNetwork.hardhat]:
'0xbae024d959c6a022dc5ed37294cd39c141034b2ae5f02a955cce75c930a81bf5',
[eEthereumNetwork.buidlerevm]:
'0xbae024d959c6a022dc5ed37294cd39c141034b2ae5f02a955cce75c930a81bf5',
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
},
WETH: {
[eEthereumNetwork.coverage]: '', // deployed in local evm
[eEthereumNetwork.hardhat]: '', // deployed in local evm
[eEthereumNetwork.buidlerevm]: '', // deployed in local evm
[eEthereumNetwork.kovan]: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
[eEthereumNetwork.ropsten]: '0xc778417e063141139fce010982780140aa0cd5ab',
[eEthereumNetwork.main]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderlyMain]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
},
ReserveFactorTreasuryAddress: {
[eEthereumNetwork.coverage]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.hardhat]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.buidlerevm]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.kovan]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.ropsten]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.main]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.tenderlyMain]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
},
};

137
markets/amm/index.ts Normal file
View File

@ -0,0 +1,137 @@
import { oneRay, ZERO_ADDRESS } from '../../helpers/constants';
import { IAmmConfiguration, eEthereumNetwork } from '../../helpers/types';
import { CommonsConfig } from './commons';
import {
strategyDAI,
strategyUSDC,
strategyUSDT,
strategyWETH,
strategyWBTC,
strategyWBTCWETH,
strategyDAIWETH,
strategyAAVEWETH,
strategyBATWETH,
strategyDAIUSDC,
strategyCRVWETH,
strategyLINKWETH,
strategyMKRWETH,
strategyRENWETH,
strategySNXWETH,
strategyUNIWETH,
strategyUSDCWETH,
strategyWBTCUSDC,
strategyYFIWETH,
strategyBALWETH,
} from './reservesConfigs';
// ----------------
// POOL--SPECIFIC PARAMS
// ----------------
export const AmmConfig: IAmmConfiguration = {
...CommonsConfig,
MarketId: 'Aave AMM market',
ProviderId: 2,
ReservesConfig: {
WETH: strategyWETH,
DAI: strategyDAI,
USDC: strategyUSDC,
USDT: strategyUSDT,
WBTC: strategyWBTC,
UniDAIWETH: strategyDAIWETH,
UniWBTCWETH: strategyWBTCWETH,
UniAAVEWETH: strategyAAVEWETH,
UniBATWETH: strategyBATWETH,
UniDAIUSDC: strategyDAIUSDC,
UniCRVWETH: strategyCRVWETH,
UniLINKWETH: strategyLINKWETH,
UniMKRWETH: strategyMKRWETH,
UniRENWETH: strategyRENWETH,
UniSNXWETH: strategySNXWETH,
UniUNIWETH: strategyUNIWETH,
UniUSDCWETH: strategyUSDCWETH,
UniWBTCUSDC: strategyWBTCUSDC,
UniYFIWETH: strategyYFIWETH,
BptWBTCWETH: strategyWBTCWETH,
BptBALWETH: strategyBALWETH,
},
ReserveAssets: {
[eEthereumNetwork.buidlerevm]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.coverage]: {},
[eEthereumNetwork.kovan]: {
DAI: '0xFf795577d9AC8bD7D90Ee22b6C1703490b6512FD',
USDC: '0xe22da380ee6B445bb8273C81944ADEB6E8450422',
USDT: '0x13512979ADE267AB5100878E2e0f485B568328a4',
WBTC: '0xD1B98B6607330172f1D991521145A22BCe793277',
WETH: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
UniDAIWETH: '0x0C652EeEA3d7D35759ba1E16183F1D89C386C9ea',
UniWBTCWETH: '0x796d562B1dF5b9dc85A4612187B6f29Ed213d960',
UniAAVEWETH: '0x657A7B8b46F35C5C6583AEF43824744B236EF826',
UniBATWETH: '0xf8CEBA8b16579956B3aE4B5D09002a30f873F783',
UniDAIUSDC: '0x8e80b7a7531c276dD1dBEC2f1Cc281c11c859e62',
UniCRVWETH: '0x9c31b7538467bF0b01e6d5fA789e66Ce540a521e',
UniLINKWETH: '0x5Acab7f8B79620ec7127A96E5D8837d2124D5D7c',
UniMKRWETH: '0xB0C6EC5d58ddbF4cd1e419A56a19924E9904e4Dd',
UniRENWETH: '0xcF428637A9f8Af21920Bc0A94fd81071bc790105',
UniSNXWETH: '0xc8F2a0d698f675Ece74042e9fB06ea52b9517521',
UniUNIWETH: '0xcC99A5f95a86d30e3DeF113bCf22f00ecF90D050',
UniUSDCWETH: '0x8C00D2428ed1857E61652aca663323A85E6e76a9',
UniWBTCUSDC: '0x3d35B5F289f55A580e6F85eE22E6a8f57053b966',
UniYFIWETH: '0x5af95ddFACC150a1695A3Fc606459fd0dE57b91f',
BptWBTCWETH: '0x110569E3261bC0934dA637b019f6f1b6F50ec574',
BptBALWETH: '0xad01D8e0Fa9EAA8Fe76dA30CFb1BCe12707aE6c5',
},
[eEthereumNetwork.ropsten]: {
},
[eEthereumNetwork.main]: {
DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
WBTC: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
UniDAIWETH: '0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11',
UniWBTCWETH: '0xBb2b8038a1640196FbE3e38816F3e67Cba72D940',
UniAAVEWETH: '0xDFC14d2Af169B0D36C4EFF567Ada9b2E0CAE044f',
UniBATWETH: '0xB6909B960DbbE7392D405429eB2b3649752b4838',
UniDAIUSDC: '0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5',
UniCRVWETH: '0x3dA1313aE46132A397D90d95B1424A9A7e3e0fCE',
UniLINKWETH: '0xa2107FA5B38d9bbd2C461D6EDf11B11A50F6b974',
UniMKRWETH: '0xC2aDdA861F89bBB333c90c492cB837741916A225',
UniRENWETH: '0x8Bd1661Da98EBDd3BD080F0bE4e6d9bE8cE9858c',
UniSNXWETH: '0x43AE24960e5534731Fc831386c07755A2dc33D47',
UniUNIWETH: '0xd3d2E2692501A5c9Ca623199D38826e513033a17',
UniUSDCWETH: '0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc',
UniWBTCUSDC: '0x004375Dff511095CC5A197A54140a24eFEF3A416',
UniYFIWETH: '0x2fDbAdf3C4D5A8666Bc06645B8358ab803996E28',
BptWBTCWETH: '0x1efF8aF5D577060BA4ac8A29A13525bb0Ee2A3D5',
BptBALWETH: '0x59A19D8c652FA0284f44113D0ff9aBa70bd46fB4',
},
[eEthereumNetwork.tenderlyMain]: {
DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
WBTC: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
UniDAIWETH: '0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11',
UniWBTCWETH: '0xBb2b8038a1640196FbE3e38816F3e67Cba72D940',
UniAAVEWETH: '0xDFC14d2Af169B0D36C4EFF567Ada9b2E0CAE044f',
UniBATWETH: '0xB6909B960DbbE7392D405429eB2b3649752b4838',
UniDAIUSDC: '0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5',
UniCRVWETH: '0x3dA1313aE46132A397D90d95B1424A9A7e3e0fCE',
UniLINKWETH: '0xa2107FA5B38d9bbd2C461D6EDf11B11A50F6b974',
UniMKRWETH: '0xC2aDdA861F89bBB333c90c492cB837741916A225',
UniRENWETH: '0x8Bd1661Da98EBDd3BD080F0bE4e6d9bE8cE9858c',
UniSNXWETH: '0x43AE24960e5534731Fc831386c07755A2dc33D47',
UniUNIWETH: '0xd3d2E2692501A5c9Ca623199D38826e513033a17',
UniUSDCWETH: '0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc',
UniWBTCUSDC: '0x004375Dff511095CC5A197A54140a24eFEF3A416',
UniYFIWETH: '0x2fDbAdf3C4D5A8666Bc06645B8358ab803996E28',
BptWBTCWETH: '0x1efF8aF5D577060BA4ac8A29A13525bb0Ee2A3D5',
BptBALWETH: '0x59A19D8c652FA0284f44113D0ff9aBa70bd46fB4',
},
},
};
export default AmmConfig;

36
markets/amm/rateStrategies.ts Normal file
View File

@ -0,0 +1,36 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
import { IInterestRateStrategyParams } from '../../helpers/types';
// DAIWETH WBTCWETH AAVEWETH BATWETH DAIUSDC CRVWETH LINKWETH MKRWETH RENWETH SNXWETH UNIWETH USDCWETH WBTCUSDC YFIWETH
export const rateStrategyAmmBase: IInterestRateStrategyParams = {
name: "rateStrategyAmmBase",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0.03).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.10).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3.00).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// WETH WBTC
export const rateStrategyBaseOne: IInterestRateStrategyParams = {
name: "rateStrategyBaseOne",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
}
// DAI USDC USDT
export const rateStrategyStable: IInterestRateStrategyParams = {
name: "rateStrategyStable",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
}

247
markets/amm/reservesConfigs.ts Normal file
View File

@ -0,0 +1,247 @@
import { eContractid, IReserveParams} from '../../helpers/types';
import {
rateStrategyAmmBase,
rateStrategyStable,
rateStrategyBaseOne,
} from './rateStrategies';
export const strategyWETH: IReserveParams = {
strategy: rateStrategyBaseOne,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8250',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWBTC: IReserveParams = {
strategy: rateStrategyBaseOne,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '8',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};
export const strategyDAI: IReserveParams = {
strategy: rateStrategyStable,
baseLTVAsCollateral: '7500',
liquidationThreshold: '8000',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDC: IReserveParams = {
strategy: rateStrategyStable,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDT: IReserveParams = {
strategy: rateStrategyStable,
baseLTVAsCollateral: '-1',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyDAIWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWBTCWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyAAVEWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '500'
};
export const strategyBATWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyDAIUSDC: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyCRVWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '5000',
liquidationThreshold: '6000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyLINKWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyMKRWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyRENWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategySNXWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '4000',
liquidationThreshold: '6000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};
export const strategyUNIWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyUSDCWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWBTCUSDC: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyYFIWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '5000',
liquidationThreshold: '6000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
};
export const strategyBALWETH: IReserveParams = {
strategy: rateStrategyAmmBase,
baseLTVAsCollateral: '6000',
liquidationThreshold: '7000',
liquidationBonus: '11500',
borrowingEnabled: true,
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1500'
}

0
markets/arbitrum/commons.ts Normal file
View File

1
markets/arbitrum/index.ts Normal file
View File

@ -0,0 +1 @@

0
markets/arbitrum/rateStrategies.ts Normal file
View File

0
markets/arbitrum/reservesConfigs.ts Normal file
View File

0
markets/bsc/commons.ts Normal file
View File

1
markets/bsc/index.ts Normal file
View File

@ -0,0 +1 @@

0
markets/bsc/rateStrategies.ts Normal file
View File

0
markets/bsc/reservesConfigs.ts Normal file
View File

144
markets/matic/commons.ts Normal file
View File

@ -0,0 +1,144 @@
import BigNumber from 'bignumber.js';
import { oneEther, oneRay, RAY, ZERO_ADDRESS, MOCK_CHAINLINK_AGGREGATORS_PRICES } from '../../helpers/constants';
import { ICommonConfiguration, ePolygonNetwork } from '../../helpers/types';
// ----------------
// PROTOCOL GLOBAL PARAMS
// ----------------
export const CommonsConfig: ICommonConfiguration = {
MarketId: 'Commons',
ATokenNamePrefix: 'Aave Matic Market',
StableDebtTokenNamePrefix: 'Aave Matic Market stable debt',
VariableDebtTokenNamePrefix: 'Aave Matic Market variable debt',
SymbolPrefix: 'm',
ProviderId: 0, // Overriden in index.ts
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
UsdAddress: '0x10F7Fc1F91Ba351f9C629c5947AD69bD03C05b96',
NilAddress: '0x0000000000000000000000000000000000000000',
OneAddress: '0x0000000000000000000000000000000000000001',
AaveReferral: '0',
},
// ----------------
// COMMON PROTOCOL PARAMS ACROSS POOLS AND NETWORKS
// ----------------
Mocks: {
AllAssetsInitialPrices: {
...MOCK_CHAINLINK_AGGREGATORS_PRICES,
},
},
// TODO: reorg alphabetically, checking the reason of tests failing
LendingRateOracleRatesCommon: {
WETH: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
DAI: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDC: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDT: {
borrowRate: oneRay.multipliedBy(0.035).toFixed(),
},
WBTC: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
WMATIC: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(), // TEMP
},
},
// ----------------
// COMMON PROTOCOL ADDRESSES ACROSS POOLS
// ----------------
// If PoolAdmin/emergencyAdmin is set, will take priority over PoolAdminIndex/emergencyAdminIndex
PoolAdmin: {
[ePolygonNetwork.mumbai]: undefined,
[ePolygonNetwork.matic]: undefined,
},
PoolAdminIndex: 0,
EmergencyAdmin: {
[ePolygonNetwork.mumbai]: undefined,
[ePolygonNetwork.matic]: undefined,
},
LendingPool: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '0xABdC61Cd16e5111f335f4135B7A0e65Cc7F86327',
},
LendingPoolConfigurator: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '0x17c4A170FFF882862F656597889016D3a6073534',
},
EmergencyAdminIndex: 1,
ProviderRegistry: {
[ePolygonNetwork.mumbai]: '0x569859d41499B4dDC28bfaA43915051FF0A38a6F', // TEMP
[ePolygonNetwork.matic]: '0x28334e4791860a0c1eCF89a62B973ba04a5d643F', // TEMP
},
ProviderRegistryOwner: {
[ePolygonNetwork.mumbai]: '0x18d9bA2baEfBdE0FF137C4ad031427EF205f1Fd9', // TEMP
[ePolygonNetwork.matic]: '0x85e4A467343c0dc4aDAB74Af84448D9c45D8ae6F', // TEMP
},
LendingRateOracle: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '',
},
LendingPoolCollateralManager: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '0x9Af76e0575D139570D3B4c821567Fe935E8c25C5',
},
TokenDistributor: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '',
},
WethGateway: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '0x15A46f5073789b7D16F6F46632aE50Bae838d938',
},
AaveOracle: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '0x1B38fa90596F2C25bCf1B193A6c6a718349AFDfC',
},
FallbackOracle: {
[ePolygonNetwork.mumbai]: ZERO_ADDRESS,
[ePolygonNetwork.matic]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[ePolygonNetwork.matic]: {
DAI: '0x4746DeC9e833A82EC7C2C1356372CcF2cfcD2F3D',
USDC: '0xfE4A8cc5b5B2366C1B58Bea3858e81843581b2F7',
USDT: '0x0A6513e40db6EB1b165753AD52E80663aeA50545',
WBTC: '0xc907E116054Ad103354f2D350FD2514433D57F6f',
WETH: '0xF9680D99D6C9589e2a93a78A04A279e509205945',
WMATIC: '0xAB594600376Ec9fD91F8e885dADF0CE036862dE0',
},
[ePolygonNetwork.mumbai]: {
DAI: ZERO_ADDRESS,
USDC: ZERO_ADDRESS,
USDT: ZERO_ADDRESS,
WBTC: ZERO_ADDRESS,
WMATIC: ZERO_ADDRESS,
},
},
ReserveAssets: {
[ePolygonNetwork.matic]: {},
[ePolygonNetwork.mumbai]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {
[ePolygonNetwork.mumbai]: '',
[ePolygonNetwork.matic]: '',
},
WETH: {
[ePolygonNetwork.mumbai]: '0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889', // WMATIC address (untested)
[ePolygonNetwork.matic]: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270', // WMATIC address
},
ReserveFactorTreasuryAddress: {
[ePolygonNetwork.mumbai]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c', // TEMP
[ePolygonNetwork.matic]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c', // TEMP
},
};

50
markets/matic/index.ts Normal file
View File

@ -0,0 +1,50 @@
import { oneRay, ZERO_ADDRESS } from '../../helpers/constants';
import { IMaticConfiguration, ePolygonNetwork } from '../../helpers/types';
import { CommonsConfig } from './commons';
import {
strategyDAI,
strategyUSDC,
strategyUSDT,
strategyWBTC,
strategyWETH,
strategyMATIC,
} from './reservesConfigs';
// ----------------
// POOL--SPECIFIC PARAMS
// ----------------
export const MaticConfig: IMaticConfiguration = {
...CommonsConfig,
MarketId: 'Matic Market',
ProviderId: 3, // Unknown?
ReservesConfig: {
DAI: strategyDAI,
USDC: strategyUSDC,
USDT: strategyUSDT,
WBTC: strategyWBTC,
WETH: strategyWETH,
WMATIC: strategyMATIC,
},
ReserveAssets: {
[ePolygonNetwork.matic]: {
DAI: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063',
USDC: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
WBTC: '0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6',
WETH: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
WMATIC: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
},
[ePolygonNetwork.mumbai]: { // Mock tokens with a simple "mint" external function, except wmatic
DAI: '0x13b3fda609C1eeb23b4F4b69257840760dCa6C4a',
USDC: '0x52b63223994433FdE2F1350Ba69Dfd2779f06ABA',
USDT: '0xB3abd1912F586fDFFa13606882c28E27913853d2',
WBTC: '0x393E3512d45a956A628124665672312ea86930Ba',
WETH: '0x53CDb16B8C031B779e996406546614E5F05BC4Bf',
WMATIC: '0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889',
},
},
};
export default MaticConfig;

91
markets/matic/rateStrategies.ts Normal file
View File

@ -0,0 +1,91 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
import { IInterestRateStrategyParams } from '../../helpers/types';
// BUSD SUSD
export const rateStrategyStableOne: IInterestRateStrategyParams = {
name: "rateStrategyStableOne",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
};
// DAI TUSD
export const rateStrategyStableTwo: IInterestRateStrategyParams = {
name: "rateStrategyStableTwo",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
}
// USDC USDT
export const rateStrategyStableThree: IInterestRateStrategyParams = {
name: "rateStrategyStableThree",
optimalUtilizationRate: new BigNumber(0.9).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
}
// WETH
export const rateStrategyWETH: IInterestRateStrategyParams = {
name: "rateStrategyWETH",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
}
// AAVE
export const rateStrategyAAVE: IInterestRateStrategyParams = {
name: "rateStrategyAAVE",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: '0',
variableRateSlope2: '0',
stableRateSlope1: '0',
stableRateSlope2: '0',
}
// BAT ENJ LINK MANA MKR REN YFI ZRX
export const rateStrategyVolatileOne: IInterestRateStrategyParams = {
name: "rateStrategyVolatileOne",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// KNC WBTC
export const rateStrategyVolatileTwo: IInterestRateStrategyParams = {
name: "rateStrategyVolatileTwo",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// SNX
export const rateStrategyVolatileThree: IInterestRateStrategyParams = {
name: "rateStrategyVolatileThree",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}

85
markets/matic/reservesConfigs.ts Normal file
View File

@ -0,0 +1,85 @@
// import BigNumber from 'bignumber.js';
// import { oneRay } from '../../helpers/constants';
import { eContractid, IReserveParams } from '../../helpers/types';
import {
rateStrategyStableOne,
rateStrategyStableTwo,
rateStrategyStableThree,
rateStrategyWETH,
rateStrategyAAVE,
rateStrategyVolatileOne,
rateStrategyVolatileTwo,
rateStrategyVolatileThree,
} from './rateStrategies';
export const strategyDAI: IReserveParams = {
strategy: rateStrategyStableTwo,
baseLTVAsCollateral: '7500',
liquidationThreshold: '8000',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDC: IReserveParams = {
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDT: IReserveParams = {
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWETH: IReserveParams = {
strategy: rateStrategyWETH,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8250',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWBTC: IReserveParams = {
strategy: rateStrategyVolatileTwo,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '8',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};
export const strategyMATIC: IReserveParams = {
strategy: rateStrategyVolatileOne, //Temp?
baseLTVAsCollateral: '5000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};

0
markets/ovm/commons.ts Normal file
View File

1
markets/ovm/index.ts Normal file
View File

@ -0,0 +1 @@

0
markets/ovm/rateStrategies.ts Normal file
View File

0
markets/ovm/reservesConfigs.ts Normal file
View File

0
markets/solana/commons.ts Normal file
View File

1
markets/solana/index.ts Normal file
View File

@ -0,0 +1 @@

0
markets/solana/rateStrategies.ts Normal file
View File

0
markets/solana/reservesConfigs.ts Normal file
View File

120
markets/xdai/commons.ts Normal file
View File

@ -0,0 +1,120 @@
import BigNumber from 'bignumber.js';
import { oneEther, oneRay, RAY, ZERO_ADDRESS, MOCK_CHAINLINK_AGGREGATORS_PRICES } from '../../helpers/constants';
import { ICommonConfiguration, eXDaiNetwork } from '../../helpers/types';
// ----------------
// PROTOCOL GLOBAL PARAMS
// ----------------
export const CommonsConfig: ICommonConfiguration = {
MarketId: 'Commons',
ATokenNamePrefix: 'Aave XDAI Market',
StableDebtTokenNamePrefix: 'Aave XDAI Market stable debt',
VariableDebtTokenNamePrefix: 'Aave XDAI Market variable debt',
SymbolPrefix: 'm',
ProviderId: 0, // Overriden in index.ts
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
UsdAddress: '0x10F7Fc1F91Ba351f9C629c5947AD69bD03C05b96',
NilAddress: '0x0000000000000000000000000000000000000000',
OneAddress: '0x0000000000000000000000000000000000000001',
AaveReferral: '0',
},
// ----------------
// COMMON PROTOCOL PARAMS ACROSS POOLS AND NETWORKS
// ----------------
Mocks: {
AllAssetsInitialPrices: {
...MOCK_CHAINLINK_AGGREGATORS_PRICES,
},
},
// TODO: reorg alphabetically, checking the reason of tests failing
LendingRateOracleRatesCommon: {
WETH: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
DAI: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDC: {
borrowRate: oneRay.multipliedBy(0.039).toFixed(),
},
USDT: {
borrowRate: oneRay.multipliedBy(0.035).toFixed(),
},
WBTC: {
borrowRate: oneRay.multipliedBy(0.03).toFixed(),
},
STAKE: {
borrowRate: oneRay.multipliedBy(0.05).toFixed(), // TEMP
},
},
// ----------------
// COMMON PROTOCOL ADDRESSES ACROSS POOLS
// ----------------
// If PoolAdmin/emergencyAdmin is set, will take priority over PoolAdminIndex/emergencyAdminIndex
PoolAdmin: {
[eXDaiNetwork.xdai]: undefined,
},
PoolAdminIndex: 0,
EmergencyAdmin: {
[eXDaiNetwork.xdai]: undefined,
},
EmergencyAdminIndex: 1,
ProviderRegistry: {
[eXDaiNetwork.xdai]: '',
},
ProviderRegistryOwner: {
[eXDaiNetwork.xdai]: '',
},
LendingPoolConfigurator: {
[eXDaiNetwork.xdai]: '0',
},
LendingPool: {
[eXDaiNetwork.xdai]: '0',
},
LendingRateOracle: {
[eXDaiNetwork.xdai]: '',
},
LendingPoolCollateralManager: {
[eXDaiNetwork.xdai]: '',
},
TokenDistributor: {
[eXDaiNetwork.xdai]: '',
},
WethGateway: {
[eXDaiNetwork.xdai]: '',
},
AaveOracle: {
[eXDaiNetwork.xdai]: '',
},
FallbackOracle: {
[eXDaiNetwork.xdai]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[eXDaiNetwork.xdai]: {
DAI: ZERO_ADDRESS,
USDC: ZERO_ADDRESS,
USDT: ZERO_ADDRESS,
WBTC: ZERO_ADDRESS,
STAKE: ZERO_ADDRESS,
},
},
ReserveAssets: {
[eXDaiNetwork.xdai]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {
[eXDaiNetwork.xdai]: '',
},
WETH: {
[eXDaiNetwork.xdai]: '', // DAI: xDAI is the base token, DAI is also there, We need WXDAI
},
ReserveFactorTreasuryAddress: {
[eXDaiNetwork.xdai]: '', // TEMP
},
};

42
markets/xdai/index.ts Normal file
View File

@ -0,0 +1,42 @@
import { oneRay, ZERO_ADDRESS } from '../../helpers/constants';
import { IXDAIConfiguration, eXDaiNetwork } from '../../helpers/types';
import { CommonsConfig } from './commons';
import {
strategyDAI,
strategyUSDC,
strategyUSDT,
strategyWBTC,
strategyWETH,
strategySTAKE,
} from './reservesConfigs';
// ----------------
// POOL--SPECIFIC PARAMS
// ----------------
export const XDAIConfig: IXDAIConfiguration = {
...CommonsConfig,
MarketId: 'XDAI Market',
ProviderId: 4, // Unknown?
ReservesConfig: {
DAI: strategyDAI,
USDC: strategyUSDC,
USDT: strategyUSDT,
WBTC: strategyWBTC,
WETH: strategyWETH,
STAKE: strategySTAKE,
},
ReserveAssets: {
[eXDaiNetwork.xdai]: {
DAI: '0x44fA8E6f47987339850636F88629646662444217',
USDC: '0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83',
USDT: '0x4ECaBa5870353805a9F068101A40E0f32ed605C6',
WBTC: '0x8e5bBbb09Ed1ebdE8674Cda39A0c169401db4252',
WETH: '0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1',
STAKE: '0xb7D311E2Eb55F2f68a9440da38e7989210b9A05e'
},
},
};
export default XDAIConfig;

91
markets/xdai/rateStrategies.ts Normal file
View File

@ -0,0 +1,91 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
import { IInterestRateStrategyParams } from '../../helpers/types';
// BUSD SUSD
export const rateStrategyStableOne: IInterestRateStrategyParams = {
name: "rateStrategyStableOne",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: '0',
stableRateSlope2: '0',
};
// DAI TUSD
export const rateStrategyStableTwo: IInterestRateStrategyParams = {
name: "rateStrategyStableTwo",
optimalUtilizationRate: new BigNumber(0.8).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.75).multipliedBy(oneRay).toFixed(),
}
// USDC USDT
export const rateStrategyStableThree: IInterestRateStrategyParams = {
name: "rateStrategyStableThree",
optimalUtilizationRate: new BigNumber(0.9).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.04).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.02).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(0.60).multipliedBy(oneRay).toFixed(),
}
// WETH
export const rateStrategyWETH: IInterestRateStrategyParams = {
name: "rateStrategyWETH",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(1).multipliedBy(oneRay).toFixed(),
}
// AAVE
export const rateStrategyAAVE: IInterestRateStrategyParams = {
name: "rateStrategyAAVE",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: '0',
variableRateSlope1: '0',
variableRateSlope2: '0',
stableRateSlope1: '0',
stableRateSlope2: '0',
}
// BAT ENJ LINK MANA MKR REN YFI ZRX
export const rateStrategyVolatileOne: IInterestRateStrategyParams = {
name: "rateStrategyVolatileOne",
optimalUtilizationRate: new BigNumber(0.45).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.07).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// KNC WBTC
export const rateStrategyVolatileTwo: IInterestRateStrategyParams = {
name: "rateStrategyVolatileTwo",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}
// SNX
export const rateStrategyVolatileThree: IInterestRateStrategyParams = {
name: "rateStrategyVolatileThree",
optimalUtilizationRate: new BigNumber(0.65).multipliedBy(oneRay).toFixed(),
baseVariableBorrowRate: new BigNumber(0).multipliedBy(oneRay).toFixed(),
variableRateSlope1: new BigNumber(0.08).multipliedBy(oneRay).toFixed(),
variableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
stableRateSlope1: new BigNumber(0.1).multipliedBy(oneRay).toFixed(),
stableRateSlope2: new BigNumber(3).multipliedBy(oneRay).toFixed(),
}

85
markets/xdai/reservesConfigs.ts Normal file
View File

@ -0,0 +1,85 @@
// import BigNumber from 'bignumber.js';
// import { oneRay } from '../../helpers/constants';
import { eContractid, IReserveParams } from '../../helpers/types';
import {
rateStrategyStableOne,
rateStrategyStableTwo,
rateStrategyStableThree,
rateStrategyWETH,
rateStrategyAAVE,
rateStrategyVolatileOne,
rateStrategyVolatileTwo,
rateStrategyVolatileThree,
} from './rateStrategies';
export const strategyDAI: IReserveParams = {
strategy: rateStrategyStableTwo,
baseLTVAsCollateral: '7500',
liquidationThreshold: '8000',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDC: IReserveParams = {
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyUSDT: IReserveParams = {
strategy: rateStrategyStableThree,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8500',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWETH: IReserveParams = {
strategy: rateStrategyWETH,
baseLTVAsCollateral: '8000',
liquidationThreshold: '8250',
liquidationBonus: '10500',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
};
export const strategyWBTC: IReserveParams = {
strategy: rateStrategyVolatileTwo,
baseLTVAsCollateral: '7000',
liquidationThreshold: '7500',
liquidationBonus: '11000',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '8',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};
export const strategySTAKE: IReserveParams = {
strategy: rateStrategyVolatileOne, //Temp?
baseLTVAsCollateral: '5000',
liquidationThreshold: '6500',
liquidationBonus: '11000',
borrowingEnabled: true,
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
};

0
markets/zksync/commons.ts Normal file
View File

1
markets/zksync/index.ts Normal file
View File

@ -0,0 +1 @@

0
markets/zksync/rateStrategies.ts Normal file
View File

0
markets/zksync/reservesConfigs.ts Normal file
View File

313
package-lock.json generated
View File

@ -1172,9 +1172,9 @@
}
},
"@tenderly/hardhat-tenderly": {
"version": "1.1.0-beta.3",
"resolved": "https://registry.npmjs.org/@tenderly/hardhat-tenderly/-/hardhat-tenderly-1.1.0-beta.3.tgz",
"integrity": "sha512-CCiS3bBCc4MhOTI5oHRAuVy/Xan6/8oNnjiwbsRvG1hdUis+EL/UVwn5yrUM1qXQTPz/La3TvRkfEa/pq1gimw==",
"version": "1.1.0-beta.4",
"resolved": "https://registry.npmjs.org/@tenderly/hardhat-tenderly/-/hardhat-tenderly-1.1.0-beta.4.tgz",
"integrity": "sha512-B1KU0e+17KKstFLgyN1jy6ynNTZoHaVCy+1Wkx7WFnMJTfXQZEijmIyw48dLjUKvbaKWvgP7dE3VSoQnfKwo8g==",
"dev": true,
"requires": {
"axios": "^0.20.0",
@ -1183,21 +1183,21 @@
},
"dependencies": {
"fs-extra": {
"version": "9.0.1",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.0.1.tgz",
"integrity": "sha512-h2iAoN838FqAFJY2/qVpzFXy+EBxfVE220PalAqQLDVsFOHLJrZvut5puAbCdNv6WJk+B8ihI+k0c7JK5erwqQ==",
"version": "9.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
"integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
"dev": true,
"requires": {
"at-least-node": "^1.0.0",
"graceful-fs": "^4.2.0",
"jsonfile": "^6.0.1",
"universalify": "^1.0.0"
"universalify": "^2.0.0"
}
},
"js-yaml": {
"version": "3.14.0",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.0.tgz",
"integrity": "sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==",
"version": "3.14.1",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
"integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
"dev": true,
"requires": {
"argparse": "^1.0.7",
@ -1212,20 +1212,12 @@
"requires": {
"graceful-fs": "^4.1.6",
"universalify": "^2.0.0"
},
"dependencies": {
"universalify": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
"integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
"dev": true
}
}
},
"universalify": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-1.0.0.tgz",
"integrity": "sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==",
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
"integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
"dev": true
}
}
@ -1798,7 +1790,7 @@
"requires": {
"underscore": "1.9.1",
"web3-core-helpers": "1.2.1",
"websocket": "github:web3-js/WebSocket-Node#polyfill/globalThis"
"websocket": "websocket@github:web3-js/WebSocket-Node#polyfill/globalThis"
}
},
"web3-shh": {
@ -5583,12 +5575,14 @@
"dependencies": {
"ansi-regex": {
"version": "4.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
"dev": true
},
"ansi-styles": {
"version": "3.2.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"requires": {
"color-convert": "^1.9.0"
@ -5596,7 +5590,8 @@
},
"bindings": {
"version": "1.5.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
"dev": true,
"requires": {
"file-uri-to-path": "1.0.0"
@ -5604,7 +5599,8 @@
},
"bip66": {
"version": "1.1.5",
"bundled": true,
"resolved": false,
"integrity": "sha1-AfqHSHhcpwlV1QESF9GzE5lpyiI=",
"dev": true,
"requires": {
"safe-buffer": "^5.0.1"
@ -5612,17 +5608,20 @@
},
"bn.js": {
"version": "4.11.8",
"bundled": true,
"resolved": false,
"integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
"dev": true
},
"brorand": {
"version": "1.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=",
"dev": true
},
"browserify-aes": {
"version": "1.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==",
"dev": true,
"requires": {
"buffer-xor": "^1.0.3",
@ -5635,22 +5634,26 @@
},
"buffer-from": {
"version": "1.1.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
"dev": true
},
"buffer-xor": {
"version": "1.0.3",
"bundled": true,
"resolved": false,
"integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=",
"dev": true
},
"camelcase": {
"version": "5.3.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
"dev": true
},
"cipher-base": {
"version": "1.0.4",
"bundled": true,
"resolved": false,
"integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
"dev": true,
"requires": {
"inherits": "^2.0.1",
@ -5659,7 +5662,8 @@
},
"cliui": {
"version": "5.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
"dev": true,
"requires": {
"string-width": "^3.1.0",
@ -5669,7 +5673,8 @@
},
"color-convert": {
"version": "1.9.3",
"bundled": true,
"resolved": false,
"integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
"dev": true,
"requires": {
"color-name": "1.1.3"
@ -5677,12 +5682,14 @@
},
"color-name": {
"version": "1.1.3",
"bundled": true,
"resolved": false,
"integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
"dev": true
},
"create-hash": {
"version": "1.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==",
"dev": true,
"requires": {
"cipher-base": "^1.0.1",
@ -5694,7 +5701,8 @@
},
"create-hmac": {
"version": "1.1.7",
"bundled": true,
"resolved": false,
"integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==",
"dev": true,
"requires": {
"cipher-base": "^1.0.3",
@ -5707,7 +5715,8 @@
},
"cross-spawn": {
"version": "6.0.5",
"bundled": true,
"resolved": false,
"integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
"dev": true,
"requires": {
"nice-try": "^1.0.4",
@ -5719,12 +5728,14 @@
},
"decamelize": {
"version": "1.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
"dev": true
},
"drbg.js": {
"version": "1.0.1",
"bundled": true,
"resolved": false,
"integrity": "sha1-Pja2xCs3BDgjzbwzLVjzHiRFSAs=",
"dev": true,
"requires": {
"browserify-aes": "^1.0.6",
@ -5734,7 +5745,8 @@
},
"elliptic": {
"version": "6.5.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-eFOJTMyCYb7xtE/caJ6JJu+bhi67WCYNbkGSknu20pmM8Ke/bqOfdnZWxyoGN26JgfxTbXrsCkEw4KheCT/KGg==",
"dev": true,
"requires": {
"bn.js": "^4.4.0",
@ -5748,12 +5760,14 @@
},
"emoji-regex": {
"version": "7.0.3",
"bundled": true,
"resolved": false,
"integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
"dev": true
},
"end-of-stream": {
"version": "1.4.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==",
"dev": true,
"requires": {
"once": "^1.4.0"
@ -5761,7 +5775,8 @@
},
"ethereumjs-util": {
"version": "6.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-URESKMFbDeJxnAxPppnk2fN6Y3BIatn9fwn76Lm8bQlt+s52TpG8dN9M66MLPuRAiAOIqL3dfwqWJf0sd0fL0Q==",
"dev": true,
"requires": {
"bn.js": "^4.11.0",
@ -5775,7 +5790,8 @@
},
"ethjs-util": {
"version": "0.1.6",
"bundled": true,
"resolved": false,
"integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==",
"dev": true,
"requires": {
"is-hex-prefixed": "1.0.0",
@ -5784,7 +5800,8 @@
},
"evp_bytestokey": {
"version": "1.0.3",
"bundled": true,
"resolved": false,
"integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==",
"dev": true,
"requires": {
"md5.js": "^1.3.4",
@ -5793,7 +5810,8 @@
},
"execa": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==",
"dev": true,
"requires": {
"cross-spawn": "^6.0.0",
@ -5807,12 +5825,14 @@
},
"file-uri-to-path": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
"dev": true
},
"find-up": {
"version": "3.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
"dev": true,
"requires": {
"locate-path": "^3.0.0"
@ -5820,12 +5840,14 @@
},
"get-caller-file": {
"version": "2.0.5",
"bundled": true,
"resolved": false,
"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
"dev": true
},
"get-stream": {
"version": "4.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
"dev": true,
"requires": {
"pump": "^3.0.0"
@ -5833,7 +5855,8 @@
},
"hash-base": {
"version": "3.0.4",
"bundled": true,
"resolved": false,
"integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=",
"dev": true,
"requires": {
"inherits": "^2.0.1",
@ -5842,7 +5865,8 @@
},
"hash.js": {
"version": "1.1.7",
"bundled": true,
"resolved": false,
"integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==",
"dev": true,
"requires": {
"inherits": "^2.0.3",
@ -5851,7 +5875,8 @@
},
"hmac-drbg": {
"version": "1.0.1",
"bundled": true,
"resolved": false,
"integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=",
"dev": true,
"requires": {
"hash.js": "^1.0.3",
@ -5861,37 +5886,44 @@
},
"inherits": {
"version": "2.0.4",
"bundled": true,
"resolved": false,
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
"dev": true
},
"invert-kv": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-wPVv/y/QQ/Uiirj/vh3oP+1Ww+AWehmi1g5fFWGPF6IpCBCDVrhgHRMvrLfdYcwDh3QJbGXDW4JAuzxElLSqKA==",
"dev": true
},
"is-fullwidth-code-point": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
"dev": true
},
"is-hex-prefixed": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-fY035q135dEnFIkTxXPggtd39VQ=",
"dev": true
},
"is-stream": {
"version": "1.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
"dev": true
},
"isexe": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
"dev": true
},
"keccak": {
"version": "1.4.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-eZVaCpblK5formjPjeTBik7TAg+pqnDrMHIffSvi9Lh7PQgM1+hSzakUeZFCk9DVVG0dacZJuaz2ntwlzZUIBw==",
"dev": true,
"requires": {
"bindings": "^1.2.1",
@ -5902,7 +5934,8 @@
},
"lcid": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-avPEb8P8EGnwXKClwsNUgryVjllcRqtMYa49NTsbQagYuT1DcXnl1915oxWjoyGrXR6zH/Y0Zc96xWsPcoDKeA==",
"dev": true,
"requires": {
"invert-kv": "^2.0.0"
@ -5910,7 +5943,8 @@
},
"locate-path": {
"version": "3.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
"dev": true,
"requires": {
"p-locate": "^3.0.0",
@ -5919,7 +5953,8 @@
},
"map-age-cleaner": {
"version": "0.1.3",
"bundled": true,
"resolved": false,
"integrity": "sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==",
"dev": true,
"requires": {
"p-defer": "^1.0.0"
@ -5927,7 +5962,8 @@
},
"md5.js": {
"version": "1.3.5",
"bundled": true,
"resolved": false,
"integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==",
"dev": true,
"requires": {
"hash-base": "^3.0.0",
@ -5937,7 +5973,8 @@
},
"mem": {
"version": "4.3.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w==",
"dev": true,
"requires": {
"map-age-cleaner": "^0.1.1",
@ -5947,32 +5984,38 @@
},
"mimic-fn": {
"version": "2.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
"dev": true
},
"minimalistic-assert": {
"version": "1.0.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
"dev": true
},
"minimalistic-crypto-utils": {
"version": "1.0.1",
"bundled": true,
"resolved": false,
"integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=",
"dev": true
},
"nan": {
"version": "2.14.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==",
"dev": true
},
"nice-try": {
"version": "1.0.5",
"bundled": true,
"resolved": false,
"integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
"dev": true
},
"npm-run-path": {
"version": "2.0.2",
"bundled": true,
"resolved": false,
"integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=",
"dev": true,
"requires": {
"path-key": "^2.0.0"
@ -5980,7 +6023,8 @@
},
"once": {
"version": "1.4.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
"dev": true,
"requires": {
"wrappy": "1"
@ -5988,7 +6032,8 @@
},
"os-locale": {
"version": "3.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q==",
"dev": true,
"requires": {
"execa": "^1.0.0",
@ -5998,22 +6043,26 @@
},
"p-defer": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-n26xgvbJqozXQwBKfU+WsZaw+ww=",
"dev": true
},
"p-finally": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=",
"dev": true
},
"p-is-promise": {
"version": "2.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg==",
"dev": true
},
"p-limit": {
"version": "2.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-pZbTJpoUsCzV48Mc9Nh51VbwO0X9cuPFE8gYwx9BTCt9SF8/b7Zljd2fVgOxhIF/HDTKgpVzs+GPhyKfjLLFRQ==",
"dev": true,
"requires": {
"p-try": "^2.0.0"
@ -6021,7 +6070,8 @@
},
"p-locate": {
"version": "3.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
"dev": true,
"requires": {
"p-limit": "^2.0.0"
@ -6029,22 +6079,26 @@
},
"p-try": {
"version": "2.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
"dev": true
},
"path-exists": {
"version": "3.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
"dev": true
},
"path-key": {
"version": "2.0.1",
"bundled": true,
"resolved": false,
"integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
"dev": true
},
"pump": {
"version": "3.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
"dev": true,
"requires": {
"end-of-stream": "^1.1.0",
@ -6053,17 +6107,20 @@
},
"require-directory": {
"version": "2.1.1",
"bundled": true,
"resolved": false,
"integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
"dev": true
},
"require-main-filename": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
"dev": true
},
"ripemd160": {
"version": "2.0.2",
"bundled": true,
"resolved": false,
"integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==",
"dev": true,
"requires": {
"hash-base": "^3.0.0",
@ -6072,7 +6129,8 @@
},
"rlp": {
"version": "2.2.3",
"bundled": true,
"resolved": false,
"integrity": "sha512-l6YVrI7+d2vpW6D6rS05x2Xrmq8oW7v3pieZOJKBEdjuTF4Kz/iwk55Zyh1Zaz+KOB2kC8+2jZlp2u9L4tTzCQ==",
"dev": true,
"requires": {
"bn.js": "^4.11.1",
@ -6081,12 +6139,14 @@
},
"safe-buffer": {
"version": "5.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==",
"dev": true
},
"secp256k1": {
"version": "3.7.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-1cf8sbnRreXrQFdH6qsg2H71Xw91fCCS9Yp021GnUNJzWJS/py96fS4lHbnTnouLp08Xj6jBoBB6V78Tdbdu5g==",
"dev": true,
"requires": {
"bindings": "^1.5.0",
@ -6101,17 +6161,20 @@
},
"semver": {
"version": "5.7.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==",
"dev": true
},
"set-blocking": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
"dev": true
},
"sha.js": {
"version": "2.4.11",
"bundled": true,
"resolved": false,
"integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
"dev": true,
"requires": {
"inherits": "^2.0.1",
@ -6120,7 +6183,8 @@
},
"shebang-command": {
"version": "1.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=",
"dev": true,
"requires": {
"shebang-regex": "^1.0.0"
@ -6128,22 +6192,26 @@
},
"shebang-regex": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
"dev": true
},
"signal-exit": {
"version": "3.0.2",
"bundled": true,
"resolved": false,
"integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
"dev": true
},
"source-map": {
"version": "0.6.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
"dev": true
},
"source-map-support": {
"version": "0.5.12",
"bundled": true,
"resolved": false,
"integrity": "sha512-4h2Pbvyy15EE02G+JOZpUCmqWJuqrs+sEkzewTm++BPi7Hvn/HwcqLAcNxYAyI0x13CpPPn+kMjl+hplXMHITQ==",
"dev": true,
"requires": {
"buffer-from": "^1.0.0",
@ -6152,7 +6220,8 @@
},
"string-width": {
"version": "3.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
"dev": true,
"requires": {
"emoji-regex": "^7.0.1",
@ -6162,7 +6231,8 @@
},
"strip-ansi": {
"version": "5.2.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
"dev": true,
"requires": {
"ansi-regex": "^4.1.0"
@ -6170,12 +6240,14 @@
},
"strip-eof": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=",
"dev": true
},
"strip-hex-prefix": {
"version": "1.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-DF8VX+8RUTczd96du1iNoFUA428=",
"dev": true,
"requires": {
"is-hex-prefixed": "1.0.0"
@ -6183,7 +6255,8 @@
},
"which": {
"version": "1.3.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
"dev": true,
"requires": {
"isexe": "^2.0.0"
@ -6191,12 +6264,14 @@
},
"which-module": {
"version": "2.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
"dev": true
},
"wrap-ansi": {
"version": "5.1.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
"dev": true,
"requires": {
"ansi-styles": "^3.2.0",
@ -6206,17 +6281,20 @@
},
"wrappy": {
"version": "1.0.2",
"bundled": true,
"resolved": false,
"integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
"dev": true
},
"y18n": {
"version": "4.0.0",
"bundled": true,
"resolved": false,
"integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
"dev": true
},
"yargs": {
"version": "13.2.4",
"bundled": true,
"resolved": false,
"integrity": "sha512-HG/DWAJa1PAnHT9JAhNa8AbAv3FPaiLzioSjCcmuXXhP8MlpHO5vwls4g4j6n30Z74GVQj8Xa62dWVx1QCGklg==",
"dev": true,
"requires": {
"cliui": "^5.0.0",
@ -6234,7 +6312,8 @@
},
"yargs-parser": {
"version": "13.1.1",
"bundled": true,
"resolved": false,
"integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==",
"dev": true,
"requires": {
"camelcase": "^5.0.0",
@ -14516,13 +14595,13 @@
"integrity": "sha1-jZWCAsftuq6Dlwf7pvCf8ydgYhA=",
"dev": true,
"requires": {
"ethereumjs-abi": "git+https://github.com/ethereumjs/ethereumjs-abi.git",
"ethereumjs-abi": "ethereumjs-abi@git+https://github.com/ethereumjs/ethereumjs-abi.git",
"ethereumjs-util": "^5.1.1"
}
},
"ethereumjs-abi": {
"version": "git+https://git@github.com/ethereumjs/ethereumjs-abi.git#1ce6a1d64235fabe2aaf827fd606def55693508f",
"from": "git+https://github.com/ethereumjs/ethereumjs-abi.git",
"from": "ethereumjs-abi@git+https://github.com/ethereumjs/ethereumjs-abi.git",
"dev": true,
"requires": {
"bn.js": "^4.11.8",
@ -18812,8 +18891,8 @@
"dev": true
},
"scrypt-shim": {
"version": "github:web3-js/scrypt-shim#aafdadda13e660e25e1c525d1f5b2443f5eb1ebb",
"from": "github:web3-js/scrypt-shim",
"version": "git+ssh://git@github.com/web3-js/scrypt-shim.git#aafdadda13e660e25e1c525d1f5b2443f5eb1ebb",
"from": "scrypt-shim@github:web3-js/scrypt-shim",
"dev": true,
"requires": {
"scryptsy": "^2.1.0",
@ -21516,7 +21595,7 @@
"eth-lib": "0.2.7",
"ethereumjs-common": "^1.3.2",
"ethereumjs-tx": "^2.1.1",
"scrypt-shim": "github:web3-js/scrypt-shim",
"scrypt-shim": "scrypt-shim@github:web3-js/scrypt-shim",
"underscore": "1.9.1",
"uuid": "3.3.2",
"web3-core": "1.2.2",
@ -21846,7 +21925,7 @@
"requires": {
"underscore": "1.9.1",
"web3-core-helpers": "1.2.2",
"websocket": "github:web3-js/WebSocket-Node#polyfill/globalThis"
"websocket": "websocket@github:web3-js/WebSocket-Node#polyfill/globalThis"
}
},
"web3-shh": {
@ -21878,8 +21957,8 @@
}
},
"websocket": {
"version": "github:web3-js/WebSocket-Node#ef5ea2f41daf4a2113b80c9223df884b4d56c400",
"from": "github:web3-js/WebSocket-Node#polyfill/globalThis",
"version": "git+ssh://git@github.com/web3-js/WebSocket-Node.git#ef5ea2f41daf4a2113b80c9223df884b4d56c400",
"from": "websocket@github:web3-js/WebSocket-Node#polyfill/globalThis",
"dev": true,
"requires": {
"debug": "^2.2.0",

55
package.json
View File

@ -14,37 +14,48 @@
"hardhat:ropsten": "hardhat--network ropsten",
"hardhat:main": "hardhat --network main",
"hardhat:docker": "hardhat --network hardhatevm_docker",
"hardhat:mumbai": "hardhat --network mumbai",
"hardhat:matic": "hardhat --network matic",
"compile": "SKIP_LOAD=true hardhat compile",
"console:fork": "MAINNET_FORK=true hardhat console",
"test": "TS_NODE_TRANSPILE_ONLY=1 hardhat test ./test/*.spec.ts",
"test-scenarios": "npx hardhat test test/__setup.spec.ts test/scenario.spec.ts",
"test-repay-with-collateral": "hardhat test test/__setup.spec.ts test/repay-with-collateral.spec.ts",
"test-liquidate-with-collateral": "hardhat test test/__setup.spec.ts test/flash-liquidation-with-collateral.spec.ts",
"test-liquidate-underlying": "hardhat test test/__setup.spec.ts test/liquidation-underlying.spec.ts",
"test-configurator": "hardhat test test/__setup.spec.ts test/configurator.spec.ts",
"test-transfers": "hardhat test test/__setup.spec.ts test/atoken-transfer.spec.ts",
"test-flash": "hardhat test test/__setup.spec.ts test/flashloan.spec.ts",
"test-liquidate": "hardhat test test/__setup.spec.ts test/liquidation-atoken.spec.ts",
"test-deploy": "hardhat test test/__setup.spec.ts test/test-init.spec.ts",
"test-pausable": "hardhat test test/__setup.spec.ts test/pausable-functions.spec.ts",
"test-permit": "hardhat test test/__setup.spec.ts test/atoken-permit.spec.ts",
"test-stable-and-atokens": "hardhat test test/__setup.spec.ts test/atoken-transfer.spec.ts test/stable-token.spec.ts",
"test-subgraph:scenarios": "hardhat --network hardhatevm_docker test test/__setup.spec.ts test/subgraph-scenarios.spec.ts",
"test-weth": "hardhat test test/__setup.spec.ts test/weth-gateway.spec.ts",
"test-uniswap": "hardhat test test/__setup.spec.ts test/uniswapAdapters*.spec.ts",
"test:main:check-list": "MAINNET_FORK=true TS_NODE_TRANSPILE_ONLY=1 hardhat test test/__setup.spec.ts test/mainnet/check-list.spec.ts",
"test": "TS_NODE_TRANSPILE_ONLY=1 hardhat test ./test-suites/test-aave/*.spec.ts",
"test-amm": "TS_NODE_TRANSPILE_ONLY=1 hardhat test ./test-suites/test-amm/*.spec.ts",
"test-amm-scenarios": "TS_NODE_TRANSPILE_ONLY=1 hardhat test ./test-suites/test-amm/__setup.spec.ts test-suites/test-amm/scenario.spec.ts",
"test-scenarios": "npx hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/scenario.spec.ts",
"test-repay-with-collateral": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/repay-with-collateral.spec.ts",
"test-liquidate-with-collateral": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/flash-liquidation-with-collateral.spec.ts",
"test-liquidate-underlying": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/liquidation-underlying.spec.ts",
"test-configurator": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/configurator.spec.ts",
"test-transfers": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/atoken-transfer.spec.ts",
"test-flash": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/flashloan.spec.ts",
"test-liquidate": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/liquidation-atoken.spec.ts",
"test-deploy": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/test-init.spec.ts",
"test-pausable": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/pausable-functions.spec.ts",
"test-permit": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/atoken-permit.spec.ts",
"test-stable-and-atokens": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/atoken-transfer.spec.ts test-suites/test-aave/stable-token.spec.ts",
"test-subgraph:scenarios": "hardhat --network hardhatevm_docker test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/subgraph-scenarios.spec.ts",
"test-weth:main": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/weth-gateway.spec.ts",
"test-weth:amm": "hardhat test test-suites/test-amm/__setup.spec.ts test-suites/test-amm/weth-gateway.spec.ts",
"test-uniswap": "hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/uniswapAdapters*.spec.ts",
"test:main:check-list": "MAINNET_FORK=true TS_NODE_TRANSPILE_ONLY=1 hardhat test test-suites/test-aave/__setup.spec.ts test-suites/test-aave/mainnet/check-list.spec.ts",
"dev:coverage": "buidler compile --force && buidler coverage --network coverage",
"aave:evm:dev:migration": "npm run compile && hardhat aave:dev",
"aave:docker:full:migration": "npm run compile && npm run hardhat:docker -- aave:mainnet",
"aave:kovan:full:migration": "npm run compile && npm run hardhat:kovan -- aave:mainnet --verify",
"matic:mumbai:full:migration": "npm run compile && npm run hardhat:mumbai matic:mainnet",
"matic:matic:full:migration": "npm run compile && npm run hardhat:matic matic:mainnet",
"amm:kovan:full:migration": "npm run compile && npm run hardhat:kovan -- amm:mainnet --verify",
"aave:kovan:full:initialize": "npm run hardhat:kovan -- full:initialize-lending-pool --verify --pool Aave",
"aave:ropsten:full:migration": "npm run compile && npm run hardhat:ropsten -- aave:mainnet --verify",
"aave:fork:main:tenderly": "npm run compile && npm run hardhat:tenderly-main -- aave:mainnet",
"aave:fork:main": "npm run compile && MAINNET_FORK=true hardhat aave:mainnet",
"aave:fork:main": "npm run compile && MAINNET_FORK=true hardhat aave:mainnet",
"amm:fork:main": "npm run compile && MAINNET_FORK=true hardhat amm:mainnet",
"amm:fork:main:tenderly": "npm run compile && npm run hardhat:tenderly-main -- amm:mainnet",
"aave:main:full:migration": "npm run compile && npm run hardhat:main -- aave:mainnet --verify",
"aave:main:full:initialize": "npm run compile && MAINNET_FORK=true full:initialize-tokens --pool Aave",
"prettier:check": "npx prettier -c 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test/**/*.ts'",
"prettier:write": "prettier --write 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test/**/*.ts'",
"amm:main:full:migration": "npm run compile && npm run hardhat:main -- amm:mainnet --verify",
"prettier:check": "npx prettier -c 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test-suites/test-aave/**/*.ts'",
"prettier:write": "prettier --write 'tasks/**/*.ts' 'contracts/**/*.sol' 'helpers/**/*.ts' 'test-suites/test-aave/**/*.ts'",
"ci:test": "npm run compile && npm run test",
"ci:clean": "rm -rf ./artifacts ./cache ./types",
"print-contracts:kovan": "npm run hardhat:kovan -- print-contracts",
@ -78,7 +89,7 @@
"@nomiclabs/hardhat-ethers": "^2.0.0",
"@nomiclabs/hardhat-waffle": "^2.0.0",
"@openzeppelin/contracts": "3.1.0",
"@tenderly/hardhat-tenderly": "^1.1.0-beta.3",
"@tenderly/hardhat-tenderly": "^1.1.0-beta.4",
"@typechain/ethers-v4": "1.0.0",
"@typechain/ethers-v5": "^2.0.0",
"@typechain/truffle-v4": "2.0.2",
@ -119,7 +130,7 @@
},
"husky": {
"hooks": {
"pre-commit": "pretty-quick --staged --pattern 'contracts/**/*.sol' --pattern 'helpers/**/*.ts' --pattern 'test/**/*.ts' --pattern 'tasks/**/*.ts'"
"pre-commit": "pretty-quick --staged --pattern 'contracts/**/*.sol' --pattern 'helpers/**/*.ts' --pattern 'test-suites/test-aave/**/*.ts' --pattern 'tasks/**/*.ts'"
}
},
"author": "Aave",

1
tasks/dev/4_oracles.ts
View File

@ -4,7 +4,6 @@ import {
deployAaveOracle,
deployLendingRateOracle,
} from '../../helpers/contracts-deployments';
import {
setInitialAssetPricesInOracle,
deployAllMockAggregators,

20
tasks/dev/5_initialize.ts
View File

@ -5,7 +5,10 @@ import {
deployWalletBalancerProvider,
deployAaveProtocolDataProvider,
deployWETHGateway,
authorizeWETHGateway,
} from '../../helpers/contracts-deployments';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { eNetwork } from '../../helpers/types';
import {
ConfigNames,
getReservesConfigByPool,
@ -30,8 +33,15 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ verify, pool }, localBRE) => {
await localBRE.run('set-DRE');
const network = <eNetwork>localBRE.network.name;
const poolConfig = loadPoolConfig(pool);
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
WethGateway,
} = poolConfig;
const mockTokens = await getAllMockedTokens();
const allTokenAddresses = getAllTokenAddresses(mockTokens);
@ -52,6 +62,10 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
await initReservesByHelper(
reservesParams,
protoPoolReservesAddresses,
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
admin,
treasuryAddress,
ZERO_ADDRESS,
@ -78,6 +92,6 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
await insertContractAddressInDb(eContractid.AaveProtocolDataProvider, testHelpers.address);
const lendingPoolAddress = await addressesProvider.getLendingPool();
const wethAddress = await getWethAddress(poolConfig);
await deployWETHGateway([wethAddress, lendingPoolAddress]);
const gateWay = await getParamPerNetwork(WethGateway, network);
await authorizeWETHGateway(gateWay, lendingPoolAddress);
});

16
tasks/full/1_address_provider.ts
View File

@ -11,15 +11,16 @@ import {
getGenesisPoolAdmin,
getEmergencyAdmin,
} from '../../helpers/configuration';
import { eEthereumNetwork } from '../../helpers/types';
import { eNetwork } from '../../helpers/types';
import {
getFirstSigner,
getLendingPoolAddressesProviderRegistry,
} from '../../helpers/contracts-getters';
import { formatEther, isAddress, parseEther } from 'ethers/lib/utils';
import { isZeroAddress } from 'ethereumjs-util';
import { Signer } from 'ethers';
import { Signer, BigNumber } from 'ethers';
import { parse } from 'path';
//import BigNumber from 'bignumber.js';
task(
'full:deploy-address-provider',
@ -30,7 +31,7 @@ task(
.setAction(async ({ verify, pool }, DRE) => {
await DRE.run('set-DRE');
let signer: Signer;
const network = <eEthereumNetwork>DRE.network.name;
const network = <eNetwork>DRE.network.name;
const poolConfig = loadPoolConfig(pool);
const { ProviderId, MarketId } = poolConfig;
@ -63,13 +64,7 @@ task(
const firstAccount = await getFirstSigner();
await firstAccount.sendTransaction({ value: parseEther('10'), to: providerRegistryOwner });
} else {
signer = await getFirstSigner();
const deployerAddress = await signer.getAddress();
if (providerRegistryOwner !== (await signer.getAddress())) {
throw Error(
`Current signer is not provider registry owner. \nCurrent deployer address: ${deployerAddress} \nExpected address: ${poolConfig.ProviderRegistryOwner}`
);
}
signer = DRE.ethers.provider.getSigner(providerRegistryOwner);
}
// 1. Address Provider Registry instance
const addressesProviderRegistry = (
@ -81,6 +76,7 @@ task(
// 2. Deploy address provider and set genesis manager
const addressesProvider = await deployLendingPoolAddressesProvider(MarketId, verify);
// DISABLE SEC. 3 FOR GOVERNANCE USE!
// 3. Set the provider at the Registry
await waitForTx(
await addressesProviderRegistry.registerAddressesProvider(

44
tasks/full/2_lending_pool.ts
View File

@ -1,45 +1,63 @@
import { task } from 'hardhat/config';
import { insertContractAddressInDb } from '../../helpers/contracts-helpers';
import { getParamPerNetwork, insertContractAddressInDb } from '../../helpers/contracts-helpers';
import {
deployATokensAndRatesHelper,
deployLendingPool,
deployLendingPoolConfigurator,
deployStableAndVariableTokensHelper,
} from '../../helpers/contracts-deployments';
import { eContractid } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import { eContractid, eNetwork } from '../../helpers/types';
import { notFalsyOrZeroAddress, waitForTx } from '../../helpers/misc-utils';
import {
getLendingPoolAddressesProvider,
getLendingPool,
getLendingPoolConfiguratorProxy,
} from '../../helpers/contracts-getters';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { loadPoolConfig, ConfigNames } from '../../helpers/configuration';
task('full:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({ verify }, DRE: HardhatRuntimeEnvironment) => {
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ verify, pool }, DRE: HardhatRuntimeEnvironment) => {
try {
await DRE.run('set-DRE');
const network = <eNetwork>DRE.network.name;
const poolConfig = loadPoolConfig(pool);
const addressesProvider = await getLendingPoolAddressesProvider();
// Deploy lending pool
const lendingPoolImpl = await deployLendingPool(verify);
const { LendingPool, LendingPoolConfigurator } = poolConfig;
// Set lending pool impl to address provider
await waitForTx(await addressesProvider.setLendingPoolImpl(lendingPoolImpl.address));
// Reuse/deploy lending pool implementation
let lendingPoolImplAddress = getParamPerNetwork(LendingPool, network);
if (!notFalsyOrZeroAddress(lendingPoolImplAddress)) {
console.log('\tDeploying new lending pool implementation & libraries...');
const lendingPoolImpl = await deployLendingPool(verify);
lendingPoolImplAddress = lendingPoolImpl.address;
}
console.log('\tSetting lending pool implementation with address:', lendingPoolImplAddress);
// Set lending pool impl to Address provider
await waitForTx(await addressesProvider.setLendingPoolImpl(lendingPoolImplAddress));
const address = await addressesProvider.getLendingPool();
const lendingPoolProxy = await getLendingPool(address);
await insertContractAddressInDb(eContractid.LendingPool, lendingPoolProxy.address);
// Deploy lending pool configurator
const lendingPoolConfiguratorImpl = await deployLendingPoolConfigurator(verify);
// Reuse/deploy lending pool configurator
let lendingPoolConfiguratorImplAddress = getParamPerNetwork(LendingPoolConfigurator, network); //await deployLendingPoolConfigurator(verify);
if (!notFalsyOrZeroAddress(lendingPoolConfiguratorImplAddress)) {
console.log('\tDeploying new configurator implementation...');
const lendingPoolConfiguratorImpl = await deployLendingPoolConfigurator(verify);
lendingPoolConfiguratorImplAddress = lendingPoolConfiguratorImpl.address;
}
console.log(
'\tSetting lending pool configurator implementation with address:',
lendingPoolConfiguratorImplAddress
);
// Set lending pool conf impl to Address Provider
await waitForTx(
await addressesProvider.setLendingPoolConfiguratorImpl(lendingPoolConfiguratorImpl.address)
await addressesProvider.setLendingPoolConfiguratorImpl(lendingPoolConfiguratorImplAddress)
);
const lendingPoolConfiguratorProxy = await getLendingPoolConfiguratorProxy(

50
tasks/full/3_oracles.ts
View File

@ -2,7 +2,7 @@ import { task } from 'hardhat/config';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { deployAaveOracle, deployLendingRateOracle } from '../../helpers/contracts-deployments';
import { setInitialMarketRatesInRatesOracleByHelper } from '../../helpers/oracles-helpers';
import { ICommonConfiguration, eEthereumNetwork, SymbolMap } from '../../helpers/types';
import { ICommonConfiguration, eNetwork, SymbolMap } from '../../helpers/types';
import { waitForTx, notFalsyOrZeroAddress } from '../../helpers/misc-utils';
import {
ConfigNames,
@ -17,6 +17,7 @@ import {
getLendingRateOracle,
getPairsTokenAggregator,
} from '../../helpers/contracts-getters';
import { AaveOracle } from '../../types';
task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
@ -24,7 +25,7 @@ task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
.setAction(async ({ verify, pool }, DRE) => {
try {
await DRE.run('set-DRE');
const network = <eEthereumNetwork>DRE.network.name;
const network = <eNetwork>DRE.network.name;
const poolConfig = loadPoolConfig(pool);
const {
ProtocolGlobalParams: { UsdAddress },
@ -47,26 +48,39 @@ task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
};
const [tokens, aggregators] = getPairsTokenAggregator(tokensToWatch, chainlinkAggregators);
const aaveOracle = notFalsyOrZeroAddress(aaveOracleAddress)
? await getAaveOracle(aaveOracleAddress)
: await deployAaveOracle(
[tokens, aggregators, fallbackOracleAddress, await getWethAddress(poolConfig)],
verify
);
const lendingRateOracle = notFalsyOrZeroAddress(lendingRateOracleAddress)
let aaveOracle: AaveOracle;
if (notFalsyOrZeroAddress(aaveOracleAddress)) {
aaveOracle = await await getAaveOracle(aaveOracleAddress);
const owner = await aaveOracle.owner();
const signer = DRE.ethers.provider.getSigner(owner);
aaveOracle = await (await getAaveOracle(aaveOracleAddress)).connect(signer);
await waitForTx(await aaveOracle.setAssetSources(tokens, aggregators));
} else {
aaveOracle = await deployAaveOracle(
[tokens, aggregators, fallbackOracleAddress, await getWethAddress(poolConfig)],
verify
);
}
let lendingRateOracle = notFalsyOrZeroAddress(lendingRateOracleAddress)
? await getLendingRateOracle(lendingRateOracleAddress)
: await deployLendingRateOracle(verify);
const { USD, ...tokensAddressesWithoutUsd } = tokensToWatch;
if (!lendingRateOracleAddress) {
await setInitialMarketRatesInRatesOracleByHelper(
lendingRateOracles,
tokensAddressesWithoutUsd,
lendingRateOracle,
admin
);
}
lendingRateOracle = lendingRateOracle.connect(
DRE.ethers.provider.getSigner(await lendingRateOracle.owner())
);
// This must be done any time a new market is created I believe
//if (!lendingRateOracleAddress) {
await setInitialMarketRatesInRatesOracleByHelper(
lendingRateOracles,
tokensAddressesWithoutUsd,
lendingRateOracle,
admin
);
//}
console.log('ORACLES: %s and %s', aaveOracle.address, lendingRateOracle.address);
// Register the proxy price provider on the addressesProvider
await waitForTx(await addressesProvider.setPriceOracle(aaveOracle.address));
await waitForTx(await addressesProvider.setLendingRateOracle(lendingRateOracle.address));

32
tasks/full/5-deploy-wethGateWay.ts Normal file
View File

@ -0,0 +1,32 @@
import { task } from 'hardhat/config';
import { AaveConfig } from '../../markets/aave/index';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { loadPoolConfig, ConfigNames, getWethAddress } from '../../helpers/configuration';
import { deployWETHGateway } from '../../helpers/contracts-deployments';
import { DRE } from '../../helpers/misc-utils';
import { eNetwork } from '../../helpers/types';
const CONTRACT_NAME = 'WETHGateway';
task(`full-deploy-weth-gateway`, `Deploys the ${CONTRACT_NAME} contract`)
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.addFlag('verify', `Verify ${CONTRACT_NAME} contract via Etherscan API.`)
.setAction(async ({ verify, pool }, localBRE) => {
await localBRE.run('set-DRE');
const network = <eNetwork>localBRE.network.name;
const poolConfig = loadPoolConfig(pool);
const Weth = await getWethAddress(poolConfig);
const { WethGateway } = poolConfig;
if (!localBRE.network.config.chainId) {
throw new Error('INVALID_CHAIN_ID');
}
let gateWay = getParamPerNetwork(WethGateway, network);
if (gateWay === '') {
const wethGateWay = await deployWETHGateway([Weth], verify);
console.log(`${CONTRACT_NAME}.address`, wethGateWay.address);
console.log(`\tFinished ${CONTRACT_NAME} deployment`);
} else {
console.log(`Weth gateway already deployed. Address: ${gateWay}`);
}
});

48
tasks/full/5_initialize.ts → tasks/full/6-initialize.ts
View File

@ -3,8 +3,8 @@ import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import {
deployLendingPoolCollateralManager,
deployWalletBalancerProvider,
deployAaveProtocolDataProvider,
deployWETHGateway,
authorizeWETHGateway,
} from '../../helpers/contracts-deployments';
import {
loadPoolConfig,
@ -12,8 +12,9 @@ import {
getWethAddress,
getTreasuryAddress,
} from '../../helpers/configuration';
import { eEthereumNetwork, ICommonConfiguration } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import { getWETHGateway } from '../../helpers/contracts-getters';
import { eNetwork, ICommonConfiguration } from '../../helpers/types';
import { notFalsyOrZeroAddress, waitForTx } from '../../helpers/misc-utils';
import { initReservesByHelper, configureReservesByHelper } from '../../helpers/init-helpers';
import { exit } from 'process';
import {
@ -28,9 +29,18 @@ task('full:initialize-lending-pool', 'Initialize lending pool configuration.')
.setAction(async ({ verify, pool }, localBRE) => {
try {
await localBRE.run('set-DRE');
const network = <eEthereumNetwork>localBRE.network.name;
const network = <eNetwork>localBRE.network.name;
const poolConfig = loadPoolConfig(pool);
const { ReserveAssets, ReservesConfig } = poolConfig as ICommonConfiguration;
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
ReserveAssets,
ReservesConfig,
LendingPoolCollateralManager,
WethGateway,
} = poolConfig as ICommonConfiguration;
const reserveAssets = await getParamPerNetwork(ReserveAssets, network);
@ -48,6 +58,10 @@ task('full:initialize-lending-pool', 'Initialize lending pool configuration.')
await initReservesByHelper(
ReservesConfig,
reserveAssets,
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
admin,
treasuryAddress,
ZERO_ADDRESS,
@ -55,17 +69,33 @@ task('full:initialize-lending-pool', 'Initialize lending pool configuration.')
);
await configureReservesByHelper(ReservesConfig, reserveAssets, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager(verify);
let collateralManagerAddress = await getParamPerNetwork(
LendingPoolCollateralManager,
network
);
if (!notFalsyOrZeroAddress(collateralManagerAddress)) {
const collateralManager = await deployLendingPoolCollateralManager(verify);
collateralManagerAddress = collateralManager.address;
}
// Seems unnecessary to register the collateral manager in the JSON db
console.log(
'\tSetting lending pool collateral manager implementation with address',
collateralManagerAddress
);
await waitForTx(
await addressesProvider.setLendingPoolCollateralManager(collateralManager.address)
await addressesProvider.setLendingPoolCollateralManager(collateralManagerAddress)
);
await deployWalletBalancerProvider(verify);
const wethAddress = await getWethAddress(poolConfig);
const lendingPoolAddress = await addressesProvider.getLendingPool();
await deployWETHGateway([wethAddress, lendingPoolAddress]);
let gateWay = getParamPerNetwork(WethGateway, network);
if (!notFalsyOrZeroAddress(gateWay)) {
gateWay = (await getWETHGateway()).address;
}
await authorizeWETHGateway(gateWay, lendingPoolAddress);
} catch (err) {
console.error(err);
exit(1);

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

@ -1,5 +1,5 @@
import { task } from 'hardhat/config';
import { EthereumNetwork } from '../../helpers/types';
import { eEthereumNetwork } from '../../helpers/types';
import { getTreasuryAddress } from '../../helpers/configuration';
import * as marketConfigs from '../../markets/aave';
import * as reserveConfigs from '../../markets/aave/reservesConfigs';
@ -18,7 +18,7 @@ const LENDING_POOL_ADDRESS_PROVIDER = {
kovan: '0x652B2937Efd0B5beA1c8d54293FC1289672AFC6b',
};
const isSymbolValid = (symbol: string, network: EthereumNetwork) =>
const isSymbolValid = (symbol: string, network: eEthereumNetwork) =>
Object.keys(reserveConfigs).includes('strategy' + symbol) &&
marketConfigs.AaveConfig.ReserveAssets[network][symbol] &&
marketConfigs.AaveConfig.ReservesConfig[symbol] === reserveConfigs['strategy' + symbol];
@ -28,7 +28,7 @@ task('external:deploy-new-asset', 'Deploy A token, Debt Tokens, Risk Parameters'
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({ verify, symbol }, localBRE) => {
const network = localBRE.network.name;
if (!isSymbolValid(symbol, network as EthereumNetwork)) {
if (!isSymbolValid(symbol, network as eEthereumNetwork)) {
throw new Error(
`
WRONG RESERVE ASSET SETUP:
@ -53,9 +53,9 @@ WRONG RESERVE ASSET SETUP:
poolAddress,
reserveAssetAddress,
treasuryAddress,
ZERO_ADDRESS, // Incentives Controller
`Aave interest bearing ${symbol}`,
`a${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -63,9 +63,9 @@ WRONG RESERVE ASSET SETUP:
[
poolAddress,
reserveAssetAddress,
ZERO_ADDRESS, // Incentives Controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);
@ -73,9 +73,9 @@ WRONG RESERVE ASSET SETUP:
[
poolAddress,
reserveAssetAddress,
ZERO_ADDRESS, // Incentives Controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
ZERO_ADDRESS,
],
verify
);

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

@ -21,7 +21,7 @@ task('aave:mainnet', 'Deploy development enviroment')
await DRE.run('full:deploy-address-provider', { pool: POOL_NAME });
console.log('2. Deploy lending pool');
await DRE.run('full:deploy-lending-pool');
await DRE.run('full:deploy-lending-pool', { pool: POOL_NAME });
console.log('3. Deploy oracles');
await DRE.run('full:deploy-oracles', { pool: POOL_NAME });
@ -29,21 +29,27 @@ task('aave:mainnet', 'Deploy development enviroment')
console.log('4. Deploy Data Provider');
await DRE.run('full:data-provider', { pool: POOL_NAME });
console.log('5. Initialize lending pool');
console.log('5. Deploy WETH Gateway');
await DRE.run('full-deploy-weth-gateway', { pool: POOL_NAME });
console.log('6. Initialize lending pool');
await DRE.run('full:initialize-lending-pool', { pool: POOL_NAME });
if (verify) {
printContracts();
console.log('4. Veryfing contracts');
console.log('7. Veryfing contracts');
await DRE.run('verify:general', { all: true, pool: POOL_NAME });
console.log('5. Veryfing aTokens and debtTokens');
console.log('8. Veryfing aTokens and debtTokens');
await DRE.run('verify:tokens', { pool: POOL_NAME });
}
if (usingTenderly()) {
const postDeployHead = DRE.tenderlyRPC.getHead();
console.log('Tenderly UUID', postDeployHead);
const postDeployFork = DRE.tenderlyRPC.getFork();
console.log('Tenderly Info');
console.log('- Head', postDeployHead);
console.log('- Fork', postDeployFork);
}
console.log('\nFinished migrations');
printContracts();

56
tasks/migrations/amm.mainnet.ts Normal file
View File

@ -0,0 +1,56 @@
import { task } from 'hardhat/config';
import { checkVerification } from '../../helpers/etherscan-verification';
import { ConfigNames } from '../../helpers/configuration';
import { printContracts } from '../../helpers/misc-utils';
import { usingTenderly } from '../../helpers/tenderly-utils';
task('amm:mainnet', 'Deploy development enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({ verify }, DRE) => {
const POOL_NAME = ConfigNames.Amm;
await DRE.run('set-DRE');
// Prevent loss of gas verifying all the needed ENVs for Etherscan verification
if (verify) {
checkVerification();
}
console.log('Migration started\n');
console.log('1. Deploy address provider');
await DRE.run('full:deploy-address-provider', { pool: POOL_NAME });
console.log('2. Deploy lending pool');
await DRE.run('full:deploy-lending-pool', { pool: POOL_NAME });
console.log('3. Deploy oracles');
await DRE.run('full:deploy-oracles', { pool: POOL_NAME });
console.log('4. Deploy Data Provider');
await DRE.run('full:data-provider', { pool: POOL_NAME });
console.log('5. Deploy WETH Gateway');
await DRE.run('full-deploy-weth-gateway', { pool: POOL_NAME });
console.log('6. Initialize lending pool');
await DRE.run('full:initialize-lending-pool', { pool: POOL_NAME });
if (verify) {
printContracts();
console.log('7. Veryfing contracts');
await DRE.run('verify:general', { all: true, pool: POOL_NAME });
console.log('8. Veryfing aTokens and debtTokens');
await DRE.run('verify:tokens', { pool: POOL_NAME });
}
if (usingTenderly()) {
const postDeployHead = DRE.tenderlyRPC.getHead();
const postDeployFork = DRE.tenderlyRPC.getFork();
console.log('Tenderly Info');
console.log('- Head', postDeployHead);
console.log('- Fork', postDeployFork);
}
console.log('\nFinished migrations');
printContracts();
});

53
tasks/migrations/matic.mainnet.ts Normal file
View File

@ -0,0 +1,53 @@
import { task } from 'hardhat/config';
import { checkVerification } from '../../helpers/etherscan-verification';
import { ConfigNames } from '../../helpers/configuration';
import { printContracts } from '../../helpers/misc-utils';
import { usingTenderly } from '../../helpers/tenderly-utils';
task('matic:mainnet', 'Deploy development enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({ verify }, DRE) => {
const POOL_NAME = ConfigNames.Matic;
await DRE.run('set-DRE');
// Prevent loss of gas verifying all the needed ENVs for Etherscan verification
if (verify) {
checkVerification();
}
console.log('Migration started\n');
console.log('1. Deploy address provider');
await DRE.run('full:deploy-address-provider', { pool: POOL_NAME });
console.log('2. Deploy lending pool');
await DRE.run('full:deploy-lending-pool', { pool: POOL_NAME });
console.log('3. Deploy oracles');
await DRE.run('full:deploy-oracles', { pool: POOL_NAME });
console.log('4. Deploy Data Provider');
await DRE.run('full:data-provider', { pool: POOL_NAME });
console.log('5. Initialize lending pool');
await DRE.run('full:initialize-lending-pool', { pool: POOL_NAME });
if (verify) {
printContracts();
console.log('4. Veryfing contracts');
await DRE.run('verify:general', { all: true, pool: POOL_NAME });
console.log('5. Veryfing aTokens and debtTokens');
await DRE.run('verify:tokens', { pool: POOL_NAME });
}
if (usingTenderly()) {
const postDeployHead = DRE.tenderlyRPC.getHead();
const postDeployFork = DRE.tenderlyRPC.getFork();
console.log('Tenderly Info');
console.log('- Head', postDeployHead);
console.log('- Fork', postDeployFork);
}
console.log('\nFinished migrations');
printContracts();
});

14
tasks/misc/initialize-tokens.ts
View File

@ -1,7 +1,7 @@
import { task } from 'hardhat/config';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { loadPoolConfig, ConfigNames, getTreasuryAddress } from '../../helpers/configuration';
import { eEthereumNetwork, ICommonConfiguration } from '../../helpers/types';
import { eEthereumNetwork, eNetwork, ICommonConfiguration } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import { initTokenReservesByHelper } from '../../helpers/init-helpers';
import { exit } from 'process';
@ -23,9 +23,7 @@ task('full:initialize-tokens', 'Initialize lending pool configuration.')
await DRE.run('set-DRE');
let signer: Signer;
const network =
process.env.MAINNET_FORK === 'true'
? eEthereumNetwork.main
: <eEthereumNetwork>DRE.network.name;
process.env.MAINNET_FORK === 'true' ? eEthereumNetwork.main : <eNetwork>DRE.network.name;
const poolConfig = loadPoolConfig(pool);
const { ReserveAssets, ReservesConfig } = poolConfig as ICommonConfiguration;
@ -62,13 +60,7 @@ task('full:initialize-tokens', 'Initialize lending pool configuration.')
const balance = await signer.getBalance();
console.log('signer balance', formatEther(balance));
} else {
signer = await getFirstSigner();
const deployerAddress = await signer.getAddress();
if (providerRegistryOwner !== (await signer.getAddress())) {
throw Error(
`Current signer is not provider registry owner. \nCurrent deployer address: ${deployerAddress} \nExpected address: ${poolConfig.ProviderRegistryOwner}`
);
}
signer = DRE.ethers.provider.getSigner(providerRegistryOwner);
}
// Init unitilialized reserves

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

@ -7,7 +7,7 @@ import {
} from '../../helpers/contracts-getters';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { DRE } from '../../helpers/misc-utils';
import { eEthereumNetwork } from '../../helpers/types';
import { eEthereumNetwork, eNetwork, ePolygonNetwork, eXDaiNetwork } from '../../helpers/types';
task('print-config', 'Inits the DRE, to have access to all the plugins')
.addParam('dataProvider', 'Address of AaveProtocolDataProvider')
@ -17,7 +17,7 @@ task('print-config', 'Inits the DRE, to have access to all the plugins')
const network =
process.env.MAINNET_FORK === 'true'
? eEthereumNetwork.main
: (localBRE.network.name as eEthereumNetwork);
: (localBRE.network.name as eNetwork);
const poolConfig = loadPoolConfig(pool);
const providerRegistryAddress = getParamPerNetwork(poolConfig.ProviderRegistry, network);

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

@ -3,6 +3,8 @@ import { DRE, setDRE } from '../../helpers/misc-utils';
import { EthereumNetworkNames } from '../../helpers/types';
import { usingTenderly } from '../../helpers/tenderly-utils';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { getFirstSigner } from '../../helpers/contracts-getters';
import { formatEther } from 'ethers/lib/utils';
task(`set-DRE`, `Inits the DRE, to have access to all the plugins' objects`).setAction(
async (_, _DRE) => {
@ -14,10 +16,24 @@ task(`set-DRE`, `Inits the DRE, to have access to all the plugins' objects`).set
process.env.TENDERLY === 'true'
) {
console.log('- Setting up Tenderly provider');
await _DRE.tenderlyRPC.initializeFork();
console.log('- Initialized Tenderly fork');
if (process.env.TENDERLY_FORK_ID && process.env.TENDERLY_HEAD_ID) {
console.log('- Connecting to a Tenderly Fork');
_DRE.tenderlyRPC.setFork(process.env.TENDERLY_FORK_ID);
_DRE.tenderlyRPC.setHead(process.env.TENDERLY_HEAD_ID);
} else {
console.log('- Creating a new Tenderly Fork');
await _DRE.tenderlyRPC.initializeFork();
}
const provider = new _DRE.ethers.providers.Web3Provider(_DRE.tenderlyRPC as any);
_DRE.ethers.provider = provider;
console.log('- Initialized Tenderly fork:');
console.log(' - Fork: ', _DRE.tenderlyRPC.getFork());
console.log(' - Head: ', _DRE.tenderlyRPC.getHead());
console.log(' - First account:', await (await _DRE.ethers.getSigners())[0].getAddress());
console.log(
' - Balance:',
formatEther(await (await _DRE.ethers.getSigners())[0].getBalance())
);
}
setDRE(_DRE);

61
tasks/verifications/1_general.ts
View File

@ -25,20 +25,24 @@ import {
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { verifyContract } from '../../helpers/etherscan-verification';
import { notFalsyOrZeroAddress } from '../../helpers/misc-utils';
import { eEthereumNetwork, ICommonConfiguration } from '../../helpers/types';
import { eNetwork, ICommonConfiguration } from '../../helpers/types';
task('verify:general', 'Deploy oracles for dev enviroment')
task('verify:general', 'Verify contracts at Etherscan')
.addFlag('all', 'Verify all contracts at Etherscan')
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ all, pool }, localDRE) => {
await localDRE.run('set-DRE');
const network = localDRE.network.name as eEthereumNetwork;
const network = localDRE.network.name as eNetwork;
const poolConfig = loadPoolConfig(pool);
const {
ReserveAssets,
ReservesConfig,
ProviderRegistry,
MarketId,
LendingPoolCollateralManager,
LendingPoolConfigurator,
LendingPool,
WethGateway,
} = poolConfig as ICommonConfiguration;
const treasuryAddress = await getTreasuryAddress(poolConfig);
@ -47,17 +51,41 @@ task('verify:general', 'Deploy oracles for dev enviroment')
const addressesProviderRegistry = notFalsyOrZeroAddress(registryAddress)
? await getLendingPoolAddressesProviderRegistry(registryAddress)
: await getLendingPoolAddressesProviderRegistry();
const lendingPoolProxy = await getLendingPool();
const lendingPoolConfigurator = await getLendingPoolConfiguratorProxy();
const lendingPoolCollateralManager = await getLendingPoolCollateralManager();
const lendingPoolAddress = await addressesProvider.getLendingPool();
const lendingPoolConfiguratorAddress = await addressesProvider.getLendingPoolConfigurator(); //getLendingPoolConfiguratorProxy();
const lendingPoolCollateralManagerAddress = await addressesProvider.getLendingPoolCollateralManager();
if (all) {
const lendingPoolImpl = await getLendingPoolImpl();
const lendingPoolConfiguratorImpl = await getLendingPoolConfiguratorImpl();
const lendingPoolCollateralManagerImpl = await getLendingPoolCollateralManagerImpl();
const lendingPoolImplAddress = getParamPerNetwork(LendingPool, network);
const lendingPoolImpl = notFalsyOrZeroAddress(lendingPoolImplAddress)
? await getLendingPoolImpl(lendingPoolImplAddress)
: await getLendingPoolImpl();
const lendingPoolConfiguratorImplAddress = getParamPerNetwork(
LendingPoolConfigurator,
network
);
const lendingPoolConfiguratorImpl = notFalsyOrZeroAddress(lendingPoolConfiguratorImplAddress)
? await getLendingPoolConfiguratorImpl(lendingPoolConfiguratorImplAddress)
: await getLendingPoolConfiguratorImpl();
const lendingPoolCollateralManagerImplAddress = getParamPerNetwork(
LendingPoolCollateralManager,
network
);
const lendingPoolCollateralManagerImpl = notFalsyOrZeroAddress(
lendingPoolCollateralManagerImplAddress
)
? await getLendingPoolCollateralManagerImpl(lendingPoolCollateralManagerImplAddress)
: await getLendingPoolCollateralManagerImpl();
const dataProvider = await getAaveProtocolDataProvider();
const walletProvider = await getWalletProvider();
const wethGateway = await getWETHGateway();
const wethGatewayAddress = getParamPerNetwork(WethGateway, network);
const wethGateway = notFalsyOrZeroAddress(wethGatewayAddress)
? await getWETHGateway(wethGatewayAddress)
: await getWETHGateway();
// Address Provider
console.log('\n- Verifying address provider...\n');
@ -89,22 +117,19 @@ task('verify:general', 'Deploy oracles for dev enviroment')
// WETHGateway
console.log('\n- Verifying WETHGateway...\n');
await verifyContract(wethGateway.address, [
await getWethAddress(poolConfig),
lendingPoolProxy.address,
]);
await verifyContract(wethGateway.address, [await getWethAddress(poolConfig)]);
}
// Lending Pool proxy
console.log('\n- Verifying Lending Pool Proxy...\n');
await verifyContract(lendingPoolProxy.address, [addressesProvider.address]);
await verifyContract(lendingPoolAddress, [addressesProvider.address]);
// LendingPool Conf proxy
console.log('\n- Verifying Lending Pool Configurator Proxy...\n');
await verifyContract(lendingPoolConfigurator.address, [addressesProvider.address]);
await verifyContract(lendingPoolConfiguratorAddress, [addressesProvider.address]);
// Proxy collateral manager
console.log('\n- Verifying Lending Pool Collateral Manager Proxy...\n');
await verifyContract(lendingPoolCollateralManager.address, []);
await verifyContract(lendingPoolCollateralManagerAddress, []);
// DelegatedAwareAToken
console.log('\n- Verifying DelegatedAwareAToken...\n');
@ -113,7 +138,7 @@ task('verify:general', 'Deploy oracles for dev enviroment')
if (aUNI) {
console.log('Verifying aUNI');
await verifyContract(aUNI, [
lendingPoolProxy.address,
lendingPoolAddress,
UNI,
treasuryAddress,
'Aave interest bearing UNI',

19
tasks/verifications/2_tokens.ts
View File

@ -8,26 +8,35 @@ import {
import { ZERO_ADDRESS } from '../../helpers/constants';
import {
getAddressById,
getFirstSigner,
getLendingPool,
getLendingPoolAddressesProvider,
getLendingPoolConfiguratorProxy,
} from '../../helpers/contracts-getters';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { verifyContract } from '../../helpers/etherscan-verification';
import { eEthereumNetwork, ICommonConfiguration, IReserveParams } from '../../helpers/types';
import { eNetwork, ICommonConfiguration, IReserveParams } from '../../helpers/types';
import { LendingPoolConfiguratorFactory, LendingPoolFactory } from '../../types';
task('verify:tokens', 'Deploy oracles for dev enviroment')
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ verify, all, pool }, localDRE) => {
await localDRE.run('set-DRE');
const network = localDRE.network.name as eEthereumNetwork;
const network = localDRE.network.name as eNetwork;
const poolConfig = loadPoolConfig(pool);
const { ReserveAssets, ReservesConfig } = poolConfig as ICommonConfiguration;
const treasuryAddress = await getTreasuryAddress(poolConfig);
const addressesProvider = await getLendingPoolAddressesProvider();
const lendingPoolProxy = await getLendingPool();
const lendingPoolConfigurator = await getLendingPoolConfiguratorProxy();
const lendingPoolProxy = LendingPoolFactory.connect(
await addressesProvider.getLendingPool(),
await getFirstSigner()
);
const lendingPoolConfigurator = LendingPoolConfiguratorFactory.connect(
await addressesProvider.getLendingPoolConfigurator(),
await getFirstSigner()
);
const configs = Object.entries(ReservesConfig) as [string, IReserveParams][];
for (const entry of Object.entries(getParamPerNetwork(ReserveAssets, network))) {
@ -52,7 +61,7 @@ task('verify:tokens', 'Deploy oracles for dev enviroment')
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
} = tokenConfig[1];
} = tokenConfig[1].strategy;
console.log;
// Proxy Stable Debt

68
test/__setup.spec.ts → test-suites/test-aave/__setup.spec.ts
View File

@ -4,7 +4,7 @@ import {
insertContractAddressInDb,
getEthersSigners,
registerContractInJsonDb,
} from '../helpers/contracts-helpers';
} from '../../helpers/contracts-helpers';
import {
deployLendingPoolAddressesProvider,
deployMintableERC20,
@ -26,33 +26,35 @@ import {
deployUniswapLiquiditySwapAdapter,
deployUniswapRepayAdapter,
deployFlashLiquidationAdapter,
} from '../helpers/contracts-deployments';
authorizeWETHGateway,
} from '../../helpers/contracts-deployments';
import { eEthereumNetwork } from '../../helpers/types';
import { Signer } from 'ethers';
import { TokenContractId, eContractid, tEthereumAddress, AavePools } from '../helpers/types';
import { MintableERC20 } from '../types/MintableERC20';
import { TokenContractId, eContractid, tEthereumAddress, AavePools } from '../../helpers/types';
import { MintableERC20 } from '../../types/MintableERC20';
import {
ConfigNames,
getReservesConfigByPool,
getTreasuryAddress,
loadPoolConfig,
} from '../helpers/configuration';
} from '../../helpers/configuration';
import { initializeMakeSuite } from './helpers/make-suite';
import {
setInitialAssetPricesInOracle,
deployAllMockAggregators,
setInitialMarketRatesInRatesOracleByHelper,
} from '../helpers/oracles-helpers';
import { DRE, waitForTx } from '../helpers/misc-utils';
import { initReservesByHelper, configureReservesByHelper } from '../helpers/init-helpers';
import AaveConfig from '../markets/aave';
import { ZERO_ADDRESS } from '../helpers/constants';
} from '../../helpers/oracles-helpers';
import { DRE, waitForTx } from '../../helpers/misc-utils';
import { initReservesByHelper, configureReservesByHelper } from '../../helpers/init-helpers';
import AaveConfig from '../../markets/aave';
import { ZERO_ADDRESS } from '../../helpers/constants';
import {
getLendingPool,
getLendingPoolConfiguratorProxy,
getPairsTokenAggregator,
} from '../helpers/contracts-getters';
import { WETH9Mocked } from '../types/WETH9Mocked';
} from '../../helpers/contracts-getters';
import { WETH9Mocked } from '../../types/WETH9Mocked';
const MOCK_USD_PRICE_IN_WEI = AaveConfig.ProtocolGlobalParams.MockUsdPriceInWei;
const ALL_ASSETS_INITIAL_PRICES = AaveConfig.Mocks.AllAssetsInitialPrices;
@ -95,7 +97,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
const aaveAdmin = await deployer.getAddress();
const mockTokens = await deployAllMockTokens(deployer);
console.log('Deployed mocks');
const addressesProvider = await deployLendingPoolAddressesProvider(AaveConfig.MarketId);
await waitForTx(await addressesProvider.setPoolAdmin(aaveAdmin));
@ -165,13 +167,37 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
REN: mockTokens.REN.address,
UNI: mockTokens.UNI.address,
ENJ: mockTokens.ENJ.address,
// DAI: mockTokens.LpDAI.address,
// USDC: mockTokens.LpUSDC.address,
// USDT: mockTokens.LpUSDT.address,
// WBTC: mockTokens.LpWBTC.address,
// WETH: mockTokens.LpWETH.address,
UniDAIWETH: mockTokens.UniDAIWETH.address,
UniWBTCWETH: mockTokens.UniWBTCWETH.address,
UniAAVEWETH: mockTokens.UniAAVEWETH.address,
UniBATWETH: mockTokens.UniBATWETH.address,
UniDAIUSDC: mockTokens.UniDAIUSDC.address,
UniCRVWETH: mockTokens.UniCRVWETH.address,
UniLINKWETH: mockTokens.UniLINKWETH.address,
UniMKRWETH: mockTokens.UniMKRWETH.address,
UniRENWETH: mockTokens.UniRENWETH.address,
UniSNXWETH: mockTokens.UniSNXWETH.address,
UniUNIWETH: mockTokens.UniUNIWETH.address,
UniUSDCWETH: mockTokens.UniUSDCWETH.address,
UniWBTCUSDC: mockTokens.UniWBTCUSDC.address,
UniYFIWETH: mockTokens.UniYFIWETH.address,
BptWBTCWETH: mockTokens.BptWBTCWETH.address,
BptBALWETH: mockTokens.BptBALWETH.address,
WMATIC: mockTokens.WMATIC.address,
USD: USD_ADDRESS,
STAKE: mockTokens.STAKE.address,
xSUSHI: mockTokens.xSUSHI.address
},
fallbackOracle
);
const mockAggregators = await deployAllMockAggregators(MOCK_CHAINLINK_AGGREGATORS_PRICES);
console.log('Mock aggs deployed');
const allTokenAddresses = Object.entries(mockTokens).reduce(
(accum: { [tokenSymbol: string]: tEthereumAddress }, [tokenSymbol, tokenContract]) => ({
...accum,
@ -217,16 +243,27 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
const config = loadPoolConfig(ConfigNames.Aave);
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
} = config;
const treasuryAddress = await getTreasuryAddress(config);
await initReservesByHelper(
reservesParams,
allReservesAddresses,
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
admin,
treasuryAddress,
ZERO_ADDRESS,
false
);
await configureReservesByHelper(reservesParams, allReservesAddresses, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager();
@ -249,7 +286,8 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
await deployWalletBalancerProvider();
await deployWETHGateway([mockTokens.WETH.address, lendingPoolAddress]);
const gateWay = await deployWETHGateway([mockTokens.WETH.address]);
await authorizeWETHGateway(gateWay.address, lendingPoolAddress);
console.timeEnd('setup');
};

4
test/addresses-provider-registry.spec.ts → test-suites/test-aave/addresses-provider-registry.spec.ts
View File

@ -1,6 +1,6 @@
import { TestEnv, makeSuite } from './helpers/make-suite';
import { ZERO_ADDRESS } from '../helpers/constants';
import { ProtocolErrors } from '../helpers/types';
import { ZERO_ADDRESS } from '../../helpers/constants';
import { ProtocolErrors } from '../../helpers/types';
const { expect } = require('chai');

2
test/atoken-modifiers.spec.ts → test-suites/test-aave/atoken-modifiers.spec.ts
View File

@ -1,6 +1,6 @@
import { expect } from 'chai';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors } from '../helpers/types';
import { ProtocolErrors } from '../../helpers/types';
makeSuite('AToken: Modifiers', (testEnv: TestEnv) => {
const { CT_CALLER_MUST_BE_LENDING_POOL } = ProtocolErrors;

24
test/atoken-permit.spec.ts → test-suites/test-aave/atoken-permit.spec.ts
View File

@ -1,11 +1,11 @@
import { MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../helpers/constants';
import { BUIDLEREVM_CHAINID } from '../helpers/buidler-constants';
import { buildPermitParams, getSignatureFromTypedData } from '../helpers/contracts-helpers';
import { MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../../helpers/constants';
import { BUIDLEREVM_CHAINID } from '../../helpers/buidler-constants';
import { buildPermitParams, getSignatureFromTypedData } from '../../helpers/contracts-helpers';
import { expect } from 'chai';
import { ethers } from 'ethers';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { DRE } from '../helpers/misc-utils';
import { waitForTx } from '../helpers/misc-utils';
import { DRE } from '../../helpers/misc-utils';
import { waitForTx } from '../../helpers/misc-utils';
import { _TypedDataEncoder } from 'ethers/lib/utils';
const { parseEther } = ethers.utils;
@ -58,7 +58,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
expiration.toFixed()
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -103,7 +103,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -145,7 +145,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -191,7 +191,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -226,7 +226,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -261,7 +261,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}
@ -296,7 +296,7 @@ makeSuite('AToken: Permit', (testEnv: TestEnv) => {
permitAmount
);
const ownerPrivateKey = require('../test-wallets.js').accounts[0].secretKey;
const ownerPrivateKey = require('../../test-wallets.js').accounts[0].secretKey;
if (!ownerPrivateKey) {
throw new Error('INVALID_OWNER_PK');
}

8
test/atoken-transfer.spec.ts → test-suites/test-aave/atoken-transfer.spec.ts
View File

@ -1,10 +1,10 @@
import { APPROVAL_AMOUNT_LENDING_POOL, MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { APPROVAL_AMOUNT_LENDING_POOL, MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../../helpers/constants';
import { convertToCurrencyDecimals } from '../../helpers/contracts-helpers';
import { expect } from 'chai';
import { ethers } from 'ethers';
import { RateMode, ProtocolErrors } from '../helpers/types';
import { RateMode, ProtocolErrors } from '../../helpers/types';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { CommonsConfig } from '../markets/aave/commons';
import { CommonsConfig } from '../../markets/aave/commons';
const AAVE_REFERRAL = CommonsConfig.ProtocolGlobalParams.AaveReferral;

8
test/configurator.spec.ts → test-suites/test-aave/configurator.spec.ts
View File

@ -1,8 +1,8 @@
import { TestEnv, makeSuite } from './helpers/make-suite';
import { APPROVAL_AMOUNT_LENDING_POOL, RAY } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { ProtocolErrors } from '../helpers/types';
import { strategyWETH } from '../markets/aave/reservesConfigs';
import { APPROVAL_AMOUNT_LENDING_POOL, RAY } from '../../helpers/constants';
import { convertToCurrencyDecimals } from '../../helpers/contracts-helpers';
import { ProtocolErrors } from '../../helpers/types';
import { strategyWETH } from '../../markets/aave/reservesConfigs';
const { expect } = require('chai');

71
test-suites/test-aave/delegation-aware-atoken.spec.ts Normal file
View File

@ -0,0 +1,71 @@
import { MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../../helpers/constants';
import { BUIDLEREVM_CHAINID } from '../../helpers/buidler-constants';
import { buildPermitParams, getSignatureFromTypedData } from '../../helpers/contracts-helpers';
import { expect } from 'chai';
import { ethers } from 'ethers';
import { ProtocolErrors } from '../../helpers/types';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { DRE } from '../../helpers/misc-utils';
import {
ConfigNames,
getATokenDomainSeparatorPerNetwork,
getTreasuryAddress,
loadPoolConfig,
} from '../../helpers/configuration';
import { waitForTx } from '../../helpers/misc-utils';
import {
deployDelegationAwareAToken,
deployMintableDelegationERC20,
} from '../../helpers/contracts-deployments';
import { DelegationAwareATokenFactory } from '../../types';
import { DelegationAwareAToken } from '../../types/DelegationAwareAToken';
import { MintableDelegationERC20 } from '../../types/MintableDelegationERC20';
import AaveConfig from '../../markets/aave';
const { parseEther } = ethers.utils;
makeSuite('AToken: underlying delegation', (testEnv: TestEnv) => {
const poolConfig = loadPoolConfig(ConfigNames.Commons);
let delegationAToken = <DelegationAwareAToken>{};
let delegationERC20 = <MintableDelegationERC20>{};
it('Deploys a new MintableDelegationERC20 and a DelegationAwareAToken', async () => {
const { pool } = testEnv;
delegationERC20 = await deployMintableDelegationERC20(['DEL', 'DEL', '18']);
delegationAToken = await deployDelegationAwareAToken(
[
pool.address,
delegationERC20.address,
await getTreasuryAddress(AaveConfig),
ZERO_ADDRESS,
'aDEL',
'aDEL',
],
false
);
//await delegationAToken.initialize(pool.address, ZERO_ADDRESS, delegationERC20.address, ZERO_ADDRESS, '18', 'aDEL', 'aDEL');
console.log((await delegationAToken.decimals()).toString());
});
it('Tries to delegate with the caller not being the Aave admin', async () => {
const { users } = testEnv;
await expect(
delegationAToken.connect(users[1].signer).delegateUnderlyingTo(users[2].address)
).to.be.revertedWith(ProtocolErrors.CALLER_NOT_POOL_ADMIN);
});
it('Tries to delegate to user 2', async () => {
const { users } = testEnv;
await delegationAToken.delegateUnderlyingTo(users[2].address);
const delegateeAddress = await delegationERC20.delegatee();
expect(delegateeAddress).to.be.equal(users[2].address);
});
});

16
test/flashloan.spec.ts → test-suites/test-aave/flashloan.spec.ts
View File

@ -1,18 +1,18 @@
import BigNumber from 'bignumber.js';
import { TestEnv, makeSuite } from './helpers/make-suite';
import { APPROVAL_AMOUNT_LENDING_POOL, oneRay } from '../helpers/constants';
import { convertToCurrencyDecimals, getContract } from '../helpers/contracts-helpers';
import { APPROVAL_AMOUNT_LENDING_POOL, oneRay } from '../../helpers/constants';
import { convertToCurrencyDecimals, getContract } from '../../helpers/contracts-helpers';
import { ethers } from 'ethers';
import { MockFlashLoanReceiver } from '../types/MockFlashLoanReceiver';
import { ProtocolErrors, eContractid } from '../helpers/types';
import { VariableDebtToken } from '../types/VariableDebtToken';
import { StableDebtToken } from '../types/StableDebtToken';
import { MockFlashLoanReceiver } from '../../types/MockFlashLoanReceiver';
import { ProtocolErrors, eContractid } from '../../helpers/types';
import { VariableDebtToken } from '../../types/VariableDebtToken';
import { StableDebtToken } from '../../types/StableDebtToken';
import {
getMockFlashLoanReceiver,
getStableDebtToken,
getVariableDebtToken,
} from '../helpers/contracts-getters';
} from '../../helpers/contracts-getters';
const { expect } = require('chai');
@ -462,7 +462,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
const reserveData = await pool.getReserveData(weth.address);
const stableDebtToken = await getVariableDebtToken(reserveData.stableDebtTokenAddress);
const stableDebtToken = await getStableDebtToken(reserveData.stableDebtTokenAddress);
// Deposited for onBehalfOf user already, delegate borrow allowance
await stableDebtToken.connect(onBehalfOf.signer).approveDelegation(caller.address, flashAmount);

Some files were not shown because too many files have changed in this diff Show More