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/188-avalanche-usd-quote' into feat/188-avalanche-market

Browse Source
This commit is contained in:
miguelmtzinf 2021-07-30 14:46:36 +02:00
commit 9bca4037be
32 changed files with 547 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
contracts/misc/AaveOracle.sol
View File

@ -18,29 +18,34 @@ import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
contract AaveOracle is IPriceOracleGetter, Ownable {
using SafeERC20 for IERC20;
event WethSet(address indexed weth);
event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);
event AssetSourceUpdated(address indexed asset, address indexed source);
event FallbackOracleUpdated(address indexed fallbackOracle);
mapping(address => IChainlinkAggregator) private assetsSources;
IPriceOracleGetter private _fallbackOracle;
address public immutable WETH;
address public immutable BASE_CURRENCY;
uint256 public immutable BASE_CURRENCY_UNIT;
/// @notice Constructor
/// @param assets The addresses of the assets
/// @param sources The address of the source of each asset
/// @param fallbackOracle The address of the fallback oracle to use if the data of an
/// aggregator is not consistent
/// @param baseCurrency the base currency used for the price quotes. If USD is used, base currency is 0x0
/// @param baseCurrencyUnit the unit of the base currency
constructor(
address[] memory assets,
address[] memory sources,
address fallbackOracle,
address weth
address baseCurrency,
uint256 baseCurrencyUnit
) public {
_setFallbackOracle(fallbackOracle);
_setAssetsSources(assets, sources);
WETH = weth;
emit WethSet(weth);
BASE_CURRENCY = baseCurrency;
BASE_CURRENCY_UNIT = baseCurrencyUnit;
emit BaseCurrencySet(baseCurrency, baseCurrencyUnit);
}
/// @notice External function called by the Aave governance to set or replace sources of assets
@ -83,8 +88,8 @@ contract AaveOracle is IPriceOracleGetter, Ownable {
function getAssetPrice(address asset) public view override returns (uint256) {
IChainlinkAggregator source = assetsSources[asset];
if (asset == WETH) {
return 1 ether;
if (asset == BASE_CURRENCY) {
return BASE_CURRENCY_UNIT;
} else if (address(source) == address(0)) {
return _fallbackOracle.getAssetPrice(asset);
} else {

2
hardhat.config.ts
View File

@ -102,7 +102,7 @@ const buidlerConfig: HardhatUserConfig = {
kovan: getCommonNetworkConfig(eEthereumNetwork.kovan, 42),
ropsten: getCommonNetworkConfig(eEthereumNetwork.ropsten, 3),
main: getCommonNetworkConfig(eEthereumNetwork.main, 1),
tenderlyMain: getCommonNetworkConfig(eEthereumNetwork.tenderlyMain, 3030),
tenderly: getCommonNetworkConfig(eEthereumNetwork.tenderly, 3030),
matic: getCommonNetworkConfig(ePolygonNetwork.matic, 137),
mumbai: getCommonNetworkConfig(ePolygonNetwork.mumbai, 80001),
xdai: getCommonNetworkConfig(eXDaiNetwork.xdai, 100),

6
helper-hardhat-config.ts
View File

@ -46,7 +46,7 @@ export const NETWORKS_RPC_URL: iParamsPerNetwork<string> = {
[eEthereumNetwork.coverage]: 'http://localhost:8555',
[eEthereumNetwork.hardhat]: 'http://localhost:8545',
[eEthereumNetwork.buidlerevm]: 'http://localhost:8545',
[eEthereumNetwork.tenderlyMain]: `https://rpc.tenderly.co/fork/${TENDERLY_FORK_ID}`,
[eEthereumNetwork.tenderly]: `https://rpc.tenderly.co/fork/`,
[ePolygonNetwork.mumbai]: 'https://rpc-mumbai.maticvigil.com',
[ePolygonNetwork.matic]: 'https://rpc-mainnet.matic.network',
[eXDaiNetwork.xdai]: 'https://rpc.xdaichain.com/',
@ -61,7 +61,7 @@ export const NETWORKS_DEFAULT_GAS: iParamsPerNetwork<number> = {
[eEthereumNetwork.coverage]: 65 * GWEI,
[eEthereumNetwork.hardhat]: 65 * GWEI,
[eEthereumNetwork.buidlerevm]: 65 * GWEI,
[eEthereumNetwork.tenderlyMain]: 0.01 * GWEI,
[eEthereumNetwork.tenderly]: 1 * GWEI,
[ePolygonNetwork.mumbai]: 1 * GWEI,
[ePolygonNetwork.matic]: 1 * GWEI,
[eXDaiNetwork.xdai]: 1 * GWEI,
@ -76,7 +76,7 @@ export const BLOCK_TO_FORK: iParamsPerNetwork<number | undefined> = {
[eEthereumNetwork.coverage]: undefined,
[eEthereumNetwork.hardhat]: undefined,
[eEthereumNetwork.buidlerevm]: undefined,
[eEthereumNetwork.tenderlyMain]: 12406069,
[eEthereumNetwork.tenderly]: undefined,
[ePolygonNetwork.mumbai]: undefined,
[ePolygonNetwork.matic]: undefined,
[eXDaiNetwork.xdai]: undefined,

39
helpers/configuration.ts
View File

@ -3,14 +3,15 @@ import {
iMultiPoolsAssets,
IReserveParams,
PoolConfiguration,
ICommonConfiguration,
eNetwork,
IBaseConfiguration,
} from './types';
import { getEthersSignersAddresses, getParamPerPool } from './contracts-helpers';
import AaveConfig from '../markets/aave';
import MaticConfig from '../markets/matic';
import AvalancheConfig from '../markets/avalanche';
import AmmConfig from '../markets/amm';
import { CommonsConfig } from '../markets/aave/commons';
import { DRE, filterMapBy } from './misc-utils';
import { tEthereumAddress } from './types';
@ -38,7 +39,11 @@ export const loadPoolConfig = (configName: ConfigNames): PoolConfiguration => {
case ConfigNames.Commons:
return CommonsConfig;
default:
throw new Error(`Unsupported pool configuration: ${Object.values(ConfigNames)}`);
throw new Error(
`Unsupported pool configuration: ${configName} is not one of the supported configs ${Object.values(
ConfigNames
)}`
);
}
};
@ -66,7 +71,7 @@ export const getReservesConfigByPool = (pool: AavePools): iMultiPoolsAssets<IRes
);
export const getGenesisPoolAdmin = async (
config: ICommonConfiguration
config: IBaseConfiguration
): Promise<tEthereumAddress> => {
const currentNetwork = process.env.FORK ? process.env.FORK : DRE.network.name;
const targetAddress = getParamPerNetwork(config.PoolAdmin, <eNetwork>currentNetwork);
@ -78,9 +83,7 @@ export const getGenesisPoolAdmin = async (
return addressList[addressIndex];
};
export const getEmergencyAdmin = async (
config: ICommonConfiguration
): Promise<tEthereumAddress> => {
export const getEmergencyAdmin = async (config: IBaseConfiguration): Promise<tEthereumAddress> => {
const currentNetwork = process.env.FORK ? process.env.FORK : DRE.network.name;
const targetAddress = getParamPerNetwork(config.EmergencyAdmin, <eNetwork>currentNetwork);
if (targetAddress) {
@ -91,19 +94,17 @@ export const getEmergencyAdmin = async (
return addressList[addressIndex];
};
export const getTreasuryAddress = async (
config: ICommonConfiguration
): Promise<tEthereumAddress> => {
export const getTreasuryAddress = async (config: IBaseConfiguration): Promise<tEthereumAddress> => {
const currentNetwork = process.env.FORK ? process.env.FORK : DRE.network.name;
return getParamPerNetwork(config.ReserveFactorTreasuryAddress, <eNetwork>currentNetwork);
};
export const getATokenDomainSeparatorPerNetwork = (
network: eNetwork,
config: ICommonConfiguration
config: IBaseConfiguration
): tEthereumAddress => getParamPerNetwork<tEthereumAddress>(config.ATokenDomainSeparator, network);
export const getWethAddress = async (config: ICommonConfiguration) => {
export const getWethAddress = async (config: IBaseConfiguration) => {
const currentNetwork = process.env.FORK ? process.env.FORK : DRE.network.name;
const wethAddress = getParamPerNetwork(config.WETH, <eNetwork>currentNetwork);
if (wethAddress) {
@ -116,7 +117,7 @@ export const getWethAddress = async (config: ICommonConfiguration) => {
return weth.address;
};
export const getWrappedNativeTokenAddress = async (config: ICommonConfiguration) => {
export const getWrappedNativeTokenAddress = async (config: IBaseConfiguration) => {
const currentNetwork = process.env.MAINNET_FORK === 'true' ? 'main' : DRE.network.name;
const wethAddress = getParamPerNetwork(config.WrappedNativeToken, <eNetwork>currentNetwork);
if (wethAddress) {
@ -129,7 +130,7 @@ export const getWrappedNativeTokenAddress = async (config: ICommonConfiguration)
return weth.address;
};
export const getLendingRateOracles = (poolConfig: ICommonConfiguration) => {
export const getLendingRateOracles = (poolConfig: IBaseConfiguration) => {
const {
ProtocolGlobalParams: { UsdAddress },
LendingRateOracleRatesCommon,
@ -141,3 +142,15 @@ export const getLendingRateOracles = (poolConfig: ICommonConfiguration) => {
Object.keys(ReserveAssets[network]).includes(key)
);
};
export const getQuoteCurrency = async (config: IBaseConfiguration) => {
switch (config.OracleQuoteCurrency) {
case 'ETH':
case 'WETH':
return getWethAddress(config);
case 'USD':
return config.ProtocolGlobalParams.UsdAddress;
default:
throw `Quote ${config.OracleQuoteCurrency} currency not set. Add a new case to getQuoteCurrency switch`;
}
};

2
helpers/constants.ts
View File

@ -1,4 +1,5 @@
import BigNumber from 'bignumber.js';
import { eEthereumNetwork } from './types';
// ----------------
// MATH
@ -12,6 +13,7 @@ export const RAY = new BigNumber(10).exponentiatedBy(27).toFixed();
export const HALF_RAY = new BigNumber(RAY).multipliedBy(0.5).toFixed();
export const WAD_RAY_RATIO = Math.pow(10, 9).toString();
export const oneEther = new BigNumber(Math.pow(10, 18));
export const oneUsd = new BigNumber(Math.pow(10, 8));
export const oneRay = new BigNumber(Math.pow(10, 27));
export const MAX_UINT_AMOUNT =
'115792089237316195423570985008687907853269984665640564039457584007913129639935';

89
helpers/contracts-deployments.ts
View File

@ -1,5 +1,5 @@
import { Contract } from 'ethers';
import { DRE } from './misc-utils';
import { DRE, notFalsyOrZeroAddress } from './misc-utils';
import {
tEthereumAddress,
eContractid,
@ -13,9 +13,8 @@ import {
} from './types';
import { MintableERC20 } from '../types/MintableERC20';
import { MockContract } from 'ethereum-waffle';
import { getReservesConfigByPool } from './configuration';
import { ConfigNames, getReservesConfigByPool, loadPoolConfig } from './configuration';
import { getFirstSigner } from './contracts-getters';
import { ZERO_ADDRESS } from './constants';
import {
AaveProtocolDataProviderFactory,
ATokenFactory,
@ -57,6 +56,7 @@ import {
insertContractAddressInDb,
deployContract,
verifyContract,
getOptionalParamAddressPerNetwork,
} from './contracts-helpers';
import { StableAndVariableTokensHelperFactory } from '../types/StableAndVariableTokensHelperFactory';
import { MintableDelegationERC20 } from '../types/MintableDelegationERC20';
@ -64,6 +64,7 @@ import { readArtifact as buidlerReadArtifact } from '@nomiclabs/buidler/plugins'
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import { LendingPoolLibraryAddresses } from '../types/LendingPoolFactory';
import { UiPoolDataProvider } from '../types';
import { eNetwork } from './types';
export const deployUiPoolDataProvider = async (
[incentivesController, aaveOracle]: [tEthereumAddress, tEthereumAddress],
@ -223,7 +224,7 @@ export const deployMockAggregator = async (price: tStringTokenSmallUnits, verify
);
export const deployAaveOracle = async (
args: [tEthereumAddress[], tEthereumAddress[], tEthereumAddress, tEthereumAddress],
args: [tEthereumAddress[], tEthereumAddress[], tEthereumAddress, tEthereumAddress, string],
verify?: boolean
) =>
withSaveAndVerify(
@ -351,20 +352,20 @@ export const deployVariableDebtToken = async (
return instance;
};
export const deployGenericStableDebtToken = async () =>
export const deployGenericStableDebtToken = async (verify?: boolean) =>
withSaveAndVerify(
await new StableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.StableDebtToken,
[],
false
verify
);
export const deployGenericVariableDebtToken = async () =>
export const deployGenericVariableDebtToken = async (verify?: boolean) =>
withSaveAndVerify(
await new VariableDebtTokenFactory(await getFirstSigner()).deploy(),
eContractid.VariableDebtToken,
[],
false
verify
);
export const deployGenericAToken = async (
@ -637,3 +638,75 @@ export const deployFlashLiquidationAdapter = async (
args,
verify
);
export const chooseATokenDeployment = (id: eContractid) => {
switch (id) {
case eContractid.AToken:
return deployGenericATokenImpl;
case eContractid.DelegationAwareAToken:
return deployDelegationAwareATokenImpl;
default:
throw Error(`Missing aToken implementation deployment script for: ${id}`);
}
};
export const deployATokenImplementations = async (
pool: ConfigNames,
reservesConfig: { [key: string]: IReserveParams },
verify = false
) => {
const poolConfig = loadPoolConfig(pool);
const network = <eNetwork>DRE.network.name;
// Obtain the different AToken implementations of all reserves inside the Market config
const aTokenImplementations = [
...Object.entries(reservesConfig).reduce<Set<eContractid>>((acc, [, entry]) => {
acc.add(entry.aTokenImpl);
return acc;
}, new Set<eContractid>()),
];
console.log(aTokenImplementations);
for (let x = 0; x < aTokenImplementations.length; x++) {
const aTokenAddress = getOptionalParamAddressPerNetwork(
poolConfig[aTokenImplementations[x].toString()],
network
);
if (!notFalsyOrZeroAddress(aTokenAddress)) {
const deployImplementationMethod = chooseATokenDeployment(aTokenImplementations[x]);
console.log(`Deploying implementation`, aTokenImplementations[x]);
await deployImplementationMethod(verify);
}
}
// Debt tokens, for now all Market configs follows same implementations
const genericStableDebtTokenAddress = getOptionalParamAddressPerNetwork(
poolConfig.StableDebtTokenImplementation,
network
);
const geneticVariableDebtTokenAddress = getOptionalParamAddressPerNetwork(
poolConfig.VariableDebtTokenImplementation,
network
);
if (!notFalsyOrZeroAddress(genericStableDebtTokenAddress)) {
await deployGenericStableDebtToken(verify);
}
if (!notFalsyOrZeroAddress(geneticVariableDebtTokenAddress)) {
await deployGenericVariableDebtToken(verify);
}
};
export const deployRateStrategy = async (
strategyName: string,
args: [tEthereumAddress, string, string, string, string, string, string],
verify: boolean
): Promise<tEthereumAddress> => {
switch (strategyName) {
default:
return await (
await deployDefaultReserveInterestRateStrategy(args, verify)
).address;
}
};

147
helpers/contracts-getters.ts
View File

@ -33,7 +33,7 @@ import {
} from '../types';
import { IERC20DetailedFactory } from '../types/IERC20DetailedFactory';
import { getEthersSigners, MockTokenMap } from './contracts-helpers';
import { DRE, getDb, notFalsyOrZeroAddress } from './misc-utils';
import { DRE, getDb, notFalsyOrZeroAddress, omit } from './misc-utils';
import { eContractid, PoolConfiguration, tEthereumAddress, TokenContractId } from './types';
export const getFirstSigner = async () => (await getEthersSigners())[0];
@ -41,16 +41,18 @@ export const getFirstSigner = async () => (await getEthersSigners())[0];
export const getLendingPoolAddressesProvider = async (address?: tEthereumAddress) => {
return await LendingPoolAddressesProviderFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPoolAddressesProvider}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.LendingPoolAddressesProvider}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
};
export const getLendingPoolConfiguratorProxy = async (address?: tEthereumAddress) => {
return await LendingPoolConfiguratorFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPoolConfigurator}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.LendingPoolConfigurator}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
};
@ -58,14 +60,18 @@ export const getLendingPoolConfiguratorProxy = async (address?: tEthereumAddress
export const getLendingPool = async (address?: tEthereumAddress) =>
await LendingPoolFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPool}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.LendingPool}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getPriceOracle = async (address?: tEthereumAddress) =>
await PriceOracleFactory.connect(
address ||
(await getDb().get(`${eContractid.PriceOracle}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.PriceOracle}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -78,36 +84,45 @@ export const getAToken = async (address?: tEthereumAddress) =>
export const getStableDebtToken = async (address?: tEthereumAddress) =>
await StableDebtTokenFactory.connect(
address ||
(await getDb().get(`${eContractid.StableDebtToken}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.StableDebtToken}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getVariableDebtToken = async (address?: tEthereumAddress) =>
await VariableDebtTokenFactory.connect(
address ||
(await getDb().get(`${eContractid.VariableDebtToken}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.VariableDebtToken}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getMintableERC20 = async (address: tEthereumAddress) =>
await MintableERC20Factory.connect(
address ||
(await getDb().get(`${eContractid.MintableERC20}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.MintableERC20}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getIErc20Detailed = async (address: tEthereumAddress) =>
await IERC20DetailedFactory.connect(
address ||
(await getDb().get(`${eContractid.IERC20Detailed}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.IERC20Detailed}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getAaveProtocolDataProvider = async (address?: tEthereumAddress) =>
await AaveProtocolDataProviderFactory.connect(
address ||
(await getDb().get(`${eContractid.AaveProtocolDataProvider}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.AaveProtocolDataProvider}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -125,15 +140,18 @@ export const getInterestRateStrategy = async (address?: tEthereumAddress) =>
export const getMockFlashLoanReceiver = async (address?: tEthereumAddress) =>
await MockFlashLoanReceiverFactory.connect(
address ||
(await getDb().get(`${eContractid.MockFlashLoanReceiver}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.MockFlashLoanReceiver}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getLendingRateOracle = async (address?: tEthereumAddress) =>
await LendingRateOracleFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingRateOracle}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.LendingRateOracle}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -166,23 +184,37 @@ export const getAllMockedTokens = async () => {
return tokens;
};
export const getQuoteCurrencies = (oracleQuoteCurrency: string): string[] => {
switch (oracleQuoteCurrency) {
case 'USD':
return ['USD'];
case 'ETH':
case 'WETH':
default:
return ['ETH', 'WETH'];
}
};
export const getPairsTokenAggregator = (
allAssetsAddresses: {
[tokenSymbol: string]: tEthereumAddress;
},
aggregatorsAddresses: { [tokenSymbol: string]: tEthereumAddress }
aggregatorsAddresses: { [tokenSymbol: string]: tEthereumAddress },
oracleQuoteCurrency: string
): [string[], string[]] => {
const { ETH, WETH, ...assetsAddressesWithoutEth } = allAssetsAddresses;
const assetsWithoutQuoteCurrency = omit(
allAssetsAddresses,
getQuoteCurrencies(oracleQuoteCurrency)
);
const pairs = Object.entries(assetsAddressesWithoutEth).map(([tokenSymbol, tokenAddress]) => {
const pairs = Object.entries(assetsWithoutQuoteCurrency).map(([tokenSymbol, tokenAddress]) => {
//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];
const [, aggregatorAddress] = (
Object.entries(aggregatorsAddresses) as [string, tEthereumAddress][]
)[aggregatorAddressIndex];
return [tokenAddress, aggregatorAddress];
//}
}) as [string, string][];
@ -208,14 +240,18 @@ export const getLendingPoolAddressesProviderRegistry = async (address?: tEthereu
export const getReserveLogic = async (address?: tEthereumAddress) =>
await ReserveLogicFactory.connect(
address ||
(await getDb().get(`${eContractid.ReserveLogic}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.ReserveLogic}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getGenericLogic = async (address?: tEthereumAddress) =>
await GenericLogicFactory.connect(
address ||
(await getDb().get(`${eContractid.GenericLogic}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.GenericLogic}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -233,15 +269,18 @@ export const getStableAndVariableTokensHelper = async (address?: tEthereumAddres
export const getATokensAndRatesHelper = async (address?: tEthereumAddress) =>
await ATokensAndRatesHelperFactory.connect(
address ||
(await getDb().get(`${eContractid.ATokensAndRatesHelper}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.ATokensAndRatesHelper}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getWETHGateway = async (address?: tEthereumAddress) =>
await WETHGatewayFactory.connect(
address ||
(await getDb().get(`${eContractid.WETHGateway}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.WETHGateway}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -260,23 +299,27 @@ export const getMockAToken = async (address?: tEthereumAddress) =>
export const getMockVariableDebtToken = async (address?: tEthereumAddress) =>
await MockVariableDebtTokenFactory.connect(
address ||
(await getDb().get(`${eContractid.MockVariableDebtToken}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.MockVariableDebtToken}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getMockStableDebtToken = async (address?: tEthereumAddress) =>
await MockStableDebtTokenFactory.connect(
address ||
(await getDb().get(`${eContractid.MockStableDebtToken}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.MockStableDebtToken}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getSelfdestructTransferMock = async (address?: tEthereumAddress) =>
await SelfdestructTransferFactory.connect(
address ||
(await getDb().get(`${eContractid.SelfdestructTransferMock}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.SelfdestructTransferMock}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -286,15 +329,18 @@ export const getProxy = async (address: tEthereumAddress) =>
export const getLendingPoolImpl = async (address?: tEthereumAddress) =>
await LendingPoolFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPoolImpl}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.LendingPoolImpl}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getLendingPoolConfiguratorImpl = async (address?: tEthereumAddress) =>
await LendingPoolConfiguratorFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPoolConfiguratorImpl}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.LendingPoolConfiguratorImpl}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -312,16 +358,18 @@ export const getLendingPoolCollateralManagerImpl = async (address?: tEthereumAdd
export const getWalletProvider = async (address?: tEthereumAddress) =>
await WalletBalanceProviderFactory.connect(
address ||
(await getDb().get(`${eContractid.WalletBalanceProvider}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.WalletBalanceProvider}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getLendingPoolCollateralManager = async (address?: tEthereumAddress) =>
await LendingPoolCollateralManagerFactory.connect(
address ||
(await getDb().get(`${eContractid.LendingPoolCollateralManager}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.LendingPoolCollateralManager}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
@ -337,30 +385,35 @@ export const getAaveOracle = async (address?: tEthereumAddress) =>
export const getMockUniswapRouter = async (address?: tEthereumAddress) =>
await MockUniswapV2Router02Factory.connect(
address ||
(await getDb().get(`${eContractid.MockUniswapV2Router02}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.MockUniswapV2Router02}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getUniswapLiquiditySwapAdapter = async (address?: tEthereumAddress) =>
await UniswapLiquiditySwapAdapterFactory.connect(
address ||
(await getDb().get(`${eContractid.UniswapLiquiditySwapAdapter}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.UniswapLiquiditySwapAdapter}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getUniswapRepayAdapter = async (address?: tEthereumAddress) =>
await UniswapRepayAdapterFactory.connect(
address ||
(await getDb().get(`${eContractid.UniswapRepayAdapter}.${DRE.network.name}`).value()).address,
(
await getDb().get(`${eContractid.UniswapRepayAdapter}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);
export const getFlashLiquidationAdapter = async (address?: tEthereumAddress) =>
await FlashLiquidationAdapterFactory.connect(
address ||
(await getDb().get(`${eContractid.FlashLiquidationAdapter}.${DRE.network.name}`).value())
.address,
(
await getDb().get(`${eContractid.FlashLiquidationAdapter}.${DRE.network.name}`).value()
).address,
await getFirstSigner()
);

41
helpers/contracts-helpers.ts
View File

@ -2,7 +2,7 @@ import { Contract, Signer, utils, ethers, BigNumberish } from 'ethers';
import { signTypedData_v4 } from 'eth-sig-util';
import { fromRpcSig, ECDSASignature } from 'ethereumjs-util';
import BigNumber from 'bignumber.js';
import { getDb, DRE, waitForTx } from './misc-utils';
import { getDb, DRE, waitForTx, notFalsyOrZeroAddress } from './misc-utils';
import {
tEthereumAddress,
eContractid,
@ -14,7 +14,6 @@ import {
ePolygonNetwork,
eXDaiNetwork,
eNetwork,
iParamsPerNetworkAll,
iEthereumParamsPerNetwork,
iPolygonParamsPerNetwork,
iXDaiParamsPerNetwork,
@ -28,6 +27,8 @@ import { verifyEtherscanContract } from './etherscan-verification';
import { getFirstSigner, getIErc20Detailed } from './contracts-getters';
import { usingTenderly, verifyAtTenderly } from './tenderly-utils';
import { usingPolygon, verifyAtPolygon } from './polygon-utils';
import { ConfigNames, loadPoolConfig } from './configuration';
import { ZERO_ADDRESS } from './constants';
import { getDefenderRelaySigner, usingDefender } from './defender-utils';
export type MockTokenMap = { [symbol: string]: MintableERC20 };
@ -144,7 +145,7 @@ export const linkBytecode = (artifact: BuidlerArtifact | Artifact, libraries: an
};
export const getParamPerNetwork = <T>(param: iParamsPerNetwork<T>, network: eNetwork) => {
const { main, ropsten, kovan, coverage, buidlerevm, tenderlyMain } =
const { main, ropsten, kovan, coverage, buidlerevm, tenderly } =
param as iEthereumParamsPerNetwork<T>;
const { matic, mumbai } = param as iPolygonParamsPerNetwork<T>;
const { xdai } = param as iXDaiParamsPerNetwork<T>;
@ -166,8 +167,8 @@ export const getParamPerNetwork = <T>(param: iParamsPerNetwork<T>, network: eNet
return ropsten;
case eEthereumNetwork.main:
return main;
case eEthereumNetwork.tenderlyMain:
return tenderlyMain;
case eEthereumNetwork.tenderly:
return tenderly;
case ePolygonNetwork.matic:
return matic;
case ePolygonNetwork.mumbai:
@ -181,6 +182,16 @@ export const getParamPerNetwork = <T>(param: iParamsPerNetwork<T>, network: eNet
}
};
export const getOptionalParamAddressPerNetwork = (
param: iParamsPerNetwork<tEthereumAddress> | undefined | null,
network: eNetwork
) => {
if (!param) {
return ZERO_ADDRESS;
}
return getParamPerNetwork(param, network);
};
export const getParamPerPool = <T>({ proto, amm, matic, avalanche }: iParamsPerPool<T>, pool: AavePools) => {
switch (pool) {
case AavePools.proto:
@ -345,3 +356,23 @@ export const verifyContract = async (
}
return instance;
};
export const getContractAddressWithJsonFallback = async (
id: string,
pool: ConfigNames
): Promise<tEthereumAddress> => {
const poolConfig = loadPoolConfig(pool);
const network = <eNetwork>DRE.network.name;
const db = getDb();
const contractAtMarketConfig = getOptionalParamAddressPerNetwork(poolConfig[id], network);
if (notFalsyOrZeroAddress(contractAtMarketConfig)) {
return contractAtMarketConfig;
}
const contractAtDb = await getDb().get(`${id}.${DRE.network.name}`).value();
if (contractAtDb?.address) {
return contractAtDb.address as tEthereumAddress;
}
throw Error(`Missing contract address ${id} at Market config and JSON local db`);
};

170
helpers/init-helpers.ts
View File

@ -1,48 +1,31 @@
import {
eContractid,
eEthereumNetwork,
eNetwork,
iMultiPoolsAssets,
IReserveParams,
tEthereumAddress,
} from './types';
import { AaveProtocolDataProvider } from '../types/AaveProtocolDataProvider';
import { chunk, DRE, getDb, waitForTx } from './misc-utils';
import { chunk, getDb, waitForTx } from './misc-utils';
import {
getAaveProtocolDataProvider,
getAToken,
getATokensAndRatesHelper,
getFirstSigner,
getLendingPoolAddressesProvider,
getLendingPoolConfiguratorProxy,
getStableAndVariableTokensHelper,
} from './contracts-getters';
import { rawInsertContractAddressInDb } from './contracts-helpers';
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';
import { config } from 'process';
getContractAddressWithJsonFallback,
rawInsertContractAddressInDb,
} from './contracts-helpers';
import { BigNumberish } from 'ethers';
import { ConfigNames } from './configuration';
import { deployRateStrategy } from './contracts-deployments';
export const chooseATokenDeployment = (id: eContractid) => {
switch (id) {
case eContractid.AToken:
return deployGenericAToken;
case eContractid.DelegationAwareAToken:
return deployDelegationAwareAToken;
export const getATokenExtraParams = async (aTokenName: string, tokenAddress: tEthereumAddress) => {
console.log(aTokenName);
switch (aTokenName) {
default:
throw Error(`Missing aToken deployment script for: ${id}`);
return '0x10';
}
};
@ -56,19 +39,15 @@ export const initReservesByHelper = async (
admin: tEthereumAddress,
treasuryAddress: tEthereumAddress,
incentivesController: tEthereumAddress,
poolName: ConfigNames,
verify: boolean
): Promise<BigNumber> => {
let gasUsage = BigNumber.from('0');
const stableAndVariableDeployer = await getStableAndVariableTokensHelper();
) => {
const addressProvider = await getLendingPoolAddressesProvider();
// CHUNK CONFIGURATION
const initChunks = 4;
const initChunks = 1;
// Initialize variables for future reserves initialization
let reserveTokens: string[] = [];
let reserveInitDecimals: string[] = [];
let reserveSymbols: string[] = [];
let initInputParams: {
@ -101,49 +80,8 @@ export const initReservesByHelper = async (
];
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 = '';
// 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 aTokenImplementation = await deployGenericATokenImpl(verify);
aTokenImplementationAddress = aTokenImplementation.address;
rawInsertContractAddressInDb(`aTokenImpl`, aTokenImplementationAddress);
const delegatedAwareReserves = Object.entries(reservesParams).filter(
([_, { aTokenImpl }]) => aTokenImpl === eContractid.DelegationAwareAToken
) as [string, IReserveParams][];
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][];
const reserves = Object.entries(reservesParams);
for (let [symbol, params] of reserves) {
if (!tokenAddresses[symbol]) {
@ -170,52 +108,41 @@ export const initReservesByHelper = async (
stableRateSlope1,
stableRateSlope2,
];
strategyAddresses[strategy.name] = (
await deployDefaultReserveInterestRateStrategy(rateStrategies[strategy.name], verify)
).address;
strategyAddresses[strategy.name] = await deployRateStrategy(
strategy.name,
rateStrategies[strategy.name],
verify
);
// 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]);
if (aTokenImpl === eContractid.AToken) {
aTokenType[symbol] = 'generic';
} else if (aTokenImpl === eContractid.DelegationAwareAToken) {
aTokenType[symbol] = 'delegation aware';
}
reserveInitDecimals.push(reserveDecimals);
reserveTokens.push(tokenAddresses[symbol]);
// Prepare input parameters
reserveSymbols.push(symbol);
}
for (let i = 0; i < reserveSymbols.length; i++) {
let aTokenToUse: string;
if (aTokenType[reserveSymbols[i]] === 'generic') {
aTokenToUse = aTokenImplementationAddress;
} else {
aTokenToUse = delegationAwareATokenImplementationAddress;
}
initInputParams.push({
aTokenImpl: aTokenToUse,
stableDebtTokenImpl: stableDebtTokenImplementationAddress,
variableDebtTokenImpl: variableDebtTokenImplementationAddress,
underlyingAssetDecimals: reserveInitDecimals[i],
interestRateStrategyAddress: strategyAddressPerAsset[reserveSymbols[i]],
underlyingAsset: reserveTokens[i],
aTokenImpl: await getContractAddressWithJsonFallback(aTokenImpl, poolName),
stableDebtTokenImpl: await getContractAddressWithJsonFallback(
eContractid.StableDebtToken,
poolName
),
variableDebtTokenImpl: await getContractAddressWithJsonFallback(
eContractid.VariableDebtToken,
poolName
),
underlyingAssetDecimals: reserveDecimals,
interestRateStrategyAddress: strategyAddresses[strategy.name],
underlyingAsset: tokenAddresses[symbol],
treasury: treasuryAddress,
incentivesController,
underlyingAssetName: reserveSymbols[i],
aTokenName: `${aTokenNamePrefix} ${reserveSymbols[i]}`,
aTokenSymbol: `a${symbolPrefix}${reserveSymbols[i]}`,
variableDebtTokenName: `${variableDebtTokenNamePrefix} ${symbolPrefix}${reserveSymbols[i]}`,
variableDebtTokenSymbol: `variableDebt${symbolPrefix}${reserveSymbols[i]}`,
stableDebtTokenName: `${stableDebtTokenNamePrefix} ${reserveSymbols[i]}`,
stableDebtTokenSymbol: `stableDebt${symbolPrefix}${reserveSymbols[i]}`,
params: '0x10',
incentivesController: incentivesController,
underlyingAssetName: symbol,
aTokenName: `${aTokenNamePrefix} ${symbol}`,
aTokenSymbol: `a${symbolPrefix}${symbol}`,
variableDebtTokenName: `${variableDebtTokenNamePrefix} ${symbolPrefix}${symbol}`,
variableDebtTokenSymbol: `variableDebt${symbolPrefix}${symbol}`,
stableDebtTokenName: `${stableDebtTokenNamePrefix} ${symbol}`,
stableDebtTokenSymbol: `stableDebt${symbolPrefix}${symbol}`,
params: await getATokenExtraParams(aTokenImpl, tokenAddresses[symbol]),
});
}
@ -224,7 +151,6 @@ export const initReservesByHelper = async (
const chunkedInitInputParams = chunk(initInputParams, initChunks);
const configurator = await getLendingPoolConfiguratorProxy();
//await waitForTx(await addressProvider.setPoolAdmin(admin));
console.log(`- Reserves initialization in ${chunkedInitInputParams.length} txs`);
for (let chunkIndex = 0; chunkIndex < chunkedInitInputParams.length; chunkIndex++) {
@ -234,10 +160,7 @@ export const initReservesByHelper = async (
console.log(` - Reserve ready for: ${chunkedSymbols[chunkIndex].join(', ')}`);
console.log(' * gasUsed', tx3.gasUsed.toString());
//gasUsage = gasUsage.add(tx3.gasUsed);
}
return gasUsage; // Deprecated
};
export const getPairsTokenAggregator = (
@ -253,10 +176,9 @@ export const getPairsTokenAggregator = (
const aggregatorAddressIndex = Object.keys(aggregatorsAddresses).findIndex(
(value) => value === tokenSymbol
);
const [, aggregatorAddress] = (Object.entries(aggregatorsAddresses) as [
string,
tEthereumAddress
][])[aggregatorAddressIndex];
const [, aggregatorAddress] = (
Object.entries(aggregatorsAddresses) as [string, tEthereumAddress][]
)[aggregatorAddressIndex];
return [tokenAddress, aggregatorAddress];
}
}) as [string, string][];

23
helpers/misc-utils.ts
View File

@ -9,6 +9,8 @@ import { BuidlerRuntimeEnvironment } from '@nomiclabs/buidler/types';
import { tEthereumAddress } from './types';
import { isAddress } from 'ethers/lib/utils';
import { isZeroAddress } from 'ethereumjs-util';
import { SignerWithAddress } from '../test-suites/test-aave/helpers/make-suite';
import { usingTenderly } from './tenderly-utils';
export const toWad = (value: string | number) => new BigNumber(value).times(WAD).toFixed();
@ -116,6 +118,27 @@ export const notFalsyOrZeroAddress = (address: tEthereumAddress | null | undefin
return isAddress(address) && !isZeroAddress(address);
};
export const impersonateAddress = async (address: tEthereumAddress): Promise<SignerWithAddress> => {
if (!usingTenderly()) {
await (DRE as HardhatRuntimeEnvironment).network.provider.request({
method: 'hardhat_impersonateAccount',
params: [address],
});
}
const signer = await DRE.ethers.provider.getSigner(address);
return {
signer,
address,
};
};
export const omit = <T, U extends keyof T>(obj: T, keys: U[]): Omit<T, U> =>
(Object.keys(obj) as U[]).reduce(
(acc, curr) => (keys.includes(curr) ? acc : { ...acc, [curr]: obj[curr] }),
{} as Omit<T, U>
);
export const impersonateAccountsHardhat = async (accounts: string[]) => {
if (process.env.TENDERLY === 'true') {
return;

19
helpers/types.ts
View File

@ -13,7 +13,7 @@ export enum eEthereumNetwork {
main = 'main',
coverage = 'coverage',
hardhat = 'hardhat',
tenderlyMain = 'tenderlyMain',
tenderly = 'tenderly',
}
export enum ePolygonNetwork {
@ -425,7 +425,7 @@ export interface iEthereumParamsPerNetwork<T> {
[eEthereumNetwork.ropsten]: T;
[eEthereumNetwork.main]: T;
[eEthereumNetwork.hardhat]: T;
[eEthereumNetwork.tenderlyMain]: T;
[eEthereumNetwork.tenderly]: T;
}
export interface iPolygonParamsPerNetwork<T> {
@ -485,7 +485,7 @@ export interface ILendingRate {
borrowRate: string;
}
export interface ICommonConfiguration {
export interface IBaseConfiguration {
MarketId: string;
ATokenNamePrefix: string;
StableDebtTokenNamePrefix: string;
@ -493,7 +493,6 @@ export interface ICommonConfiguration {
SymbolPrefix: string;
ProviderId: number;
ProtocolGlobalParams: IProtocolGlobalConfig;
Mocks: IMocksConfig;
ProviderRegistry: iParamsPerNetwork<tEthereumAddress | undefined>;
ProviderRegistryOwner: iParamsPerNetwork<tEthereumAddress | undefined>;
LendingPoolCollateralManager: iParamsPerNetwork<tEthereumAddress>;
@ -509,14 +508,22 @@ export interface ICommonConfiguration {
PoolAdminIndex: number;
EmergencyAdmin: iParamsPerNetwork<tEthereumAddress | undefined>;
EmergencyAdminIndex: number;
ReserveAssets: iParamsPerNetwork<SymbolMap<tEthereumAddress>>;
ReservesConfig: iMultiPoolsAssets<IReserveParams>;
ATokenDomainSeparator: iParamsPerNetwork<string>;
WETH: iParamsPerNetwork<tEthereumAddress>;
WrappedNativeToken: iParamsPerNetwork<tEthereumAddress>;
WethGateway: iParamsPerNetwork<tEthereumAddress>;
ReserveFactorTreasuryAddress: iParamsPerNetwork<tEthereumAddress>;
IncentivesController: iParamsPerNetwork<tEthereumAddress>;
StableDebtTokenImplementation?: iParamsPerNetwork<tEthereumAddress>;
VariableDebtTokenImplementation?: iParamsPerNetwork<tEthereumAddress>;
ReserveAssets: iParamsPerNetwork<SymbolMap<tEthereumAddress>>;
OracleQuoteCurrency: string;
OracleQuoteUnit: string;
}
export interface ICommonConfiguration extends IBaseConfiguration {
ReservesConfig: iMultiPoolsAssets<IReserveParams>;
Mocks: IMocksConfig;
}
export interface IAaveConfiguration extends ICommonConfiguration {

44
markets/aave/commons.ts
View File

@ -1,10 +1,8 @@
import BigNumber from 'bignumber.js';
import {
oneEther,
oneRay,
RAY,
ZERO_ADDRESS,
MOCK_CHAINLINK_AGGREGATORS_PRICES,
oneEther,
} from '../../helpers/constants';
import { ICommonConfiguration, eEthereumNetwork } from '../../helpers/types';
@ -19,6 +17,8 @@ export const CommonsConfig: ICommonConfiguration = {
VariableDebtTokenNamePrefix: 'Aave variable debt bearing',
SymbolPrefix: '',
ProviderId: 0, // Overriden in index.ts
OracleQuoteCurrency: 'ETH',
OracleQuoteUnit: oneEther.toString(),
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
@ -113,7 +113,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
[eEthereumNetwork.tenderly]: undefined,
},
PoolAdminIndex: 0,
EmergencyAdmin: {
@ -123,7 +123,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
[eEthereumNetwork.tenderly]: undefined,
},
EmergencyAdminIndex: 1,
ProviderRegistry: {
@ -133,7 +133,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
[eEthereumNetwork.tenderly]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
},
ProviderRegistryOwner: {
[eEthereumNetwork.kovan]: '0x85e4A467343c0dc4aDAB74Af84448D9c45D8ae6F',
@ -142,7 +142,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0xB9062896ec3A615a4e4444DF183F0531a77218AE',
[eEthereumNetwork.tenderly]: '0xB9062896ec3A615a4e4444DF183F0531a77218AE',
},
LendingRateOracle: {
[eEthereumNetwork.coverage]: '',
@ -151,7 +151,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '', //'0xdCde9Bb6a49e37fA433990832AB541AE2d4FEB4a',
[eEthereumNetwork.ropsten]: '0x05dcca805a6562c1bdd0423768754acb6993241b',
[eEthereumNetwork.main]: '', //'0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
[eEthereumNetwork.tenderlyMain]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
[eEthereumNetwork.tenderly]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
},
LendingPoolCollateralManager: {
[eEthereumNetwork.coverage]: '',
@ -160,7 +160,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x9269b6453d0d75370c4c85e5a42977a53efdb72a',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderlyMain]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderly]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
},
LendingPoolConfigurator: {
[eEthereumNetwork.coverage]: '',
@ -169,7 +169,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
LendingPool: {
[eEthereumNetwork.coverage]: '',
@ -178,7 +178,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
WethGateway: {
[eEthereumNetwork.coverage]: '',
@ -187,7 +187,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
TokenDistributor: {
[eEthereumNetwork.coverage]: '',
@ -196,7 +196,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x971efe90088f21dc6a36f610ffed77fc19710708',
[eEthereumNetwork.ropsten]: '0xeba2ea67942b8250d870b12750b594696d02fc9c',
[eEthereumNetwork.main]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderlyMain]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderly]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
},
AaveOracle: {
[eEthereumNetwork.coverage]: '',
@ -205,7 +205,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '', //'0xB8bE51E6563BB312Cbb2aa26e352516c25c26ac1',
[eEthereumNetwork.ropsten]: ZERO_ADDRESS,
[eEthereumNetwork.main]: '', //'0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
[eEthereumNetwork.tenderlyMain]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
[eEthereumNetwork.tenderly]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
},
FallbackOracle: {
[eEthereumNetwork.coverage]: '',
@ -214,7 +214,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x50913E8E1c650E790F8a1E741FF9B1B1bB251dfe',
[eEthereumNetwork.ropsten]: '0xAD1a978cdbb8175b2eaeC47B01404f8AEC5f4F0d',
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
[eEthereumNetwork.tenderly]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[eEthereumNetwork.coverage]: {},
@ -287,7 +287,7 @@ export const CommonsConfig: ICommonConfiguration = {
USD: '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419',
xSUSHI: '0x9b26214bEC078E68a394AaEbfbffF406Ce14893F',
},
[eEthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderly]: {
AAVE: '0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012',
BAT: '0x0d16d4528239e9ee52fa531af613AcdB23D88c94',
BUSD: '0x614715d2Af89E6EC99A233818275142cE88d1Cfd',
@ -318,7 +318,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.main]: {},
[eEthereumNetwork.kovan]: {},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.tenderlyMain]: {},
[eEthereumNetwork.tenderly]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {
@ -331,7 +331,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
WETH: {
[eEthereumNetwork.coverage]: '', // deployed in local evm
@ -340,7 +340,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
[eEthereumNetwork.ropsten]: '0xc778417e063141139fce010982780140aa0cd5ab',
[eEthereumNetwork.main]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderlyMain]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderly]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
},
WrappedNativeToken: {
[eEthereumNetwork.coverage]: '', // deployed in local evm
@ -349,7 +349,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
[eEthereumNetwork.ropsten]: '0xc778417e063141139fce010982780140aa0cd5ab',
[eEthereumNetwork.main]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderlyMain]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderly]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
},
ReserveFactorTreasuryAddress: {
[eEthereumNetwork.coverage]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
@ -358,7 +358,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.ropsten]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.main]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.tenderlyMain]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.tenderly]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
},
IncentivesController: {
[eEthereumNetwork.coverage]: ZERO_ADDRESS,
@ -367,6 +367,6 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: ZERO_ADDRESS,
[eEthereumNetwork.ropsten]: ZERO_ADDRESS,
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
[eEthereumNetwork.tenderly]: ZERO_ADDRESS,
},
};

2
markets/aave/index.ts
View File

@ -128,7 +128,7 @@ export const AaveConfig: IAaveConfiguration = {
ZRX: '0xE41d2489571d322189246DaFA5ebDe1F4699F498',
xSUSHI: '0x8798249c2E607446EfB7Ad49eC89dD1865Ff4272',
},
[eEthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderly]: {
AAVE: '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
BAT: '0x0d8775f648430679a709e98d2b0cb6250d2887ef',
BUSD: '0x4Fabb145d64652a948d72533023f6E7A623C7C53',

40
markets/aave/reservesConfigs.ts
View File

@ -21,7 +21,7 @@ export const strategyBUSD: IReserveParams = {
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategyDAI: IReserveParams = {
@ -33,7 +33,7 @@ export const strategyDAI: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategySUSD: IReserveParams = {
@ -45,7 +45,7 @@ export const strategySUSD: IReserveParams = {
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyTUSD: IReserveParams = {
@ -57,7 +57,7 @@ export const strategyTUSD: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategyUSDC: IReserveParams = {
@ -69,7 +69,7 @@ export const strategyUSDC: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategyUSDT: IReserveParams = {
@ -81,7 +81,7 @@ export const strategyUSDT: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '6',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategyAAVE: IReserveParams = {
@ -93,7 +93,7 @@ export const strategyAAVE: IReserveParams = {
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '0'
reserveFactor: '0',
};
export const strategyBAT: IReserveParams = {
@ -105,7 +105,7 @@ export const strategyBAT: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyENJ: IReserveParams = {
@ -117,7 +117,7 @@ export const strategyENJ: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyWETH: IReserveParams = {
@ -129,7 +129,7 @@ export const strategyWETH: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '1000'
reserveFactor: '1000',
};
export const strategyKNC: IReserveParams = {
@ -141,7 +141,7 @@ export const strategyKNC: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyLINK: IReserveParams = {
@ -153,7 +153,7 @@ export const strategyLINK: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyMANA: IReserveParams = {
@ -165,7 +165,7 @@ export const strategyMANA: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '3500'
reserveFactor: '3500',
};
export const strategyMKR: IReserveParams = {
@ -177,7 +177,7 @@ export const strategyMKR: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyREN: IReserveParams = {
@ -189,7 +189,7 @@ export const strategyREN: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategySNX: IReserveParams = {
@ -201,7 +201,7 @@ export const strategySNX: IReserveParams = {
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '3500'
reserveFactor: '3500',
};
// Invalid borrow rates in params currently, replaced with snx params
@ -214,7 +214,7 @@ export const strategyUNI: IReserveParams = {
stableBorrowRateEnabled: false,
reserveDecimals: '18',
aTokenImpl: eContractid.DelegationAwareAToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyWBTC: IReserveParams = {
@ -226,7 +226,7 @@ export const strategyWBTC: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '8',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyYFI: IReserveParams = {
@ -238,7 +238,7 @@ export const strategyYFI: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyZRX: IReserveParams = {
@ -250,7 +250,7 @@ export const strategyZRX: IReserveParams = {
stableBorrowRateEnabled: true,
reserveDecimals: '18',
aTokenImpl: eContractid.AToken,
reserveFactor: '2000'
reserveFactor: '2000',
};
export const strategyXSUSHI: IReserveParams = {

41
markets/amm/commons.ts
View File

@ -5,6 +5,7 @@ import {
RAY,
ZERO_ADDRESS,
MOCK_CHAINLINK_AGGREGATORS_PRICES,
oneUsd,
} from '../../helpers/constants';
import { ICommonConfiguration, eEthereumNetwork } from '../../helpers/types';
@ -19,6 +20,8 @@ export const CommonsConfig: ICommonConfiguration = {
VariableDebtTokenNamePrefix: 'Aave AMM Market variable debt',
SymbolPrefix: 'Amm',
ProviderId: 0, // Overriden in index.ts
OracleQuoteCurrency: 'ETH',
OracleQuoteUnit: oneEther.toString(),
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
@ -116,7 +119,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
[eEthereumNetwork.tenderly]: undefined,
},
PoolAdminIndex: 0,
EmergencyAdmin: {
@ -126,7 +129,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: undefined,
[eEthereumNetwork.ropsten]: undefined,
[eEthereumNetwork.main]: undefined,
[eEthereumNetwork.tenderlyMain]: undefined,
[eEthereumNetwork.tenderly]: undefined,
},
EmergencyAdminIndex: 1,
ProviderRegistry: {
@ -136,7 +139,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
[eEthereumNetwork.tenderly]: '0x52D306e36E3B6B02c153d0266ff0f85d18BCD413',
},
ProviderRegistryOwner: {
[eEthereumNetwork.kovan]: '0x85e4A467343c0dc4aDAB74Af84448D9c45D8ae6F',
@ -145,7 +148,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.coverage]: '',
[eEthereumNetwork.hardhat]: '',
[eEthereumNetwork.buidlerevm]: '',
[eEthereumNetwork.tenderlyMain]: '0xB9062896ec3A615a4e4444DF183F0531a77218AE',
[eEthereumNetwork.tenderly]: '0xB9062896ec3A615a4e4444DF183F0531a77218AE',
},
LendingRateOracle: {
[eEthereumNetwork.coverage]: '',
@ -154,7 +157,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0xd00Bd28FAdDa9d5658D1D4e0c151973146C7A533', //'0xE48F95873855bfd97BF89572DDf5cBC44D9c545b'
[eEthereumNetwork.ropsten]: '0x05dcca805a6562c1bdd0423768754acb6993241b',
[eEthereumNetwork.main]: '', //'0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D', // Need to re-deploy because of onlyOwner
[eEthereumNetwork.tenderlyMain]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
[eEthereumNetwork.tenderly]: '0x8A32f49FFbA88aba6EFF96F45D8BD1D4b3f35c7D',
},
LendingPoolCollateralManager: {
[eEthereumNetwork.coverage]: '',
@ -163,7 +166,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x9269b6453d0d75370c4c85e5a42977a53efdb72a',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderlyMain]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
[eEthereumNetwork.tenderly]: '0xbd4765210d4167CE2A5b87280D9E8Ee316D5EC7C',
},
LendingPoolConfigurator: {
[eEthereumNetwork.coverage]: '',
@ -172,7 +175,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x36eB31800aa67a9c50df1d56EE01981A6E14Cce5',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
LendingPool: {
[eEthereumNetwork.coverage]: '',
@ -181,7 +184,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x78142De7a1930412E9e50dEB3b80dB284c2dFa3A',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
WethGateway: {
[eEthereumNetwork.coverage]: '',
@ -190,7 +193,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x1c4A1cC35A477aa1cF35DF671d93ACc04d8131E0',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
TokenDistributor: {
[eEthereumNetwork.coverage]: '',
@ -199,7 +202,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x971efe90088f21dc6a36f610ffed77fc19710708',
[eEthereumNetwork.ropsten]: '0xeba2ea67942b8250d870b12750b594696d02fc9c',
[eEthereumNetwork.main]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderlyMain]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
[eEthereumNetwork.tenderly]: '0xe3d9988f676457123c5fd01297605efdd0cba1ae',
},
AaveOracle: {
[eEthereumNetwork.coverage]: '',
@ -208,7 +211,7 @@ export const CommonsConfig: ICommonConfiguration = {
[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',
[eEthereumNetwork.tenderly]: '0xA50ba011c48153De246E5192C8f9258A2ba79Ca9',
},
FallbackOracle: {
[eEthereumNetwork.coverage]: '',
@ -217,7 +220,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x50913E8E1c650E790F8a1E741FF9B1B1bB251dfe',
[eEthereumNetwork.ropsten]: '0xAD1a978cdbb8175b2eaeC47B01404f8AEC5f4F0d',
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
[eEthereumNetwork.tenderly]: ZERO_ADDRESS,
},
ChainlinkAggregator: {
[eEthereumNetwork.coverage]: {},
@ -270,7 +273,7 @@ export const CommonsConfig: ICommonConfiguration = {
BptBALWETH: '0x2e4e78936b100be6Ef85BCEf7FB25bC770B02B85',
USD: '0x9326BFA02ADD2366b30bacB125260Af641031331',
},
[eEthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderly]: {
USDT: '0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46',
WBTC: '0xdeb288F737066589598e9214E782fa5A8eD689e8',
USDC: '0x986b5E1e1755e3C2440e960477f25201B0a8bbD4',
@ -301,7 +304,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.main]: {},
[eEthereumNetwork.kovan]: {},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.tenderlyMain]: {},
[eEthereumNetwork.tenderly]: {},
},
ReservesConfig: {},
ATokenDomainSeparator: {
@ -314,7 +317,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '',
[eEthereumNetwork.ropsten]: '',
[eEthereumNetwork.main]: '',
[eEthereumNetwork.tenderlyMain]: '',
[eEthereumNetwork.tenderly]: '',
},
WETH: {
[eEthereumNetwork.coverage]: '', // deployed in local evm
@ -323,7 +326,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
[eEthereumNetwork.ropsten]: '0xc778417e063141139fce010982780140aa0cd5ab',
[eEthereumNetwork.main]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderlyMain]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderly]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
},
WrappedNativeToken: {
[eEthereumNetwork.coverage]: '', // deployed in local evm
@ -332,7 +335,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0xd0a1e359811322d97991e03f863a0c30c2cf029c',
[eEthereumNetwork.ropsten]: '0xc778417e063141139fce010982780140aa0cd5ab',
[eEthereumNetwork.main]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderlyMain]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
[eEthereumNetwork.tenderly]: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
},
ReserveFactorTreasuryAddress: {
[eEthereumNetwork.coverage]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
@ -341,7 +344,7 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.ropsten]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.main]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.tenderlyMain]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
[eEthereumNetwork.tenderly]: '0x464c71f6c2f760dda6093dcb91c24c39e5d6e18c',
},
IncentivesController: {
[eEthereumNetwork.coverage]: ZERO_ADDRESS,
@ -350,6 +353,6 @@ export const CommonsConfig: ICommonConfiguration = {
[eEthereumNetwork.kovan]: ZERO_ADDRESS,
[eEthereumNetwork.ropsten]: ZERO_ADDRESS,
[eEthereumNetwork.main]: ZERO_ADDRESS,
[eEthereumNetwork.tenderlyMain]: ZERO_ADDRESS,
[eEthereumNetwork.tenderly]: ZERO_ADDRESS,
},
};

5
markets/amm/index.ts
View File

@ -83,8 +83,7 @@ export const AmmConfig: IAmmConfiguration = {
BptWBTCWETH: '0x110569E3261bC0934dA637b019f6f1b6F50ec574',
BptBALWETH: '0xad01D8e0Fa9EAA8Fe76dA30CFb1BCe12707aE6c5',
},
[eEthereumNetwork.ropsten]: {
},
[eEthereumNetwork.ropsten]: {},
[eEthereumNetwork.main]: {
DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
@ -108,7 +107,7 @@ export const AmmConfig: IAmmConfiguration = {
BptWBTCWETH: '0x1efF8aF5D577060BA4ac8A29A13525bb0Ee2A3D5',
BptBALWETH: '0x59A19D8c652FA0284f44113D0ff9aBa70bd46fB4',
},
[eEthereumNetwork.tenderlyMain]: {
[eEthereumNetwork.tenderly]: {
DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',

33
markets/avalanche/commons.ts
View File

@ -5,6 +5,7 @@ import {
RAY,
ZERO_ADDRESS,
MOCK_CHAINLINK_AGGREGATORS_PRICES,
oneUsd,
} from '../../helpers/constants';
import { ICommonConfiguration, eAvalancheNetwork } from '../../helpers/types';
@ -19,6 +20,8 @@ export const CommonsConfig: ICommonConfiguration = {
VariableDebtTokenNamePrefix: 'Aave Avalanche Market variable debt',
SymbolPrefix: '', // TODO: add a symbol?
ProviderId: 0, // Overriden in index.ts
OracleQuoteCurrency: 'USD',
OracleQuoteUnit: oneUsd.toString(),
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',
@ -78,7 +81,7 @@ export const CommonsConfig: ICommonConfiguration = {
},
ProviderRegistry: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: '0x3C50d48864d0866B854120fd5B6e1CC7783BB92c'
[eAvalancheNetwork.fuji]: '0x2e4c88B23A52Af210619E9FFA4371708E3Bfc286'
},
ProviderRegistryOwner: {
[eAvalancheNetwork.avalanche]: '',
@ -86,15 +89,15 @@ export const CommonsConfig: ICommonConfiguration = {
},
LendingRateOracle: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: '0x82493D29a6CD24cF6C3865Ad5Ef728A6A8920194'
[eAvalancheNetwork.fuji]: '0x0BA6fa6D6800dc900dB82d58D135fD0e0DA1a77A'
},
LendingPoolCollateralManager: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: '0x67abd0a85e1a2eAf10995820C23A455De7E164Af'
[eAvalancheNetwork.fuji]: '0x102035669D37a48689859A9F1cf03F294c8b7f56'
},
LendingPoolConfigurator: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: ''
[eAvalancheNetwork.fuji]: '0x4de9ee3d1F33676e505CA3747993929c29802293'
},
LendingPool: {
[eAvalancheNetwork.avalanche]: '',
@ -102,7 +105,7 @@ export const CommonsConfig: ICommonConfiguration = {
},
WethGateway: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: ''
[eAvalancheNetwork.fuji]: '0xd00ae08403B9bbb9124bB305C09058E32C39A48c'
},
TokenDistributor: {
[eAvalancheNetwork.avalanche]: '',
@ -110,7 +113,7 @@ export const CommonsConfig: ICommonConfiguration = {
},
AaveOracle: {
[eAvalancheNetwork.avalanche]: '',
[eAvalancheNetwork.fuji]: ''
[eAvalancheNetwork.fuji]: '0x7cb1a6663D864eBD5cB0cDA6063FBf5e3A9285eC'
},
FallbackOracle: {
[eAvalancheNetwork.avalanche]: ZERO_ADDRESS,
@ -118,13 +121,13 @@ export const CommonsConfig: ICommonConfiguration = {
},
ChainlinkAggregator: {
[eAvalancheNetwork.avalanche]: {
WETH: '',
DAI: '',
WETH: '0x976B3D034E162d8bD72D6b9C989d545b839003b0',
DAI: '0x51D7180edA2260cc4F6e4EebB82FEF5c3c2B8300',
USDC: '',
USDT: '',
USDT: '0xEBE676ee90Fe1112671f19b6B7459bC678B67e8a',
AAVE: '',
WBTC: ' ',
AVAX: '',
WBTC: '0x2779D32d5166BAaa2B2b658333bA7e6Ec0C65743',
AVAX: '0x0A77230d17318075983913bC2145DB16C7366156',
},
[eAvalancheNetwork.fuji]: {
WETH: '0x86d67c3D38D2bCeE722E601025C25a575021c6EA',
@ -147,12 +150,12 @@ export const CommonsConfig: ICommonConfiguration = {
[eAvalancheNetwork.fuji]: ''
},
WETH: {
[eAvalancheNetwork.avalanche]: '0xf20d962a6c8f70c731bd838a3a388D7d48fA6e15', // TODO: Add WETH address
[eAvalancheNetwork.fuji]: '0x86d67c3D38D2bCeE722E601025C25a575021c6EA'
[eAvalancheNetwork.avalanche]: '0xf20d962a6c8f70c731bd838a3a388D7d48fA6e15', // TODO: ETH Address
[eAvalancheNetwork.fuji]: '0x3b8b3fc85ccA720809Af2dA4B58cF4ce84bcbdd0' // TODO: Mock ETH
},
WrappedNativeToken: {
[eAvalancheNetwork.avalanche]: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
[eAvalancheNetwork.fuji]: '0xd00ae08403B9bbb9124bB305C09058E32C39A48c' // TODO: Add WAVAX address?
[eAvalancheNetwork.avalanche]: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7', // Official WAVAX
[eAvalancheNetwork.fuji]: '0xd00ae08403B9bbb9124bB305C09058E32C39A48c' // Official WAVAX
},
ReserveFactorTreasuryAddress: {
[eAvalancheNetwork.avalanche]: '0x652e2Ac6b072Ba8bF7BEF2B11B092447dBc40bde', // TODO: Deploy Treasury

2
markets/matic/commons.ts
View File

@ -19,6 +19,8 @@ export const CommonsConfig: ICommonConfiguration = {
VariableDebtTokenNamePrefix: 'Aave Matic Market variable debt',
SymbolPrefix: 'm',
ProviderId: 0, // Overriden in index.ts
OracleQuoteCurrency: 'ETH',
OracleQuoteUnit: oneEther.toString(),
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',

1
markets/xdai/commons.ts
View File

@ -19,6 +19,7 @@ export const CommonsConfig: ICommonConfiguration = {
VariableDebtTokenNamePrefix: 'Aave XDAI Market variable debt',
SymbolPrefix: 'm',
ProviderId: 0, // Overriden in index.ts
OracleQuoteCurrency: 'ETH',
ProtocolGlobalParams: {
TokenDistributorPercentageBase: '10000',
MockUsdPriceInWei: '5848466240000000',

2
package-lock.json generated
View File

@ -14793,7 +14793,7 @@
}
},
"ethereumjs-abi": {
"version": "git+https://github.com/ethereumjs/ethereumjs-abi.git#1a27c59c15ab1e95ee8e5c4ed6ad814c49cc439e",
"version": "git+https://github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0",
"from": "git+https://github.com/ethereumjs/ethereumjs-abi.git",
"dev": true,
"requires": {

2
tasks/deployments/add-market-to-registry.ts
View File

@ -40,7 +40,7 @@ task('add-market-to-registry', 'Adds address provider to registry')
) {
console.log('- Deploying a new Address Providers Registry:');
await DRE.run('full:deploy-address-provider-registry', { verify });
await DRE.run('full:deploy-address-provider-registry', { verify, pool });
providerRegistryAddress = (await getLendingPoolAddressesProviderRegistry()).address;
providerRegistryOwner = await (await getFirstSigner()).getAddress();

6
tasks/deployments/deploy-UiPoolDataProvider.ts
View File

@ -1,5 +1,5 @@
import { task } from 'hardhat/config';
import { eContractid, eEthereumNetwork, eNetwork, ePolygonNetwork } from '../../helpers/types';
import { eAvalancheNetwork, eContractid, eEthereumNetwork, eNetwork, ePolygonNetwork } from '../../helpers/types';
import { deployUiPoolDataProvider } from '../../helpers/contracts-deployments';
import { exit } from 'process';
@ -31,6 +31,10 @@ task(`deploy-${eContractid.UiPoolDataProvider}`, `Deploys the UiPoolDataProvider
incentivesController: '0xd41aE58e803Edf4304334acCE4DC4Ec34a63C644',
aaveOracle: '0xC365C653f7229894F93994CD0b30947Ab69Ff1D5',
},
[eAvalancheNetwork.fuji]: {
incentivesController: '0x0000000000000000000000000000000000000000',
aaveOracle: '0xF8a88cE4bd99dcae4634D1b11bBf4554b1B9EaCf',
},
};
const supportedNetworks = Object.keys(addressesByNetwork);

8
tasks/dev/3_lending_pool.ts
View File

@ -1,5 +1,6 @@
import { task } from 'hardhat/config';
import {
deployATokenImplementations,
deployATokensAndRatesHelper,
deployLendingPool,
deployLendingPoolConfigurator,
@ -13,13 +14,15 @@ import {
getLendingPoolConfiguratorProxy,
} from '../../helpers/contracts-getters';
import { insertContractAddressInDb } from '../../helpers/contracts-helpers';
import { ConfigNames, loadPoolConfig } from '../../helpers/configuration';
task('dev:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
.addFlag('verify', 'Verify contracts at Etherscan')
.setAction(async ({ verify }, localBRE) => {
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ verify, pool }, localBRE) => {
await localBRE.run('set-DRE');
const addressesProvider = await getLendingPoolAddressesProvider();
const poolConfig = loadPoolConfig(pool);
const lendingPoolImpl = await deployLendingPool(verify);
@ -55,4 +58,5 @@ task('dev:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
[lendingPoolProxy.address, addressesProvider.address, lendingPoolConfiguratorProxy.address],
verify
);
await deployATokenImplementations(pool, poolConfig.ReservesConfig, verify);
});

17
tasks/dev/4_oracles.ts
View File

@ -12,14 +12,14 @@ import {
import { ICommonConfiguration, iAssetBase, TokenContractId } from '../../helpers/types';
import { waitForTx } from '../../helpers/misc-utils';
import { getAllAggregatorsAddresses, getAllTokenAddresses } from '../../helpers/mock-helpers';
import { ConfigNames, loadPoolConfig, getWethAddress } from '../../helpers/configuration';
import { ConfigNames, loadPoolConfig, getQuoteCurrency } from '../../helpers/configuration';
import {
getAllMockedTokens,
getLendingPoolAddressesProvider,
getPairsTokenAggregator,
} from '../../helpers/contracts-getters';
task('dev:deploy-oracles', 'Deploy oracles for dev enviroment')
task('dev:deploy-oracles', 'Deploy oracles for dev environment')
.addFlag('verify', 'Verify contracts at Etherscan')
.addParam('pool', `Pool name to retrieve configuration, supported: ${Object.values(ConfigNames)}`)
.setAction(async ({ verify, pool }, localBRE) => {
@ -29,6 +29,8 @@ task('dev:deploy-oracles', 'Deploy oracles for dev enviroment')
Mocks: { AllAssetsInitialPrices },
ProtocolGlobalParams: { UsdAddress, MockUsdPriceInWei },
LendingRateOracleRatesCommon,
OracleQuoteCurrency,
OracleQuoteUnit,
} = poolConfig as ICommonConfiguration;
const defaultTokenList = {
@ -54,11 +56,18 @@ task('dev:deploy-oracles', 'Deploy oracles for dev enviroment')
const [tokens, aggregators] = getPairsTokenAggregator(
allTokenAddresses,
allAggregatorsAddresses
allAggregatorsAddresses,
OracleQuoteCurrency
);
await deployAaveOracle(
[tokens, aggregators, fallbackOracle.address, await getWethAddress(poolConfig)],
[
tokens,
aggregators,
fallbackOracle.address,
await getQuoteCurrency(poolConfig),
OracleQuoteUnit,
],
verify
);
await waitForTx(await addressesProvider.setPriceOracle(fallbackOracle.address));

8
tasks/dev/5_initialize.ts
View File

@ -40,6 +40,7 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
VariableDebtTokenNamePrefix,
SymbolPrefix,
WethGateway,
ReservesConfig,
} = poolConfig;
const mockTokens = await getAllMockedTokens();
const allTokenAddresses = getAllTokenAddresses(mockTokens);
@ -52,14 +53,12 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
const testHelpers = await deployAaveProtocolDataProvider(addressesProvider.address, verify);
const reservesParams = getReservesConfigByPool(AavePools.proto);
const admin = await addressesProvider.getPoolAdmin();
const treasuryAddress = await getTreasuryAddress(poolConfig);
await initReservesByHelper(
reservesParams,
ReservesConfig,
protoPoolReservesAddresses,
ATokenNamePrefix,
StableDebtTokenNamePrefix,
@ -68,9 +67,10 @@ task('dev:initialize-lending-pool', 'Initialize lending pool configuration.')
admin,
treasuryAddress,
ZERO_ADDRESS,
pool,
verify
);
await configureReservesByHelper(reservesParams, protoPoolReservesAddresses, testHelpers, admin);
await configureReservesByHelper(ReservesConfig, protoPoolReservesAddresses, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager(verify);
await waitForTx(

4
tasks/full/2_lending_pool.ts
View File

@ -1,6 +1,7 @@
import { task } from 'hardhat/config';
import { getParamPerNetwork, insertContractAddressInDb } from '../../helpers/contracts-helpers';
import {
deployATokenImplementations,
deployATokensAndRatesHelper,
deployLendingPool,
deployLendingPoolConfigurator,
@ -78,11 +79,12 @@ task('full:deploy-lending-pool', 'Deploy lending pool for dev enviroment')
[lendingPoolProxy.address, addressesProvider.address, lendingPoolConfiguratorProxy.address],
verify
);
await deployATokenImplementations(pool, poolConfig.ReservesConfig, verify);
} catch (error) {
if (DRE.network.name.includes('tenderly')) {
const transactionLink = `https://dashboard.tenderly.co/${DRE.config.tenderly.username}/${
DRE.config.tenderly.project
}/fork/${DRE.tenderlyNetwork.getFork()}/simulation/${DRE.tenderlyNetwork.getHead()}`;
}/fork/${DRE.tenderly.network().getFork()}/simulation/${DRE.tenderly.network().getHead()}`;
console.error('Check tx error:', transactionLink);
}
throw error;

21
tasks/full/3_oracles.ts
View File

@ -7,9 +7,9 @@ import { waitForTx, notFalsyOrZeroAddress } from '../../helpers/misc-utils';
import {
ConfigNames,
loadPoolConfig,
getWethAddress,
getGenesisPoolAdmin,
getLendingRateOracles,
getQuoteCurrency,
} from '../../helpers/configuration';
import {
getAaveOracle,
@ -46,16 +46,27 @@ task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
...reserveAssets,
USD: UsdAddress,
};
const [tokens, aggregators] = getPairsTokenAggregator(tokensToWatch, chainlinkAggregators);
const [tokens, aggregators] = getPairsTokenAggregator(
tokensToWatch,
chainlinkAggregators,
poolConfig.OracleQuoteCurrency
);
let aaveOracle: AaveOracle;
let lendingRateOracle: LendingRateOracle;
if (notFalsyOrZeroAddress(aaveOracleAddress)) {
aaveOracle = await await getAaveOracle(aaveOracleAddress);
await waitForTx(await aaveOracle.setAssetSources(tokens, aggregators));
} else {
aaveOracle = await deployAaveOracle(
[tokens, aggregators, fallbackOracleAddress, await getWethAddress(poolConfig)],
[
tokens,
aggregators,
fallbackOracleAddress,
await getQuoteCurrency(poolConfig),
poolConfig.OracleQuoteUnit,
],
verify
);
await waitForTx(await aaveOracle.setAssetSources(tokens, aggregators));
@ -74,7 +85,7 @@ task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
);
}
console.log('Aave Oracle: %s', lendingRateOracle.address);
console.log('Aave Oracle: %s', aaveOracle.address);
console.log('Lending Rate Oracle: %s', lendingRateOracle.address);
// Register the proxy price provider on the addressesProvider
@ -84,7 +95,7 @@ task('full:deploy-oracles', 'Deploy oracles for dev enviroment')
if (DRE.network.name.includes('tenderly')) {
const transactionLink = `https://dashboard.tenderly.co/${DRE.config.tenderly.username}/${
DRE.config.tenderly.project
}/fork/${DRE.tenderlyNetwork.getFork()}/simulation/${DRE.tenderlyNetwork.getHead()}`;
}/fork/${DRE.tenderly.network().getFork()}/simulation/${DRE.tenderly.network().getHead()}`;
console.error('Check tx error:', transactionLink);
}
throw error;

1
tasks/full/6-initialize.ts
View File

@ -66,6 +66,7 @@ task('full:initialize-lending-pool', 'Initialize lending pool configuration.')
admin,
treasuryAddress,
incentivesController,
pool,
verify
);
await configureReservesByHelper(ReservesConfig, reserveAssets, testHelpers, admin);

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

@ -3,9 +3,9 @@ import { eEthereumNetwork } from '../../helpers/types';
import { getTreasuryAddress } from '../../helpers/configuration';
import * as marketConfigs from '../../markets/aave';
import * as reserveConfigs from '../../markets/aave/reservesConfigs';
import { chooseATokenDeployment } from '../../helpers/init-helpers';
import { getLendingPoolAddressesProvider } from './../../helpers/contracts-getters';
import {
chooseATokenDeployment,
deployDefaultReserveInterestRateStrategy,
deployStableDebtToken,
deployVariableDebtToken,
@ -47,18 +47,7 @@ WRONG RESERVE ASSET SETUP:
LENDING_POOL_ADDRESS_PROVIDER[network]
);
const poolAddress = await addressProvider.getLendingPool();
const treasuryAddress = await getTreasuryAddress(marketConfigs.AaveConfig);
const aToken = await deployCustomAToken(
[
poolAddress,
reserveAssetAddress,
treasuryAddress,
ZERO_ADDRESS, // Incentives Controller
`Aave interest bearing ${symbol}`,
`a${symbol}`,
],
verify
);
const aToken = await deployCustomAToken(verify);
const stableDebt = await deployStableDebtToken(
[
poolAddress,

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

@ -24,7 +24,7 @@ task('aave:dev', 'Deploy development enviroment')
await localBRE.run('dev:deploy-address-provider', { verify });
console.log('3. Deploy lending pool');
await localBRE.run('dev:deploy-lending-pool', { verify });
await localBRE.run('dev:deploy-lending-pool', { verify, pool: POOL_NAME });
console.log('4. Deploy oracles');
await localBRE.run('dev:deploy-oracles', { verify, pool: POOL_NAME });

55
test-suites/test-aave/__setup.spec.ts
View File

@ -13,7 +13,7 @@ import {
deployLendingPoolConfigurator,
deployLendingPool,
deployPriceOracle,
deployAaveOracle,
deployAaveOracleV2,
deployLendingPoolCollateralManager,
deployMockFlashLoanReceiver,
deployWalletBalancerProvider,
@ -28,8 +28,8 @@ import {
deployUniswapRepayAdapter,
deployFlashLiquidationAdapter,
authorizeWETHGateway,
deployATokenImplementations,
} 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';
@ -49,7 +49,7 @@ import {
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 { oneEther, ZERO_ADDRESS } from '../../helpers/constants';
import {
getLendingPool,
getLendingPoolConfiguratorProxy,
@ -60,7 +60,6 @@ import { WETH9Mocked } from '../../types/WETH9Mocked';
const MOCK_USD_PRICE_IN_WEI = AaveConfig.ProtocolGlobalParams.MockUsdPriceInWei;
const ALL_ASSETS_INITIAL_PRICES = AaveConfig.Mocks.AllAssetsInitialPrices;
const USD_ADDRESS = AaveConfig.ProtocolGlobalParams.UsdAddress;
const MOCK_CHAINLINK_AGGREGATORS_PRICES = AaveConfig.Mocks.AllAssetsInitialPrices;
const LENDING_RATE_ORACLE_RATES_COMMON = AaveConfig.LendingRateOracleRatesCommon;
const deployAllMockTokens = async (deployer: Signer) => {
@ -96,9 +95,13 @@ const deployAllMockTokens = async (deployer: Signer) => {
const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
console.time('setup');
const aaveAdmin = await deployer.getAddress();
const config = loadPoolConfig(ConfigNames.Aave);
const mockTokens = await deployAllMockTokens(deployer);
console.log('Deployed mocks');
const mockTokens: {
[symbol: string]: MockContract | MintableERC20 | WETH9Mocked;
} = {
...(await deployAllMockTokens(deployer)),
};
const addressesProvider = await deployLendingPoolAddressesProvider(AaveConfig.MarketId);
await waitForTx(await addressesProvider.setPoolAdmin(aaveAdmin));
@ -196,8 +199,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
fallbackOracle
);
const mockAggregators = await deployAllMockAggregators(MOCK_CHAINLINK_AGGREGATORS_PRICES);
console.log('Mock aggs deployed');
const mockAggregators = await deployAllMockAggregators(ALL_ASSETS_INITIAL_PRICES);
const allTokenAddresses = Object.entries(mockTokens).reduce(
(accum: { [tokenSymbol: string]: tEthereumAddress }, [tokenSymbol, tokenContract]) => ({
...accum,
@ -213,9 +215,19 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
{}
);
const [tokens, aggregators] = getPairsTokenAggregator(allTokenAddresses, allAggregatorsAddresses);
const [tokens, aggregators] = getPairsTokenAggregator(
allTokenAddresses,
allAggregatorsAddresses,
config.OracleQuoteCurrency
);
await deployAaveOracle([tokens, aggregators, fallbackOracle.address, mockTokens.WETH.address]);
await deployAaveOracleV2([
tokens,
aggregators,
fallbackOracle.address,
mockTokens.WETH.address,
oneEther.toString(),
]);
await waitForTx(await addressesProvider.setPriceOracle(fallbackOracle.address));
const lendingRateOracle = await deployLendingRateOracle();
@ -232,23 +244,19 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
aaveAdmin
);
const reservesParams = getReservesConfigByPool(AavePools.proto);
// Reserve params from AAVE pool + mocked tokens
const reservesParams = {
...config.ReservesConfig,
};
const testHelpers = await deployAaveProtocolDataProvider(addressesProvider.address);
await insertContractAddressInDb(eContractid.AaveProtocolDataProvider, testHelpers.address);
await deployATokenImplementations(ConfigNames.Aave, reservesParams, false);
const admin = await deployer.getAddress();
console.log('Initialize configuration');
const config = loadPoolConfig(ConfigNames.Aave);
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
} = config;
const { ATokenNamePrefix, StableDebtTokenNamePrefix, VariableDebtTokenNamePrefix, SymbolPrefix } =
config;
const treasuryAddress = await getTreasuryAddress(config);
await initReservesByHelper(
@ -261,6 +269,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
admin,
treasuryAddress,
ZERO_ADDRESS,
ConfigNames.Aave,
false
);
@ -298,7 +307,7 @@ before(async () => {
const FORK = process.env.FORK;
if (FORK) {
await rawBRE.run('aave:mainnet');
await rawBRE.run('aave:mainnet', { skipRegistry: true });
} else {
console.log('-> Deploying test environment...');
await buildTestEnv(deployer, secondaryWallet);

46
test-suites/test-amm/__setup.spec.ts
View File

@ -13,7 +13,7 @@ import {
deployLendingPoolConfigurator,
deployLendingPool,
deployPriceOracle,
deployAaveOracle,
deployAaveOracleV2,
deployLendingPoolCollateralManager,
deployMockFlashLoanReceiver,
deployWalletBalancerProvider,
@ -28,6 +28,7 @@ import {
deployUniswapRepayAdapter,
deployFlashLiquidationAdapter,
authorizeWETHGateway,
deployATokenImplementations,
} from '../../helpers/contracts-deployments';
import { Signer } from 'ethers';
import { TokenContractId, eContractid, tEthereumAddress, AavePools } from '../../helpers/types';
@ -48,7 +49,7 @@ import {
import { DRE, waitForTx } from '../../helpers/misc-utils';
import { initReservesByHelper, configureReservesByHelper } from '../../helpers/init-helpers';
import AmmConfig from '../../markets/amm';
import { ZERO_ADDRESS } from '../../helpers/constants';
import { oneEther, ZERO_ADDRESS } from '../../helpers/constants';
import {
getLendingPool,
getLendingPoolConfiguratorProxy,
@ -95,6 +96,14 @@ const deployAllMockTokens = async (deployer: Signer) => {
const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
console.time('setup');
const aaveAdmin = await deployer.getAddress();
const config = loadPoolConfig(ConfigNames.Amm);
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
ReservesConfig,
} = config;
const mockTokens = await deployAllMockTokens(deployer);
@ -189,6 +198,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
WMATIC: mockTokens.WMATIC.address,
USD: USD_ADDRESS,
STAKE: mockTokens.STAKE.address,
xSUSHI: ZERO_ADDRESS,
},
fallbackOracle
);
@ -210,9 +220,19 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
{}
);
const [tokens, aggregators] = getPairsTokenAggregator(allTokenAddresses, allAggregatorsAddresses);
const [tokens, aggregators] = getPairsTokenAggregator(
allTokenAddresses,
allAggregatorsAddresses,
config.OracleQuoteCurrency
);
await deployAaveOracle([tokens, aggregators, fallbackOracle.address, mockTokens.WETH.address]);
await deployAaveOracleV2([
tokens,
aggregators,
fallbackOracle.address,
mockTokens.WETH.address,
oneEther.toString(),
]);
await waitForTx(await addressesProvider.setPriceOracle(fallbackOracle.address));
const lendingRateOracle = await deployLendingRateOracle();
@ -228,8 +248,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
lendingRateOracle,
aaveAdmin
);
const reservesParams = getReservesConfigByPool(AavePools.amm);
await deployATokenImplementations(ConfigNames.Amm, ReservesConfig);
const testHelpers = await deployAaveProtocolDataProvider(addressesProvider.address);
@ -238,18 +257,10 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
console.log('Initialize configuration');
const config = loadPoolConfig(ConfigNames.Amm);
const {
ATokenNamePrefix,
StableDebtTokenNamePrefix,
VariableDebtTokenNamePrefix,
SymbolPrefix,
} = config;
const treasuryAddress = await getTreasuryAddress(config);
await initReservesByHelper(
reservesParams,
ReservesConfig,
allReservesAddresses,
ATokenNamePrefix,
StableDebtTokenNamePrefix,
@ -258,9 +269,10 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
admin,
treasuryAddress,
ZERO_ADDRESS,
ConfigNames.Amm,
false
);
await configureReservesByHelper(reservesParams, allReservesAddresses, testHelpers, admin);
await configureReservesByHelper(ReservesConfig, allReservesAddresses, testHelpers, admin);
const collateralManager = await deployLendingPoolCollateralManager();
await waitForTx(
@ -294,7 +306,7 @@ before(async () => {
const FORK = process.env.FORK;
if (FORK) {
await rawBRE.run('amm:mainnet');
await rawBRE.run('amm:mainnet', { skipRegistry: true });
} else {
console.log('-> Deploying test environment...');
await buildTestEnv(deployer, secondaryWallet);