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

Merge branch 'feat/light-deployments' of github.com:aave/protocol-v2 into feat/light-deployments

Browse Source
This commit is contained in:
The3D 2021-03-01 15:58:41 +01:00
commit e735d40a3b
161 changed files with 44314 additions and 1221 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
) {

3
contracts/interfaces/IInitializableAToken.sol
View File

@ -27,6 +27,7 @@ interface IInitializableAToken {
IAaveIncentivesController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol
string calldata aTokenSymbol,
bytes calldata params
) external;
}

3
contracts/interfaces/IInitializableDebtToken.sol
View File

@ -25,6 +25,7 @@ interface IInitializableDebtToken {
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol
string memory debtTokenSymbol,
bytes calldata params
) external;
}

3
contracts/interfaces/ILendingPoolConfigurator.sol
View File

@ -19,6 +19,7 @@ interface ILendingPoolConfigurator {
string variableDebtTokenSymbol;
string stableDebtTokenName;
string stableDebtTokenSymbol;
bytes params;
}
struct UpdateATokenInput {
@ -28,6 +29,7 @@ interface ILendingPoolConfigurator {
string name;
string symbol;
address implementation;
bytes params;
}
struct UpdateDebtTokenInput {
@ -36,6 +38,7 @@ interface ILendingPoolConfigurator {
string name;
string symbol;
address implementation;
bytes params;
}
/**

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

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

@ -60,183 +60,186 @@ contract LendingPoolConfigurator is VersionedInitializable, ILendingPoolConfigur
/**
* @dev Initializes reserves in batch
**/
function batchInitReserve(InitReserveInput[] calldata inputParams) external onlyPoolAdmin {
function batchInitReserve(InitReserveInput[] calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
for (uint256 i = 0; i < inputParams.length; i++) {
_initReserve(cachedPool, inputParams[i]);
for (uint256 i = 0; i < input.length; i++) {
_initReserve(cachedPool, input[i]);
}
}
function _initReserve(ILendingPool pool, InitReserveInput calldata inputParams) internal {
function _initReserve(ILendingPool pool, InitReserveInput calldata input) internal {
address aTokenProxyAddress =
_initTokenWithProxy(
inputParams.aTokenImpl,
input.aTokenImpl,
abi.encodeWithSelector(
IInitializableAToken.initialize.selector,
pool,
inputParams.treasury,
inputParams.underlyingAsset,
IAaveIncentivesController(inputParams.incentivesController),
inputParams.underlyingAssetDecimals,
inputParams.aTokenName,
inputParams.aTokenSymbol
input.treasury,
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.aTokenName,
input.aTokenSymbol,
input.params
)
);
address stableDebtTokenProxyAddress =
_initTokenWithProxy(
inputParams.stableDebtTokenImpl,
input.stableDebtTokenImpl,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
pool,
inputParams.underlyingAsset,
IAaveIncentivesController(inputParams.incentivesController),
inputParams.underlyingAssetDecimals,
inputParams.stableDebtTokenName,
inputParams.stableDebtTokenSymbol
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.stableDebtTokenName,
input.stableDebtTokenSymbol,
input.params
)
);
address variableDebtTokenProxyAddress =
_initTokenWithProxy(
inputParams.variableDebtTokenImpl,
input.variableDebtTokenImpl,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
pool,
inputParams.underlyingAsset,
IAaveIncentivesController(inputParams.incentivesController),
inputParams.underlyingAssetDecimals,
inputParams.variableDebtTokenName,
inputParams.variableDebtTokenSymbol
input.underlyingAsset,
IAaveIncentivesController(input.incentivesController),
input.underlyingAssetDecimals,
input.variableDebtTokenName,
input.variableDebtTokenSymbol,
input.params
)
);
pool.initReserve(
inputParams.underlyingAsset,
input.underlyingAsset,
aTokenProxyAddress,
stableDebtTokenProxyAddress,
variableDebtTokenProxyAddress,
inputParams.interestRateStrategyAddress
input.interestRateStrategyAddress
);
DataTypes.ReserveConfigurationMap memory currentConfig =
pool.getConfiguration(inputParams.underlyingAsset);
pool.getConfiguration(input.underlyingAsset);
currentConfig.setDecimals(inputParams.underlyingAssetDecimals);
currentConfig.setDecimals(input.underlyingAssetDecimals);
currentConfig.setActive(true);
currentConfig.setFrozen(false);
pool.setConfiguration(inputParams.underlyingAsset, currentConfig.data);
pool.setConfiguration(input.underlyingAsset, currentConfig.data);
emit ReserveInitialized(
inputParams.underlyingAsset,
input.underlyingAsset,
aTokenProxyAddress,
stableDebtTokenProxyAddress,
variableDebtTokenProxyAddress,
inputParams.interestRateStrategyAddress
input.interestRateStrategyAddress
);
}
/**
* @dev Updates the aToken implementation for the reserve
**/
function updateAToken(UpdateATokenInput calldata inputParams) external onlyPoolAdmin {
function updateAToken(UpdateATokenInput calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(inputParams.asset);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
DataTypes.ReserveConfigurationMap memory configuration =
cachedPool.getConfiguration(inputParams.asset);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
(, , , uint256 decimals, ) = configuration.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,
inputParams.implementation,
abi.encodeWithSelector(
IInitializableAToken.initialize.selector,
cachedPool,
inputParams.treasury,
inputParams.asset,
inputParams.incentivesController,
decimals,
inputParams.name,
inputParams.symbol
)
input.implementation,
encodedCall
);
emit ATokenUpgraded(inputParams.asset, reserveData.aTokenAddress, inputParams.implementation);
emit ATokenUpgraded(input.asset, reserveData.aTokenAddress, input.implementation);
}
/**
* @dev Updates the stable debt token implementation for the reserve
**/
function updateStableDebtToken(UpdateDebtTokenInput calldata inputParams) external onlyPoolAdmin {
function updateStableDebtToken(UpdateDebtTokenInput calldata input) external onlyPoolAdmin {
ILendingPool cachedPool = pool;
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(inputParams.asset);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
DataTypes.ReserveConfigurationMap memory configuration =
cachedPool.getConfiguration(inputParams.asset);
(, , , uint256 decimals, ) = configuration.getParamsMemory();
bytes memory encodedCall = abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
input.asset,
input.incentivesController,
decimals,
input.name,
input.symbol,
input.params
);
_upgradeTokenImplementation(
reserveData.stableDebtTokenAddress,
inputParams.implementation,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
inputParams.asset,
inputParams.incentivesController,
decimals,
inputParams.name,
inputParams.symbol
)
input.implementation,
encodedCall
);
emit StableDebtTokenUpgraded(
inputParams.asset,
input.asset,
reserveData.stableDebtTokenAddress,
inputParams.implementation
input.implementation
);
}
/**
* @dev Updates the variable debt token implementation for the asset
**/
function updateVariableDebtToken(UpdateDebtTokenInput calldata inputParams)
function updateVariableDebtToken(UpdateDebtTokenInput calldata input)
external
onlyPoolAdmin
{
ILendingPool cachedPool = pool;
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(inputParams.asset);
DataTypes.ReserveData memory reserveData = cachedPool.getReserveData(input.asset);
DataTypes.ReserveConfigurationMap memory configuration =
cachedPool.getConfiguration(inputParams.asset);
(, , , uint256 decimals, ) = cachedPool.getConfiguration(input.asset).getParamsMemory();
(, , , uint256 decimals, ) = configuration.getParamsMemory();
bytes memory encodedCall = abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
input.asset,
input.incentivesController,
decimals,
input.name,
input.symbol,
input.params
);
_upgradeTokenImplementation(
reserveData.variableDebtTokenAddress,
inputParams.implementation,
abi.encodeWithSelector(
IInitializableDebtToken.initialize.selector,
cachedPool,
inputParams.asset,
inputParams.incentivesController,
decimals,
inputParams.name,
inputParams.symbol
)
input.implementation,
encodedCall
);
emit VariableDebtTokenUpgraded(
inputParams.asset,
input.asset,
reserveData.variableDebtTokenAddress,
inputParams.implementation
input.implementation
);
}

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

@ -68,7 +68,8 @@ contract AToken is
IAaveIncentivesController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol
string calldata aTokenSymbol,
bytes calldata params
) external override initializer {
uint256 chainId;

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

@ -44,7 +44,8 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol
string memory debtTokenSymbol,
bytes calldata params
) public override initializer {
_setName(debtTokenName);
_setSymbol(debtTokenSymbol);

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

@ -38,7 +38,8 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
IAaveIncentivesController incentivesController,
uint8 debtTokenDecimals,
string memory debtTokenName,
string memory debtTokenSymbol
string memory debtTokenSymbol,
bytes calldata params
) public override initializer {
_setName(debtTokenName);
_setSymbol(debtTokenSymbol);

50
hardhat.config.ts
View File

@ -3,9 +3,10 @@ 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();
import '@nomiclabs/hardhat-ethers';
@ -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;
@ -104,6 +95,9 @@ const buidlerConfig: HardhatUserConfig = {
ropsten: getCommonNetworkConfig(eEthereumNetwork.ropsten, 3),
main: getCommonNetworkConfig(eEthereumNetwork.main, 1),
tenderlyMain: getCommonNetworkConfig(eEthereumNetwork.main, 1),
matic: getCommonNetworkConfig(ePolygonNetwork.matic, 137),
mumbai: getCommonNetworkConfig(ePolygonNetwork.mumbai, 80001),
xdai: getCommonNetworkConfig(eXDaiNetwork.xdai, 100),
hardhat: {
hardfork: 'istanbul',
blockGasLimit: DEFAULT_BLOCK_GAS_LIMIT,

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

@ -0,0 +1,43 @@
// @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 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]: ALCHEMY_KEY
? `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_KEY}`
: `https://mainnet.infura.io/v3/${INFURA_KEY}`,
[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]: 65 * 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;
}

42
helpers/constants.ts
View File

@ -28,3 +28,45 @@ 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(),
USD: '5848466240000000',
};

137
helpers/contracts-deployments.ts
View File

@ -300,7 +300,7 @@ export const deployDefaultReserveInterestRateStrategy = async (
);
export const deployStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify: boolean
) => {
const instance = await withSaveAndVerify(
@ -310,21 +310,13 @@ export const deployStableDebtToken = async (
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4]);
return instance;
}
};
export const deployVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, string, string, tEthereumAddress],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
verify: boolean
) => {
const instance = await withSaveAndVerify(
@ -334,18 +326,26 @@ export const deployVariableDebtToken = async (
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
await instance.initialize(args[0], args[1], args[2], '18', args[3], args[4]);
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, incentivesController, name, symbol]: [
@ -364,20 +364,28 @@ export const deployGenericAToken = async (
[],
verify
);
await instance.initialize(
poolAddress,
poolAddress,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
"18",
name,
underlyingAssetAddress,
incentivesController,
'18',
name,
symbol
);
return instance;
};
export const deployGenericATokenImpl = async (verify: boolean) =>
withSaveAndVerify(
await new ATokenFactory(await getFirstSigner()).deploy(),
eContractid.AToken,
[],
verify
);
export const deployDelegationAwareAToken = async (
[pool, underlyingAssetAddress, treasuryAddress, incentivesController, name, symbol]: [
tEthereumAddress,
@ -395,20 +403,29 @@ export const deployDelegationAwareAToken = async (
[],
verify
);
await instance.initialize(
pool,
treasuryAddress,
underlyingAssetAddress,
incentivesController,
"18",
'18',
name,
symbol
)
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 } = {};
@ -471,10 +488,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,
@ -482,8 +496,16 @@ export const deployWETHGateway = async (
verify
);
export const authorizeWETHGateway = async (
wethGateWay: tEthereumAddress,
lendingPool: tEthereumAddress
) =>
await new WETHGatewayFactory(await getFirstSigner())
.attach(wethGateWay)
.authorizeLendingPool(lendingPool);
export const deployMockStableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) => {
const instance = await withSaveAndVerify(
@ -493,18 +515,10 @@ export const deployMockStableDebtToken = async (
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
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(
@ -515,7 +529,7 @@ export const deployWETHMocked = async (verify?: boolean) =>
);
export const deployMockVariableDebtToken = async (
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) => {
const instance = await withSaveAndVerify(
@ -525,21 +539,13 @@ export const deployMockVariableDebtToken = async (
verify
);
await instance.initialize(
args[0],
args[1],
args[2],
"18",
args[3],
args[4]
);
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,tEthereumAddress, string, string],
args: [tEthereumAddress, tEthereumAddress, tEthereumAddress, tEthereumAddress, string, string, string],
verify?: boolean
) => {
const instance = await withSaveAndVerify(
@ -548,20 +554,11 @@ args: [tEthereumAddress, tEthereumAddress, tEthereumAddress,tEthereumAddress, st
[],
verify
);
await instance.initialize(
args[0],
args[2],
args[1],
args[3],
"18",
args[4],
args[5],
);
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(

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);

34
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';
@ -132,10 +139,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 +170,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;
}

464
helpers/init-helpers.ts
View File

@ -1,6 +1,7 @@
import {
eContractid,
eEthereumNetwork,
eNetwork,
iMultiPoolsAssets,
IReserveParams,
tEthereumAddress,
@ -20,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) {
@ -41,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,
@ -48,176 +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[] = [];
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,
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;
}[] = [];
console.log(
`- Token deployments in ${reservesChunks.length * 2} txs instead of ${
Object.entries(reservesParams).length * 4
} txs`
);
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 = '';
for (let reservesChunk of reservesChunks) {
// Prepare data
const tokens: string[] = [];
const symbols: string[] = [];
const strategyRates: [
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish
][] = [];
const reservesDecimals: string[] = [];
// 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;
const inputParams: {
asset: string,
rates: [
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish,
BigNumberish
]
}[] = [];
const aTokenImplementation = await deployGenericATokenImpl(verify);
aTokenImplementationAddress = aTokenImplementation.address;
rawInsertContractAddressInDb(`aTokenImpl`, aTokenImplementationAddress);
for (let [assetSymbol, { reserveDecimals }] of reservesChunk) {
const assetAddressIndex = Object.keys(tokenAddresses).findIndex(
(value) => value === assetSymbol
);
const [, tokenAddress] = (Object.entries(tokenAddresses) as [string, string][])[
assetAddressIndex
];
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);
inputParams.push({
asset: tokenAddress,
rates: [
optimalUtilizationRate,
baseVariableBorrowRate,
variableRateSlope1,
variableRateSlope2,
stableRateSlope1,
stableRateSlope2
]
});
}
// Deploy stable and variable deployers and save implementations
const tx1 = await waitForTx(
await stableAndVariableDeployer.initDeployment(tokens, symbols)
);
tx1.events?.forEach((event, index) => {
rawInsertContractAddressInDb(`stableDebt${symbols[index]}`, event?.args?.stableToken);
rawInsertContractAddressInDb(`variableDebt${symbols[index]}`, event?.args?.variableToken);
});
// Deploy atokens and rate strategies and save implementations
const tx2 = await waitForTx(
await atokenAndRatesDeployer.initDeployment(inputParams)
);
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,
@ -225,78 +152,64 @@ export const initReservesByHelper = async (
variableRateSlope2,
stableRateSlope1,
stableRateSlope2,
} = params;
const deployCustomAToken = chooseATokenDeployment(params.aTokenImpl);
const aToken = await deployCustomAToken(
[
poolAddress,
tokenAddresses[symbol],
treasuryAddress,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`,
],
verify
);
const stableDebt = await deployStableDebtToken(
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`
],
verify
);
const variableDebt = await deployVariableDebtToken(
[
poolAddress,
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`,
],
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);
}
for (let i = 0; i < deployedATokens.length; i ++) {
for (let i = 0; i < reserveSymbols.length; i++) {
let aTokenToUse: string;
if (aTokenType[reserveSymbols[i]] === 'generic') {
aTokenToUse = aTokenImplementationAddress;
} else {
aTokenToUse = delegationAwareATokenImplementationAddress;
}
initInputParams.push({
aTokenImpl: deployedATokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
variableDebtTokenImpl: deployedVariableTokens[i],
aTokenImpl: aTokenToUse,
stableDebtTokenImpl: stableDebtTokenImplementationAddress,
variableDebtTokenImpl: variableDebtTokenImplementationAddress,
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: deployedRates[i],
interestRateStrategyAddress: strategyAddressPerAsset[reserveSymbols[i]],
underlyingAsset: reserveTokens[i],
treasury: treasuryAddress,
incentivesController: ZERO_ADDRESS,
underlyingAssetName: reserveSymbols[i],
aTokenName: `Aave interest bearing ${reserveSymbols[i]}`,
aTokenSymbol: `a${reserveSymbols[i]}`,
variableDebtTokenName: `Aave variable debt bearing ${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${reserveSymbols[i]}`,
stableDebtTokenName: `Aave stable debt bearing ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`
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'
});
}
@ -305,7 +218,7 @@ export const initReservesByHelper = async (
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
await waitForTx(await addressProvider.setPoolAdmin(admin));
//await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
@ -315,13 +228,10 @@ export const initReservesByHelper = async (
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 = (
@ -367,7 +277,7 @@ export const configureReservesByHelper = async (
const reserveFactors: string[] = [];
const stableRatesEnabled: boolean[] = [];
const inputParams : {
const inputParams: {
asset: string;
baseLTV: BigNumberish;
liquidationThreshold: BigNumberish;
@ -410,7 +320,7 @@ export const configureReservesByHelper = async (
liquidationThreshold: liquidationThreshold,
liquidationBonus: liquidationBonus,
reserveFactor: reserveFactor,
stableBorrowingEnabled: stableBorrowRateEnabled
stableBorrowingEnabled: stableBorrowRateEnabled,
});
tokens.push(tokenAddress);
@ -433,10 +343,9 @@ export const configureReservesByHelper = async (
console.log(`- Configure reserves in ${chunkedInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInputParams.length; chunkIndex++) {
await waitForTx(
await atokenAndRatesDeployer.configureReserves(
chunkedInputParams[chunkIndex],
{ gasLimit: 12000000 }
)
await atokenAndRatesDeployer.configureReserves(chunkedInputParams[chunkIndex], {
gasLimit: 12000000,
})
);
console.log(` - Init for: ${chunkedSymbols[chunkIndex].join(', ')}`);
}
@ -447,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 },
@ -476,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;
@ -486,32 +398,31 @@ export const initTokenReservesByHelper = async (
let deployedVariableTokens: string[] = [];
let deployedATokens: string[] = [];
let deployedRates: string[] = [];
let reserveTokens: 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,
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);
@ -525,10 +436,20 @@ 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(
@ -537,7 +458,7 @@ export const initTokenReservesByHelper = async (
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives controller
`Aave stable debt bearing ${symbol}`,
`stableDebt${symbol}`
`stableDebt${symbol}`,
],
verify
);
@ -550,7 +471,7 @@ export const initTokenReservesByHelper = async (
tokenAddresses[symbol],
ZERO_ADDRESS, // Incentives Controller
`Aave variable debt bearing ${symbol}`,
`variableDebt${symbol}`
`variableDebt${symbol}`,
],
verify
);
@ -568,24 +489,24 @@ export const initTokenReservesByHelper = async (
treasuryAddress,
ZERO_ADDRESS,
`Aave interest bearing ${symbol}`,
`a${symbol}`
`a${symbol}`,
],
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],
@ -600,28 +521,29 @@ 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();
//reserveTokens.push();
deployedRates.push(strategyImpl);
reserveInitDecimals.push(decimals.toString());
reserveSymbols.push(symbol);
}
for (let i = 0; i < deployedATokens.length; i ++) {
for (let i = 0; i < deployedATokens.length; i++) {
initInputParams.push({
aTokenImpl: deployedATokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
stableDebtTokenImpl: deployedStableTokens[i],
variableDebtTokenImpl: deployedVariableTokens[i],
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: deployedRates[i],
@ -634,7 +556,8 @@ export const initTokenReservesByHelper = async (
variableDebtTokenName: `Aave variable debt bearing ${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${reserveSymbols[i]}`,
stableDebtTokenName: `Aave stable debt bearing ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`
stableDebtTokenSymbol: `stableDebt${reserveSymbols[i]}`,
params: '0x10'
});
}
@ -643,7 +566,7 @@ export const initTokenReservesByHelper = async (
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
await waitForTx(await addressProvider.setPoolAdmin(admin));
//await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
@ -656,10 +579,11 @@ export const initTokenReservesByHelper = async (
}
// 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();

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;
}
export type iAssetsWithoutETH<T> = Omit<iAssetBase<T>, 'ETH'>;
@ -234,6 +268,41 @@ export type iAavePoolAssets<T> = Pick<
| 'ENJ'
>;
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'>;
@ -262,20 +331,49 @@ 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',
}
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;
@ -290,7 +388,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;
@ -300,8 +408,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 {
@ -319,15 +438,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;
@ -351,11 +461,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>;
@ -370,12 +487,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;
}

113
markets/aave/commons.ts
View File

@ -1,37 +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(),
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',
@ -158,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',
@ -216,7 +233,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0xBc3f28Ccc21E9b5856E81E6372aFf57307E2E883',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[EthereumNetwork.ropsten]: {
[eEthereumNetwork.ropsten]: {
AAVE: ZERO_ADDRESS,
BAT: '0xafd8186c962daf599f171b8600f3e19af7b52c92',
BUSD: '0x0A32D96Ff131cd5c3E0E5AAB645BF009Eda61564',
@ -238,7 +255,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0x1d0052e4ae5b4ae4563cbac50edc3627ca0460d7',
USD: '0x8468b2bDCE073A157E560AA4D9CcF6dB1DB98507',
},
[EthereumNetwork.main]: {
[eEthereumNetwork.main]: {
AAVE: '0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012',
BAT: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
BUSD: '0x614715d2Af89E6EC99A233818275142cE88d1Cfd',
@ -260,7 +277,7 @@ export const CommonsConfig: ICommonConfiguration = {
ZRX: '0x2Da4983a622a8498bb1a21FaE9D8F6C664939962',
USD: '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419',
},
[EthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderlyMain]: {
AAVE: '0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012',
BAT: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
BUSD: '0x614715d2Af89E6EC99A233818275142cE88d1Cfd',
@ -287,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 {
@ -58,7 +58,7 @@ export const AaveConfig: IAaveConfiguration = {
[eEthereumNetwork.buidlerevm]: {},
[eEthereumNetwork.hardhat]: {},
[eEthereumNetwork.coverage]: {},
[EthereumNetwork.kovan]: {
[eEthereumNetwork.kovan]: {
AAVE: '0xB597cd8D3217ea6477232F9217fa70837ff667Af',
BAT: '0x2d12186Fbb9f9a8C28B3FfdD4c42920f8539D738',
BUSD: '0x4c6E1EFC12FDfD568186b7BAEc0A43fFfb4bCcCf',
@ -80,7 +80,7 @@ export const AaveConfig: IAaveConfiguration = {
YFI: '0xb7c325266ec274fEb1354021D27FA3E3379D840d',
ZRX: '0xD0d76886cF8D952ca26177EB7CfDf83bad08C00C',
},
[EthereumNetwork.ropsten]: {
[eEthereumNetwork.ropsten]: {
AAVE: '',
BAT: '0x85B24b3517E3aC7bf72a14516160541A60cFF19d',
BUSD: '0xFA6adcFf6A90c11f31Bc9bb59eC0a6efB38381C6',
@ -102,7 +102,7 @@ export const AaveConfig: IAaveConfiguration = {
YFI: ZERO_ADDRESS,
ZRX: '0x02d7055704EfF050323A2E5ee4ba05DB2A588959',
},
[EthereumNetwork.main]: {
[eEthereumNetwork.main]: {
AAVE: '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
BAT: '0x0d8775f648430679a709e98d2b0cb6250d2887ef',
BUSD: '0x4Fabb145d64652a948d72533023f6E7A623C7C53',
@ -124,7 +124,7 @@ export const AaveConfig: IAaveConfiguration = {
YFI: '0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e',
ZRX: '0xE41d2489571d322189246DaFA5ebDe1F4699F498',
},
[EthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderlyMain]: {
AAVE: '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
BAT: '0x0d8775f648430679a709e98d2b0cb6250d2887ef',
BUSD: '0x4Fabb145d64652a948d72533023f6E7A623C7C53',

91
markets/aave/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(),
}

155
markets/aave/reservesConfigs.ts
View File

@ -1,14 +1,19 @@
import BigNumber from 'bignumber.js';
import { oneRay } from '../../helpers/constants';
// 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 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',

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

@ -0,0 +1,332 @@
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: ZERO_ADDRESS,
UniAAVEWETH: ZERO_ADDRESS,
UniBATWETH: ZERO_ADDRESS,
UniDAIUSDC: ZERO_ADDRESS,
UniCRVWETH: ZERO_ADDRESS,
UniLINKWETH: ZERO_ADDRESS,
UniMKRWETH: ZERO_ADDRESS,
UniRENWETH: ZERO_ADDRESS,
UniSNXWETH: ZERO_ADDRESS,
UniUNIWETH: ZERO_ADDRESS,
UniUSDCWETH: ZERO_ADDRESS,
UniWBTCUSDC: ZERO_ADDRESS,
UniYFIWETH: ZERO_ADDRESS,
BptWBTCWETH: ZERO_ADDRESS,
BptBALWETH: ZERO_ADDRESS,
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[eEthereumNetwork.tenderlyMain]: {
USDT: '0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46',
WBTC: '0xdeb288F737066589598e9214E782fa5A8eD689e8',
USDC: '0x986b5E1e1755e3C2440e960477f25201B0a8bbD4',
DAI:'0x773616E4d11A78F511299002da57A0a94577F1f4',
UniDAIWETH: ZERO_ADDRESS,
UniWBTCWETH: ZERO_ADDRESS,
UniAAVEWETH: ZERO_ADDRESS,
UniBATWETH: ZERO_ADDRESS,
UniDAIUSDC: ZERO_ADDRESS,
UniCRVWETH: ZERO_ADDRESS,
UniLINKWETH: ZERO_ADDRESS,
UniMKRWETH: ZERO_ADDRESS,
UniRENWETH: ZERO_ADDRESS,
UniSNXWETH: ZERO_ADDRESS,
UniUNIWETH: ZERO_ADDRESS,
UniUSDCWETH: ZERO_ADDRESS,
UniWBTCUSDC: ZERO_ADDRESS,
UniYFIWETH: ZERO_ADDRESS,
BptWBTCWETH: ZERO_ADDRESS,
BptBALWETH: ZERO_ADDRESS,
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

25588
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

52
package.json
View File

@ -14,37 +14,47 @@
"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",
"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",
@ -119,7 +129,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);
});

8
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;
@ -81,6 +82,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(

41
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,32 @@ 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
);
let aaveOracle: AaveOracle;
if (notFalsyOrZeroAddress(aaveOracleAddress)) {
aaveOracle = await getAaveOracle(aaveOracleAddress);
await waitForTx(await aaveOracle.setAssetSources(tokens, aggregators));
} else {
aaveOracle = await deployAaveOracle(
[tokens, aggregators, fallbackOracleAddress, await getWethAddress(poolConfig)],
verify
);
}
const lendingRateOracle = notFalsyOrZeroAddress(lendingRateOracleAddress)
? await getLendingRateOracle(lendingRateOracleAddress)
: await deployLendingRateOracle(verify);
const { USD, ...tokensAddressesWithoutUsd } = tokensToWatch;
if (!lendingRateOracleAddress) {
await setInitialMarketRatesInRatesOracleByHelper(
lendingRateOracles,
tokensAddressesWithoutUsd,
lendingRateOracle,
admin
);
}
// 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,7 +53,7 @@ WRONG RESERVE ASSET SETUP:
poolAddress,
reserveAssetAddress,
treasuryAddress,
ZERO_ADDRESS,
ZERO_ADDRESS, // Incentives Controller
`Aave interest bearing ${symbol}`,
`a${symbol}`,
],
@ -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
);

11
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,15 +29,18 @@ 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 });
}

53
tasks/migrations/amm.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('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();
console.log('Tenderly UUID', postDeployHead);
}
console.log('\nFinished migrations');
printContracts();
});

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

@ -0,0 +1,50 @@
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();
console.log('Tenderly UUID', postDeployHead);
}
console.log('\nFinished migrations');
printContracts();
});

6
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;

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);

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

67
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,36 @@ 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,
},
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 +242,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 +285,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);

770
test-suites/test-aave/helpers/actions.ts Normal file
View File

@ -0,0 +1,770 @@
import BigNumber from 'bignumber.js';
import {
calcExpectedReserveDataAfterBorrow,
calcExpectedReserveDataAfterDeposit,
calcExpectedReserveDataAfterRepay,
calcExpectedReserveDataAfterStableRateRebalance,
calcExpectedReserveDataAfterSwapRateMode,
calcExpectedReserveDataAfterWithdraw,
calcExpectedUserDataAfterBorrow,
calcExpectedUserDataAfterDeposit,
calcExpectedUserDataAfterRepay,
calcExpectedUserDataAfterSetUseAsCollateral,
calcExpectedUserDataAfterStableRateRebalance,
calcExpectedUserDataAfterSwapRateMode,
calcExpectedUserDataAfterWithdraw,
} from './utils/calculations';
import { getReserveAddressFromSymbol, getReserveData, getUserData } from './utils/helpers';
import { convertToCurrencyDecimals } from '../../../helpers/contracts-helpers';
import {
getAToken,
getMintableERC20,
getStableDebtToken,
getVariableDebtToken,
} from '../../../helpers/contracts-getters';
import { MAX_UINT_AMOUNT, ONE_YEAR } from '../../../helpers/constants';
import { SignerWithAddress, TestEnv } from './make-suite';
import { advanceTimeAndBlock, DRE, timeLatest, waitForTx } from '../../../helpers/misc-utils';
import chai from 'chai';
import { ReserveData, UserReserveData } from './utils/interfaces';
import { ContractReceipt } from 'ethers';
import { AToken } from '../../../types/AToken';
import { RateMode, tEthereumAddress } from '../../../helpers/types';
const { expect } = chai;
const almostEqualOrEqual = function (
this: any,
expected: ReserveData | UserReserveData,
actual: ReserveData | UserReserveData
) {
const keys = Object.keys(actual);
keys.forEach((key) => {
if (
key === 'lastUpdateTimestamp' ||
key === 'marketStableRate' ||
key === 'symbol' ||
key === 'aTokenAddress' ||
key === 'decimals' ||
key === 'totalStableDebtLastUpdated'
) {
// skipping consistency check on accessory data
return;
}
this.assert(actual[key] != undefined, `Property ${key} is undefined in the actual data`);
expect(expected[key] != undefined, `Property ${key} is undefined in the expected data`);
if (expected[key] == null || actual[key] == null) {
console.log('Found a undefined value for Key ', key, ' value ', expected[key], actual[key]);
}
if (actual[key] instanceof BigNumber) {
const actualValue = (<BigNumber>actual[key]).decimalPlaces(0, BigNumber.ROUND_DOWN);
const expectedValue = (<BigNumber>expected[key]).decimalPlaces(0, BigNumber.ROUND_DOWN);
this.assert(
actualValue.eq(expectedValue) ||
actualValue.plus(1).eq(expectedValue) ||
actualValue.eq(expectedValue.plus(1)) ||
actualValue.plus(2).eq(expectedValue) ||
actualValue.eq(expectedValue.plus(2)) ||
actualValue.plus(3).eq(expectedValue) ||
actualValue.eq(expectedValue.plus(3)),
`expected #{act} to be almost equal or equal #{exp} for property ${key}`,
`expected #{act} to be almost equal or equal #{exp} for property ${key}`,
expectedValue.toFixed(0),
actualValue.toFixed(0)
);
} else {
this.assert(
actual[key] !== null &&
expected[key] !== null &&
actual[key].toString() === expected[key].toString(),
`expected #{act} to be equal #{exp} for property ${key}`,
`expected #{act} to be equal #{exp} for property ${key}`,
expected[key],
actual[key]
);
}
});
};
chai.use(function (chai: any, utils: any) {
chai.Assertion.overwriteMethod('almostEqualOrEqual', function (original: any) {
return function (this: any, expected: ReserveData | UserReserveData) {
const actual = (expected as ReserveData)
? <ReserveData>this._obj
: <UserReserveData>this._obj;
almostEqualOrEqual.apply(this, [expected, actual]);
};
});
});
interface ActionsConfig {
skipIntegrityCheck: boolean;
}
export const configuration: ActionsConfig = <ActionsConfig>{};
export const mint = async (reserveSymbol: string, amount: string, user: SignerWithAddress) => {
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const token = await getMintableERC20(reserve);
await waitForTx(
await token.connect(user.signer).mint(await convertToCurrencyDecimals(reserve, amount))
);
};
export const approve = async (reserveSymbol: string, user: SignerWithAddress, testEnv: TestEnv) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const token = await getMintableERC20(reserve);
await waitForTx(
await token.connect(user.signer).approve(pool.address, '100000000000000000000000000000')
);
};
export const deposit = async (
reserveSymbol: string,
amount: string,
sender: SignerWithAddress,
onBehalfOf: tEthereumAddress,
sendValue: string,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const amountToDeposit = await convertToCurrencyDecimals(reserve, amount);
const txOptions: any = {};
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
onBehalfOf,
testEnv,
sender.address
);
if (sendValue) {
txOptions.value = await convertToCurrencyDecimals(reserve, sendValue);
}
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool
.connect(sender.signer)
.deposit(reserve, amountToDeposit, onBehalfOf, '0', txOptions)
);
const {
reserveData: reserveDataAfter,
userData: userDataAfter,
timestamp,
} = await getContractsData(reserve, onBehalfOf, testEnv, sender.address);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
const expectedReserveData = calcExpectedReserveDataAfterDeposit(
amountToDeposit.toString(),
reserveDataBefore,
txTimestamp
);
const expectedUserReserveData = calcExpectedUserDataAfterDeposit(
amountToDeposit.toString(),
reserveDataBefore,
expectedReserveData,
userDataBefore,
txTimestamp,
timestamp,
txCost
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserReserveData);
// truffleAssert.eventEmitted(txResult, "Deposit", (ev: any) => {
// const {_reserve, _user, _amount} = ev;
// return (
// _reserve === reserve &&
// _user === user &&
// new BigNumber(_amount).isEqualTo(new BigNumber(amountToDeposit))
// );
// });
} else if (expectedResult === 'revert') {
await expect(
pool.connect(sender.signer).deposit(reserve, amountToDeposit, onBehalfOf, '0', txOptions),
revertMessage
).to.be.reverted;
}
};
export const withdraw = async (
reserveSymbol: string,
amount: string,
user: SignerWithAddress,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const {
aTokenInstance,
reserve,
userData: userDataBefore,
reserveData: reserveDataBefore,
} = await getDataBeforeAction(reserveSymbol, user.address, testEnv);
let amountToWithdraw = '0';
if (amount !== '-1') {
amountToWithdraw = (await convertToCurrencyDecimals(reserve, amount)).toString();
} else {
amountToWithdraw = MAX_UINT_AMOUNT;
}
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool.connect(user.signer).withdraw(reserve, amountToWithdraw, user.address)
);
const {
reserveData: reserveDataAfter,
userData: userDataAfter,
timestamp,
} = await getContractsData(reserve, user.address, testEnv);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
const expectedReserveData = calcExpectedReserveDataAfterWithdraw(
amountToWithdraw,
reserveDataBefore,
userDataBefore,
txTimestamp
);
const expectedUserData = calcExpectedUserDataAfterWithdraw(
amountToWithdraw,
reserveDataBefore,
expectedReserveData,
userDataBefore,
txTimestamp,
timestamp,
txCost
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserData);
// truffleAssert.eventEmitted(txResult, "Redeem", (ev: any) => {
// const {_from, _value} = ev;
// return (
// _from === user && new BigNumber(_value).isEqualTo(actualAmountRedeemed)
// );
// });
} else if (expectedResult === 'revert') {
await expect(
pool.connect(user.signer).withdraw(reserve, amountToWithdraw, user.address),
revertMessage
).to.be.reverted;
}
};
export const delegateBorrowAllowance = async (
reserve: string,
amount: string,
interestRateMode: string,
user: SignerWithAddress,
receiver: tEthereumAddress,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserveAddress: tEthereumAddress = await getReserveAddressFromSymbol(reserve);
const amountToDelegate: string = await (
await convertToCurrencyDecimals(reserveAddress, amount)
).toString();
const reserveData = await pool.getReserveData(reserveAddress);
const debtToken =
interestRateMode === '1'
? await getStableDebtToken(reserveData.stableDebtTokenAddress)
: await getVariableDebtToken(reserveData.variableDebtTokenAddress);
const delegateAllowancePromise = debtToken
.connect(user.signer)
.approveDelegation(receiver, amountToDelegate);
if (expectedResult === 'revert' && revertMessage) {
await expect(delegateAllowancePromise, revertMessage).to.be.revertedWith(revertMessage);
return;
} else {
await waitForTx(await delegateAllowancePromise);
const allowance = await debtToken.borrowAllowance(user.address, receiver);
expect(allowance.toString()).to.be.equal(
amountToDelegate,
'borrowAllowance is set incorrectly'
);
}
};
export const borrow = async (
reserveSymbol: string,
amount: string,
interestRateMode: string,
user: SignerWithAddress,
onBehalfOf: tEthereumAddress,
timeTravel: string,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
onBehalfOf,
testEnv,
user.address
);
const amountToBorrow = await convertToCurrencyDecimals(reserve, amount);
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool
.connect(user.signer)
.borrow(reserve, amountToBorrow, interestRateMode, '0', onBehalfOf)
);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
if (timeTravel) {
const secondsToTravel = new BigNumber(timeTravel).multipliedBy(ONE_YEAR).div(365).toNumber();
await advanceTimeAndBlock(secondsToTravel);
}
const {
reserveData: reserveDataAfter,
userData: userDataAfter,
timestamp,
} = await getContractsData(reserve, onBehalfOf, testEnv, user.address);
const expectedReserveData = calcExpectedReserveDataAfterBorrow(
amountToBorrow.toString(),
interestRateMode,
reserveDataBefore,
userDataBefore,
txTimestamp,
timestamp
);
const expectedUserData = calcExpectedUserDataAfterBorrow(
amountToBorrow.toString(),
interestRateMode,
reserveDataBefore,
expectedReserveData,
userDataBefore,
txTimestamp,
timestamp
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserData);
// truffleAssert.eventEmitted(txResult, "Borrow", (ev: any) => {
// const {
// _reserve,
// _user,
// _amount,
// _borrowRateMode,
// _borrowRate,
// _originationFee,
// } = ev;
// return (
// _reserve.toLowerCase() === reserve.toLowerCase() &&
// _user.toLowerCase() === user.toLowerCase() &&
// new BigNumber(_amount).eq(amountToBorrow) &&
// new BigNumber(_borrowRateMode).eq(expectedUserData.borrowRateMode) &&
// new BigNumber(_borrowRate).eq(expectedUserData.borrowRate) &&
// new BigNumber(_originationFee).eq(
// expectedUserData.originationFee.minus(userDataBefore.originationFee)
// )
// );
// });
} else if (expectedResult === 'revert') {
await expect(
pool.connect(user.signer).borrow(reserve, amountToBorrow, interestRateMode, '0', onBehalfOf),
revertMessage
).to.be.reverted;
}
};
export const repay = async (
reserveSymbol: string,
amount: string,
rateMode: string,
user: SignerWithAddress,
onBehalfOf: SignerWithAddress,
sendValue: string,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
onBehalfOf.address,
testEnv
);
let amountToRepay = '0';
if (amount !== '-1') {
amountToRepay = (await convertToCurrencyDecimals(reserve, amount)).toString();
} else {
amountToRepay = MAX_UINT_AMOUNT;
}
amountToRepay = '0x' + new BigNumber(amountToRepay).toString(16);
const txOptions: any = {};
if (sendValue) {
const valueToSend = await convertToCurrencyDecimals(reserve, sendValue);
txOptions.value = '0x' + new BigNumber(valueToSend.toString()).toString(16);
}
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool
.connect(user.signer)
.repay(reserve, amountToRepay, rateMode, onBehalfOf.address, txOptions)
);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
const {
reserveData: reserveDataAfter,
userData: userDataAfter,
timestamp,
} = await getContractsData(reserve, onBehalfOf.address, testEnv);
const expectedReserveData = calcExpectedReserveDataAfterRepay(
amountToRepay,
<RateMode>rateMode,
reserveDataBefore,
userDataBefore,
txTimestamp,
timestamp
);
const expectedUserData = calcExpectedUserDataAfterRepay(
amountToRepay,
<RateMode>rateMode,
reserveDataBefore,
expectedReserveData,
userDataBefore,
user.address,
onBehalfOf.address,
txTimestamp,
timestamp
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserData);
// truffleAssert.eventEmitted(txResult, "Repay", (ev: any) => {
// const {_reserve, _user, _repayer} = ev;
// return (
// _reserve.toLowerCase() === reserve.toLowerCase() &&
// _user.toLowerCase() === onBehalfOf.toLowerCase() &&
// _repayer.toLowerCase() === user.toLowerCase()
// );
// });
} else if (expectedResult === 'revert') {
await expect(
pool
.connect(user.signer)
.repay(reserve, amountToRepay, rateMode, onBehalfOf.address, txOptions),
revertMessage
).to.be.reverted;
}
};
export const setUseAsCollateral = async (
reserveSymbol: string,
user: SignerWithAddress,
useAsCollateral: string,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
user.address,
testEnv
);
const useAsCollateralBool = useAsCollateral.toLowerCase() === 'true';
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool.connect(user.signer).setUserUseReserveAsCollateral(reserve, useAsCollateralBool)
);
const { txCost } = await getTxCostAndTimestamp(txResult);
const { userData: userDataAfter } = await getContractsData(reserve, user.address, testEnv);
const expectedUserData = calcExpectedUserDataAfterSetUseAsCollateral(
useAsCollateral.toLocaleLowerCase() === 'true',
reserveDataBefore,
userDataBefore,
txCost
);
expectEqual(userDataAfter, expectedUserData);
// if (useAsCollateralBool) {
// truffleAssert.eventEmitted(txResult, 'ReserveUsedAsCollateralEnabled', (ev: any) => {
// const {_reserve, _user} = ev;
// return _reserve === reserve && _user === user;
// });
// } else {
// truffleAssert.eventEmitted(txResult, 'ReserveUsedAsCollateralDisabled', (ev: any) => {
// const {_reserve, _user} = ev;
// return _reserve === reserve && _user === user;
// });
// }
} else if (expectedResult === 'revert') {
await expect(
pool.connect(user.signer).setUserUseReserveAsCollateral(reserve, useAsCollateralBool),
revertMessage
).to.be.reverted;
}
};
export const swapBorrowRateMode = async (
reserveSymbol: string,
user: SignerWithAddress,
rateMode: string,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
user.address,
testEnv
);
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool.connect(user.signer).swapBorrowRateMode(reserve, rateMode)
);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
const { reserveData: reserveDataAfter, userData: userDataAfter } = await getContractsData(
reserve,
user.address,
testEnv
);
const expectedReserveData = calcExpectedReserveDataAfterSwapRateMode(
reserveDataBefore,
userDataBefore,
rateMode,
txTimestamp
);
const expectedUserData = calcExpectedUserDataAfterSwapRateMode(
reserveDataBefore,
expectedReserveData,
userDataBefore,
rateMode,
txCost,
txTimestamp
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserData);
// truffleAssert.eventEmitted(txResult, "Swap", (ev: any) => {
// const {_user, _reserve, _newRateMode, _newRate} = ev;
// return (
// _user === user &&
// _reserve == reserve &&
// new BigNumber(_newRateMode).eq(expectedUserData.borrowRateMode) &&
// new BigNumber(_newRate).eq(expectedUserData.borrowRate)
// );
// });
} else if (expectedResult === 'revert') {
await expect(pool.connect(user.signer).swapBorrowRateMode(reserve, rateMode), revertMessage).to
.be.reverted;
}
};
export const rebalanceStableBorrowRate = async (
reserveSymbol: string,
user: SignerWithAddress,
target: SignerWithAddress,
expectedResult: string,
testEnv: TestEnv,
revertMessage?: string
) => {
const { pool } = testEnv;
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData: reserveDataBefore, userData: userDataBefore } = await getContractsData(
reserve,
target.address,
testEnv
);
if (expectedResult === 'success') {
const txResult = await waitForTx(
await pool.connect(user.signer).rebalanceStableBorrowRate(reserve, target.address)
);
const { txCost, txTimestamp } = await getTxCostAndTimestamp(txResult);
const { reserveData: reserveDataAfter, userData: userDataAfter } = await getContractsData(
reserve,
target.address,
testEnv
);
const expectedReserveData = calcExpectedReserveDataAfterStableRateRebalance(
reserveDataBefore,
userDataBefore,
txTimestamp
);
const expectedUserData = calcExpectedUserDataAfterStableRateRebalance(
reserveDataBefore,
expectedReserveData,
userDataBefore,
txCost,
txTimestamp
);
expectEqual(reserveDataAfter, expectedReserveData);
expectEqual(userDataAfter, expectedUserData);
// truffleAssert.eventEmitted(txResult, 'RebalanceStableBorrowRate', (ev: any) => {
// const {_user, _reserve, _newStableRate} = ev;
// return (
// _user.toLowerCase() === target.toLowerCase() &&
// _reserve.toLowerCase() === reserve.toLowerCase() &&
// new BigNumber(_newStableRate).eq(expectedUserData.borrowRate)
// );
// });
} else if (expectedResult === 'revert') {
await expect(
pool.connect(user.signer).rebalanceStableBorrowRate(reserve, target.address),
revertMessage
).to.be.reverted;
}
};
const expectEqual = (
actual: UserReserveData | ReserveData,
expected: UserReserveData | ReserveData
) => {
if (!configuration.skipIntegrityCheck) {
// @ts-ignore
expect(actual).to.be.almostEqualOrEqual(expected);
}
};
interface ActionData {
reserve: string;
reserveData: ReserveData;
userData: UserReserveData;
aTokenInstance: AToken;
}
const getDataBeforeAction = async (
reserveSymbol: string,
user: tEthereumAddress,
testEnv: TestEnv
): Promise<ActionData> => {
const reserve = await getReserveAddressFromSymbol(reserveSymbol);
const { reserveData, userData } = await getContractsData(reserve, user, testEnv);
const aTokenInstance = await getAToken(reserveData.aTokenAddress);
return {
reserve,
reserveData,
userData,
aTokenInstance,
};
};
export const getTxCostAndTimestamp = async (tx: ContractReceipt) => {
if (!tx.blockNumber || !tx.transactionHash || !tx.cumulativeGasUsed) {
throw new Error('No tx blocknumber');
}
const txTimestamp = new BigNumber((await DRE.ethers.provider.getBlock(tx.blockNumber)).timestamp);
const txInfo = await DRE.ethers.provider.getTransaction(tx.transactionHash);
const txCost = new BigNumber(tx.cumulativeGasUsed.toString()).multipliedBy(
txInfo.gasPrice.toString()
);
return { txCost, txTimestamp };
};
export const getContractsData = async (
reserve: string,
user: string,
testEnv: TestEnv,
sender?: string
) => {
const { pool, helpersContract } = testEnv;
const [userData, reserveData, timestamp] = await Promise.all([
getUserData(pool, helpersContract, reserve, user, sender || user),
getReserveData(helpersContract, reserve),
timeLatest(),
]);
return {
reserveData,
userData,
timestamp: new BigNumber(timestamp),
};
};

