Merge pull request #126 from aave/feat/defender-integration

Add OpenZeppelin Defender Integration

Author: The-3D

docker-compose.yml

@@ -21,3 +21,5 @@ services:
       ALCHEMY_KEY: ${ALCHEMY_KEY}
       TENDERLY_FORK_ID: ${TENDERLY_FORK_ID}
       TENDERLY_HEAD_ID: ${TENDERLY_HEAD_ID}
+      DEFENDER_API_KEY: ${DEFENDER_API_KEY}
+      DEFENDER_SECRET_KEY: ${DEFENDER_SECRET_KEY}

helpers/configuration.ts

@@ -6,7 +6,7 @@ import {
   ICommonConfiguration,
   eNetwork,
 } from './types';
-import { getParamPerPool } from './contracts-helpers';
+import { getEthersSignersAddresses, getParamPerPool } from './contracts-helpers';
 import AaveConfig from '../markets/aave';
 import MaticConfig from '../markets/matic';
 import AmmConfig from '../markets/amm';
@@ -66,9 +66,7 @@ export const getGenesisPoolAdmin = async (
   if (targetAddress) {
     return targetAddress;
   }
-  const addressList = await Promise.all(
-    (await DRE.ethers.getSigners()).map((signer) => signer.getAddress())
-  );
+  const addressList = await getEthersSignersAddresses();
   const addressIndex = config.PoolAdminIndex;
   return addressList[addressIndex];
 };
@@ -81,9 +79,7 @@ export const getEmergencyAdmin = async (
   if (targetAddress) {
     return targetAddress;
   }
-  const addressList = await Promise.all(
-    (await DRE.ethers.getSigners()).map((signer) => signer.getAddress())
-  );
+  const addressList = await getEthersSignersAddresses();
   const addressIndex = config.EmergencyAdminIndex;
   return addressList[addressIndex];
 };

helpers/contracts-deployments.ts

@@ -137,7 +137,9 @@ export const deployGenericLogic = async (reserveLogic: Contract, verify?: boolea
     linkedGenericLogicByteCode
   );
 
-  const genericLogic = await (await genericLogicFactory.deploy()).deployed();
+  const genericLogic = await (
+    await genericLogicFactory.connect(await getFirstSigner()).deploy()
+  ).deployed();
   return withSaveAndVerify(genericLogic, eContractid.GenericLogic, [], verify);
 };
 
@@ -158,7 +160,9 @@ export const deployValidationLogic = async (
     linkedValidationLogicByteCode
   );
 
-  const validationLogic = await (await validationLogicFactory.deploy()).deployed();
+  const validationLogic = await (
+    await validationLogicFactory.connect(await getFirstSigner()).deploy()
+  ).deployed();
 
   return withSaveAndVerify(validationLogic, eContractid.ValidationLogic, [], verify);
 };

helpers/contracts-getters.ts

@@ -32,11 +32,11 @@ import {
   FlashLiquidationAdapterFactory,
 } from '../types';
 import { IERC20DetailedFactory } from '../types/IERC20DetailedFactory';
-import { MockTokenMap } from './contracts-helpers';
+import { getEthersSigners, MockTokenMap } from './contracts-helpers';
 import { DRE, getDb, notFalsyOrZeroAddress } from './misc-utils';
 import { eContractid, PoolConfiguration, tEthereumAddress, TokenContractId } from './types';
 