0
test/helpers/almost-equal.ts → test-suites/test-aave/helpers/almost-equal.ts
View File

40
test/helpers/make-suite.ts → test-suites/test-aave/helpers/make-suite.ts
View File

@ -1,4 +1,4 @@
import { evmRevert, evmSnapshot, DRE } from '../../helpers/misc-utils';
import { evmRevert, evmSnapshot, DRE } from '../../../helpers/misc-utils';
import { Signer } from 'ethers';
import {
getLendingPool,
@ -14,32 +14,32 @@ import {
getUniswapLiquiditySwapAdapter,
getUniswapRepayAdapter,
getFlashLiquidationAdapter,
} from '../../helpers/contracts-getters';
import { eEthereumNetwork, tEthereumAddress } from '../../helpers/types';
import { LendingPool } from '../../types/LendingPool';
import { AaveProtocolDataProvider } from '../../types/AaveProtocolDataProvider';
import { MintableERC20 } from '../../types/MintableERC20';
import { AToken } from '../../types/AToken';
import { LendingPoolConfigurator } from '../../types/LendingPoolConfigurator';
} from '../../../helpers/contracts-getters';
import { eEthereumNetwork, tEthereumAddress } from '../../../helpers/types';
import { LendingPool } from '../../../types/LendingPool';
import { AaveProtocolDataProvider } from '../../../types/AaveProtocolDataProvider';
import { MintableERC20 } from '../../../types/MintableERC20';
import { AToken } from '../../../types/AToken';
import { LendingPoolConfigurator } from '../../../types/LendingPoolConfigurator';
import chai from 'chai';
// @ts-ignore
import bignumberChai from 'chai-bignumber';
import { almostEqual } from './almost-equal';
import { PriceOracle } from '../../types/PriceOracle';
import { LendingPoolAddressesProvider } from '../../types/LendingPoolAddressesProvider';
import { LendingPoolAddressesProviderRegistry } from '../../types/LendingPoolAddressesProviderRegistry';
import { getEthersSigners } from '../../helpers/contracts-helpers';
import { UniswapLiquiditySwapAdapter } from '../../types/UniswapLiquiditySwapAdapter';
import { UniswapRepayAdapter } from '../../types/UniswapRepayAdapter';
import { getParamPerNetwork } from '../../helpers/contracts-helpers';
import { WETH9Mocked } from '../../types/WETH9Mocked';
import { WETHGateway } from '../../types/WETHGateway';
import { PriceOracle } from '../../../types/PriceOracle';
import { LendingPoolAddressesProvider } from '../../../types/LendingPoolAddressesProvider';
import { LendingPoolAddressesProviderRegistry } from '../../../types/LendingPoolAddressesProviderRegistry';
import { getEthersSigners } from '../../../helpers/contracts-helpers';
import { UniswapLiquiditySwapAdapter } from '../../../types/UniswapLiquiditySwapAdapter';
import { UniswapRepayAdapter } from '../../../types/UniswapRepayAdapter';
import { getParamPerNetwork } from '../../../helpers/contracts-helpers';
import { WETH9Mocked } from '../../../types/WETH9Mocked';
import { WETHGateway } from '../../../types/WETHGateway';
import { solidity } from 'ethereum-waffle';
import { AaveConfig } from '../../markets/aave';
import { FlashLiquidationAdapter } from '../../types';
import { AaveConfig } from '../../../markets/aave';
import { FlashLiquidationAdapter } from '../../../types';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { usingTenderly } from '../../helpers/tenderly-utils';
import { usingTenderly } from '../../../helpers/tenderly-utils';
chai.use(bignumberChai());
chai.use(almostEqual());