-export const getFirstSigner = async () => (await DRE.ethers.getSigners())[0];
+export const getFirstSigner = async () => (await getEthersSigners())[0];
 
 export const getLendingPoolAddressesProvider = async (address?: tEthereumAddress) => {
   return await LendingPoolAddressesProviderFactory.connect(

helpers/contracts-helpers.ts

@@ -23,9 +23,10 @@ import { MintableERC20 } from '../types/MintableERC20';
 import { Artifact } from 'hardhat/types';
 import { Artifact as BuidlerArtifact } from '@nomiclabs/buidler/types';
 import { verifyEtherscanContract } from './etherscan-verification';
-import { getIErc20Detailed } from './contracts-getters';
+import { getFirstSigner, getIErc20Detailed } from './contracts-getters';
 import { usingTenderly, verifyAtTenderly } from './tenderly-utils';
 import { usingPolygon, verifyAtPolygon } from './polygon-utils';
+import { getDefenderRelaySigner, usingDefender } from './defender-utils';
 
 export type MockTokenMap = { [symbol: string]: MintableERC20 };
 
@@ -66,11 +67,18 @@ export const rawInsertContractAddressInDb = async (id: string, address: tEthereu
     })
     .write();
 
-export const getEthersSigners = async (): Promise<Signer[]> =>
-  await Promise.all(await DRE.ethers.getSigners());
+export const getEthersSigners = async (): Promise<Signer[]> => {
+  const ethersSigners = await Promise.all(await DRE.ethers.getSigners());
+
+  if (usingDefender()) {
+    const [, ...users] = ethersSigners;
+    return [await getDefenderRelaySigner(), ...users];
+  }
+  return ethersSigners;
+};
 
 export const getEthersSignersAddresses = async (): Promise<tEthereumAddress[]> =>
-  await Promise.all((await DRE.ethers.getSigners()).map((signer) => signer.getAddress()));
+  await Promise.all((await getEthersSigners()).map((signer) => signer.getAddress()));
 
 export const getCurrentBlock = async () => {
   return DRE.ethers.provider.getBlockNumber();
@@ -83,9 +91,9 @@ export const deployContract = async <ContractType extends Contract>(
   contractName: string,
   args: any[]
 ): Promise<ContractType> => {
-  const contract = (await (await DRE.ethers.getContractFactory(contractName)).deploy(
-    ...args
-  )) as ContractType;
+  const contract = (await (await DRE.ethers.getContractFactory(contractName))
+    .connect(await getFirstSigner())
+    .deploy(...args)) as ContractType;
   await waitForTx(contract.deployTransaction);
   await registerContractInJsonDb(<eContractid>contractName, contract);
   return contract;

helpers/defender-utils.ts

@@ -0,0 +1,41 @@
+import { formatEther } from '@ethersproject/units';
+import { DefenderRelaySigner, DefenderRelayProvider } from 'defender-relay-client/lib/ethers';
+import { Signer } from 'ethers';
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { DRE, impersonateAccountsHardhat } from './misc-utils';
+import { usingTenderly } from './tenderly-utils';
+
+export const usingDefender = () => process.env.DEFENDER === 'true';
+
+export const getDefenderRelaySigner = async () => {
+  const { DEFENDER_API_KEY, DEFENDER_SECRET_KEY } = process.env;
+  let defenderSigner: Signer;
+
+  if (!DEFENDER_API_KEY || !DEFENDER_SECRET_KEY) {
+    throw new Error('Defender secrets required');
+  }
+
+  const credentials = { apiKey: DEFENDER_API_KEY, apiSecret: DEFENDER_SECRET_KEY };
+
+  defenderSigner = new DefenderRelaySigner(credentials, new DefenderRelayProvider(credentials), {
+    speed: 'fast',
+  });
+
+  const defenderAddress = await defenderSigner.getAddress();
+  console.log('  - Using Defender Relay: ', defenderAddress);
+
+  // Replace signer if FORK=main is active
+  if (process.env.FORK === 'main') {
+    console.log('  - Impersonating Defender Relay');
+    await impersonateAccountsHardhat([defenderAddress]);
+    defenderSigner = await (DRE as HardhatRuntimeEnvironment).ethers.getSigner(defenderAddress);
+  }
+  // Replace signer if Tenderly network is active
+  if (usingTenderly()) {
+    console.log('  - Impersonating Defender Relay via Tenderly');
+    defenderSigner = await (DRE as HardhatRuntimeEnvironment).ethers.getSigner(defenderAddress);
+  }
+  console.log('  - Balance: ', formatEther(await defenderSigner.getBalance()));
+
+  return defenderSigner;
+};

helpers/misc-utils.ts

@@ -115,3 +115,17 @@ export const notFalsyOrZeroAddress = (address: tEthereumAddress | null | undefin
   }
   return isAddress(address) && !isZeroAddress(address);
 };
+
+export const impersonateAccountsHardhat = async (accounts: string[]) => {
+  if (process.env.TENDERLY === 'true') {
+    return;
+  }
+  // eslint-disable-next-line no-restricted-syntax
+  for (const account of accounts) {
+    // eslint-disable-next-line no-await-in-loop
+    await (DRE as HardhatRuntimeEnvironment).network.provider.request({
+      method: 'hardhat_impersonateAccount',
+      params: [account],
+    });
+  }
+};

helpers/tenderly-utils.ts

@@ -9,7 +9,7 @@ export const usingTenderly = () =>
 
 export const verifyAtTenderly = async (id: string, instance: Contract) => {
   console.log('\n- Doing Tenderly contract verification of', id);
-  await (DRE as any).tenderlyRPC.verify({
+  await (DRE as any).tenderlyNetwork.verify({
     name: id,
     address: instance.address,
   });