2
test/helpers/scenario-engine.ts → test-suites/test-aave/helpers/scenario-engine.ts
View File

@ -11,7 +11,7 @@ import {
rebalanceStableBorrowRate,
delegateBorrowAllowance,
} from './actions';
import { RateMode } from '../../helpers/types';
import { RateMode } from '../../../helpers/types';
export interface Action {
name: string;

2
test/helpers/scenarios/borrow-negatives.json → test-suites/test-aave/helpers/scenarios/borrow-negatives.json
View File

@ -52,7 +52,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},
@ -121,7 +120,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},

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

@ -88,7 +88,7 @@
]
},
{
"description": "User 1 repays the half of the DAI borrow after one year",
"description": "User 1 repays half of the DAI borrow after one year",
"actions": [
{
"name": "mint",
@ -170,7 +170,7 @@
]
},
{
"description": "User 1 deposits 1000 DAI, user 2 tries to borrow 1000 DAI at a stable rate without any collateral (revert expected)",
"description": "User 1 deposits 1000 DAI, user 2 tries to borrow 1000 DAI at a stable rate without any collateral (revert expected) User 1 withdrawws",
"actions": [
{
"name": "mint",
@ -270,7 +270,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},
@ -308,7 +307,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "2"
},
@ -346,7 +344,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "3"
},
@ -384,7 +381,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "4"
},
@ -578,7 +574,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "2",
"user": "1"
},

27
test/helpers/scenarios/borrow-repay-variable.json → test-suites/test-aave/helpers/scenarios/borrow-repay-variable.json
View File

@ -83,7 +83,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},
@ -205,7 +204,6 @@
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "1"
},
@ -237,7 +235,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "0.001",
"user": "2"
},
@ -246,7 +243,7 @@
]
},
{
"description": "User 0 deposits 1 WETH, user 1 deposits 100 LINK as collateral and borrows 0.5 ETH at variable rate",
"description": "User 0 deposits 1 WETH, user 1 deposits 100 LINK as collateral and borrows 0.5 WETH at variable rate",
"actions": [
{
"name": "mint",
@ -269,7 +266,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "0"
},
@ -306,7 +302,6 @@
"name": "borrow",
"args": {
"reserve": "WETH",
"amount": "0.5",
"borrowRateMode": "variable",
"user": "1",
@ -317,7 +312,7 @@
]
},
{
"description": "User 1 tries to repay 0 ETH",
"description": "User 1 tries to repay 0 WETH",
"actions": [
{
"name": "repay",
@ -340,7 +335,6 @@
"name": "repay",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "2",
"borrowRateMode": "variable",
@ -375,7 +369,6 @@
"name": "repay",
"args": {
"reserve": "WETH",
"amount": "0.2",
"user": "3",
"borrowRateMode": "variable",
@ -409,7 +402,6 @@
"name": "repay",
"args": {
"reserve": "WETH",
"amount": "-1",
"borrowRateMode": "variable",
"user": "1",
@ -426,7 +418,6 @@
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "0"
},
@ -530,7 +521,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},
@ -670,7 +660,7 @@
]
},
{
"description": "user 3 deposits 0.1 ETH collateral to borrow 100 DAI; 0.1 ETH is not enough to borrow 100 DAI (revert expected)",
"description": "user 3 deposits 0.1 WETH collateral to borrow 100 DAI; 0.1 WETH is not enough to borrow 100 DAI (revert expected)",
"actions": [
{
"name": "mint",
@ -693,7 +683,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "0.1",
"user": "3"
},
@ -713,13 +702,12 @@
]
},
{
"description": "user 3 withdraws the 0.1 ETH",
"description": "user 3 withdraws the 0.1 WETH",
"actions": [
{
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "3"
},
@ -770,7 +758,7 @@
]
},
{
"description": "user 3 deposits 0.1 ETH collateral to borrow 100 USDC; 0.1 ETH is not enough to borrow 100 USDC (revert expected)",
"description": "user 3 deposits 0.1 WETH collateral to borrow 100 USDC; 0.1 WETH is not enough to borrow 100 USDC (revert expected)",
"actions": [
{
"name": "mint",
@ -793,7 +781,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "0.1",
"user": "3"
},
@ -813,13 +800,12 @@
]
},
{
"description": "user 3 withdraws the 0.1 ETH",
"description": "user 3 withdraws the 0.1 WETH",
"actions": [
{
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "3"
},
@ -877,7 +863,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "2",
"user": "6"
},

2
test/helpers/scenarios/credit-delegation.json → test-suites/test-aave/helpers/scenarios/credit-delegation.json
View File

@ -3,7 +3,7 @@
"description": "Test cases for the credit delegation related functions.",
"stories": [
{
"description": "User 0 deposits 1000 DAI, user 0 delegates borrowing of 1 WETH on variable to user 4, user 4 borrows 1 WETH variable on behalf of user 0",
"description": "User 3 deposits 1000 WETH. User 0 deposits 1000 DAI, user 0 delegates borrowing of 1 WETH on variable to user 4, user 4 borrows 1 WETH variable on behalf of user 0",
"actions": [
{
"name": "mint",

5
test/helpers/scenarios/deposit.json → test-suites/test-aave/helpers/scenarios/deposit.json
View File

@ -34,7 +34,7 @@
]
},
{
"description": "User 1 deposits 1000 DAI after user 1",
"description": "User 1 deposits 1000 DAI after user 0",
"actions": [
{
"name": "mint",
@ -150,7 +150,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "0"
},
@ -191,7 +190,7 @@
]
},
{
"description": "User 1 deposits 0 ETH (revert expected)",
"description": "User 1 deposits 0 WETH (revert expected)",
"actions": [
{
"name": "mint",

14
test/helpers/scenarios/rebalance-stable-rate.json → test-suites/test-aave/helpers/scenarios/rebalance-stable-rate.json
View File

@ -10,8 +10,7 @@
"args": {
"reserve": "USDC",
"user": "0",
"target": "1",
"borrowRateMode": "variable"
"target": "1"
},
"expected": "revert",
"revertMessage": "User does not have any stable rate loan for this reserve"
@ -19,7 +18,7 @@
]
},
{
"description": "User 0 deposits 1000 USDC, user 1 deposits 5 ETH, borrows 250 USDC at a stable rate, user 0 rebalances user 1 (revert expected)",
"description": "User 0 deposits 1000 USDC, user 1 deposits 7 WETH, borrows 250 USDC at a stable rate, user 0 rebalances user 1 (revert expected)",
"actions": [
{
"name": "mint",
@ -68,7 +67,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "7",
"user": "1"
},
@ -97,7 +95,7 @@
]
},
{
"description": "User 1 borrows another 200 at stable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"description": "User 1 borrows another 200 at variable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"actions": [
{
"name": "borrow",
@ -122,7 +120,7 @@
]
},
{
"description": "User 1 borrows another 200 at stable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"description": "User 1 borrows another 200 at variable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"actions": [
{
"name": "borrow",
@ -147,7 +145,7 @@
]
},
{
"description": "User 1 borrows another 100 at stable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"description": "User 1 borrows another 100 at variable, user 0 tries to rebalance but the conditions are not met (revert expected)",
"actions": [
{
"name": "borrow",
@ -173,7 +171,7 @@
},
{
"description": "User 0 borrows the remaining USDC (usage ratio = 100%). User 0 rebalances user 1",
"description": "User 1 borrows the remaining USDC (usage ratio = 100%) at variable. User 0 rebalances user 1",
"actions": [
{
"name": "borrow",

11
test/helpers/scenarios/set-use-as-collateral.json → test-suites/test-aave/helpers/scenarios/set-use-as-collateral.json
View File

@ -66,7 +66,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "2",
"user": "1"
},
@ -76,7 +75,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "WETH",
"user": "1",
"useAsCollateral": "false"
},
@ -126,7 +124,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "WETH",
"user": "1",
"useAsCollateral": "false"
},
@ -136,7 +133,7 @@
]
},
{
"description": "User 1 Deposits 1000 AAVE, disables WETH as collateral. Should revert as 1000 AAVE are not enough to cover the debt (revert expected)",
"description": "User 1 Deposits 10 AAVE, disables WETH as collateral. Should revert as 10 AAVE are not enough to cover the debt (revert expected)",
"actions": [
{
"name": "mint",
@ -159,7 +156,6 @@
"name": "deposit",
"args": {
"reserve": "AAVE",
"amount": "10",
"user": "1"
},
@ -169,7 +165,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "WETH",
"user": "1",
"useAsCollateral": "false"
},
@ -193,7 +188,6 @@
"name": "deposit",
"args": {
"reserve": "AAVE",
"amount": "640",
"user": "1"
},
@ -203,7 +197,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "WETH",
"user": "1",
"useAsCollateral": "false"
},
@ -218,7 +211,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "AAVE",
"user": "1",
"useAsCollateral": "false"
},
@ -233,7 +225,6 @@
"name": "setUseAsCollateral",
"args": {
"reserve": "WETH",
"user": "1",
"useAsCollateral": "true"
},

3
test/helpers/scenarios/swap-rate-mode.json → test-suites/test-aave/helpers/scenarios/swap-rate-mode.json
View File

@ -33,7 +33,7 @@
]
},
{
"description": "User 0 deposits 1000 DAI, user 1 deposits 2 ETH as collateral, borrows 100 DAI at variable rate and swaps to stable after one year",
"description": "User 0 deposits 1000 DAI, user 1 deposits 2 WETH as collateral, borrows 100 DAI at variable rate and swaps to stable after one year",
"actions": [
{
"name": "mint",
@ -82,7 +82,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "2",
"user": "1"
},

2
test/helpers/scenarios/withdraw-negatives.json → test-suites/test-aave/helpers/scenarios/withdraw-negatives.json
View File

@ -83,7 +83,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},
@ -103,7 +102,6 @@
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "1"
},

25
test/helpers/scenarios/withdraw.json → test-suites/test-aave/helpers/scenarios/withdraw.json
View File

@ -144,7 +144,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "0"
},
@ -153,13 +152,12 @@
]
},
{
"description": "User 0 withdraws half of the deposited ETH",
"description": "User 0 withdraws half of the deposited WETH",
"actions": [
{
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "0.5",
"user": "0"
},
@ -168,13 +166,12 @@
]
},
{
"description": "User 0 withdraws remaining half of the deposited ETH",
"description": "User 0 withdraws remaining half of the deposited WETH",
"actions": [
{
"name": "withdraw",
"args": {
"reserve": "WETH",
"amount": "-1",
"user": "0"
},
@ -243,23 +240,6 @@
{
"description": "Users 0 deposits 1000 DAI, user 1 Deposit 1000 USDC and 1 WETH, borrows 100 DAI. User 1 tries to withdraw all the USDC",
"actions": [
{
"name": "mint",
"args": {
"reserve": "DAI",
"amount": "1000",
"user": "1"
},
"expected": "success"
},
{
"name": "approve",
"args": {
"reserve": "DAI",
"user": "1"
},
"expected": "success"
},
{
"name": "deposit",
"args": {
@ -316,7 +296,6 @@
"name": "deposit",
"args": {
"reserve": "WETH",
"amount": "1",
"user": "1"
},

23
test/helpers/utils/calculations.ts → test-suites/test-aave/helpers/utils/calculations.ts
View File

@ -1,13 +1,14 @@
import BigNumber from 'bignumber.js';
import { ONE_YEAR, RAY, MAX_UINT_AMOUNT, PERCENTAGE_FACTOR } from '../../../helpers/constants';
import { ONE_YEAR, RAY, MAX_UINT_AMOUNT, PERCENTAGE_FACTOR } from '../../../../helpers/constants';
import {
IReserveParams,
iAavePoolAssets,
RateMode,
tEthereumAddress,
} from '../../../helpers/types';
} from '../../../../helpers/types';
import './math';
import { ReserveData, UserReserveData } from './interfaces';
import { expect } from 'chai';
export const strToBN = (amount: string): BigNumber => new BigNumber(amount);
@ -1243,29 +1244,29 @@ export const calcExpectedInterestRates = (
];
let stableBorrowRate: BigNumber = marketStableRate;
let variableBorrowRate: BigNumber = new BigNumber(reserveConfiguration.baseVariableBorrowRate);
let variableBorrowRate: BigNumber = new BigNumber(reserveConfiguration.strategy.baseVariableBorrowRate);
const optimalRate = new BigNumber(reserveConfiguration.optimalUtilizationRate);
const optimalRate = new BigNumber(reserveConfiguration.strategy.optimalUtilizationRate);
const excessRate = new BigNumber(RAY).minus(optimalRate);
if (utilizationRate.gt(optimalRate)) {
const excessUtilizationRateRatio = utilizationRate
.minus(reserveConfiguration.optimalUtilizationRate)
.minus(reserveConfiguration.strategy.optimalUtilizationRate)
.rayDiv(excessRate);
stableBorrowRate = stableBorrowRate
.plus(reserveConfiguration.stableRateSlope1)
.plus(reserveConfiguration.strategy.stableRateSlope1)
.plus(
new BigNumber(reserveConfiguration.stableRateSlope2).rayMul(excessUtilizationRateRatio)
new BigNumber(reserveConfiguration.strategy.stableRateSlope2).rayMul(excessUtilizationRateRatio)
);
variableBorrowRate = variableBorrowRate
.plus(reserveConfiguration.variableRateSlope1)
.plus(reserveConfiguration.strategy.variableRateSlope1)
.plus(
new BigNumber(reserveConfiguration.variableRateSlope2).rayMul(excessUtilizationRateRatio)
new BigNumber(reserveConfiguration.strategy.variableRateSlope2).rayMul(excessUtilizationRateRatio)
);
} else {
stableBorrowRate = stableBorrowRate.plus(
new BigNumber(reserveConfiguration.stableRateSlope1).rayMul(
new BigNumber(reserveConfiguration.strategy.stableRateSlope1).rayMul(
utilizationRate.rayDiv(new BigNumber(optimalRate))
)
);
@ -1273,7 +1274,7 @@ export const calcExpectedInterestRates = (
variableBorrowRate = variableBorrowRate.plus(
utilizationRate
.rayDiv(optimalRate)
.rayMul(new BigNumber(reserveConfiguration.variableRateSlope1))
.rayMul(new BigNumber(reserveConfiguration.strategy.variableRateSlope1))
);
}

10
test/helpers/utils/helpers.ts → test-suites/test-aave/helpers/utils/helpers.ts
View File

@ -1,4 +1,4 @@
import { LendingPool } from '../../../types/LendingPool';
import { LendingPool } from '../../../../types/LendingPool';
import { ReserveData, UserReserveData } from './interfaces';
import {
getLendingRateOracle,
@ -7,11 +7,11 @@ import {
getAToken,
getStableDebtToken,
getVariableDebtToken,
} from '../../../helpers/contracts-getters';
import { tEthereumAddress } from '../../../helpers/types';
} from '../../../../helpers/contracts-getters';
import { tEthereumAddress } from '../../../../helpers/types';
import BigNumber from 'bignumber.js';
import { getDb, DRE } from '../../../helpers/misc-utils';
import { AaveProtocolDataProvider } from '../../../types/AaveProtocolDataProvider';
import { getDb, DRE } from '../../../../helpers/misc-utils';
import { AaveProtocolDataProvider } from '../../../../types/AaveProtocolDataProvider';
export const getReserveData = async (
helper: AaveProtocolDataProvider,

0
test/helpers/utils/interfaces/index.ts → test-suites/test-aave/helpers/utils/interfaces/index.ts
View File

2
test/helpers/utils/math.ts → test-suites/test-aave/helpers/utils/math.ts
View File

@ -7,7 +7,7 @@ import {
WAD_RAY_RATIO,
HALF_PERCENTAGE,
PERCENTAGE_FACTOR,
} from '../../../helpers/constants';
} from '../../../../helpers/constants';
declare module 'bignumber.js' {
interface BigNumber {

10
test/lending-pool-addresses-provider.spec.ts → test-suites/test-aave/lending-pool-addresses-provider.spec.ts
View File

@ -1,11 +1,11 @@
import { expect } from 'chai';
import { createRandomAddress } from '../helpers/misc-utils';
import { createRandomAddress } from '../../helpers/misc-utils';
import { makeSuite, TestEnv } from './helpers/make-suite';
import { ProtocolErrors } from '../helpers/types';
import { ProtocolErrors } from '../../helpers/types';
import { ethers } from 'ethers';
import { ZERO_ADDRESS } from '../helpers/constants';
import { waitForTx } from '../helpers/misc-utils';
import { deployLendingPool } from '../helpers/contracts-deployments';
import { ZERO_ADDRESS } from '../../helpers/constants';
import { waitForTx } from '../../helpers/misc-utils';
import { deployLendingPool } from '../../helpers/contracts-deployments';
const { utils } = ethers;

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

@ -1,10 +1,10 @@
import BigNumber from 'bignumber.js';
import { DRE } from '../helpers/misc-utils';
import { APPROVAL_AMOUNT_LENDING_POOL, oneEther } from '../helpers/constants';
import { convertToCurrencyDecimals } from '../helpers/contracts-helpers';
import { DRE } from '../../helpers/misc-utils';
import { APPROVAL_AMOUNT_LENDING_POOL, oneEther } from '../../helpers/constants';
import { convertToCurrencyDecimals } from '../../helpers/contracts-helpers';
import { makeSuite } from './helpers/make-suite';
import { ProtocolErrors, RateMode } from '../helpers/types';
import { ProtocolErrors, RateMode } from '../../helpers/types';
import { calcExpectedVariableDebtTokenBalance } from './helpers/utils/calculations';
import { getUserData, getReserveData } from './helpers/utils/helpers';

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