feat: Add helper contract to manage risk params of GHO reserve (#291)

* setup modifier

* setup gho manager and tests

* remove atoken changes

* use interfaces

* adds test for ghomanager as pooladmin

deploy/10_deploy_ghomanager.ts

@@ -0,0 +1,23 @@
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { DeployFunction } from 'hardhat-deploy/types';
+const func: DeployFunction = async function ({
+  getNamedAccounts,
+  deployments,
+}: HardhatRuntimeEnvironment) {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const ghoManager = await deploy('GhoManager', {
+    from: deployer,
+    args: [],
+    log: true,
+  });
+  console.log(`GHO Manager:               ${ghoManager.address}`);
+
+  return true;
+};
+
+func.id = 'GhoManager';
+func.tags = ['GhoManager', 'full_gho_deploy'];
+
+export default func;

src/contracts/facilitators/aave/misc/GhoManager.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';
+import {IPoolConfigurator} from '@aave/core-v3/contracts/interfaces/IPoolConfigurator.sol';
+import {IGhoVariableDebtToken} from 'src/contracts/facilitators/aave/tokens/interfaces/IGhoVariableDebtToken.sol';
+
+/**
+ * @title GhoManager
+ * @author Aave
+ * @notice Helper contract for managing key risk parameters of the GHO reserve within the Aave Facilitator
+ * @dev This contract is intended to be granted as PoolAdmin
+ */
+contract GhoManager is Ownable {
+  /**
+   * @notice Updates the Discount Rate Strategy
+   * @param ghoVariableDebtToken The address of GhoVariableDebtToken contract
+   * @param newDiscountRateStrategy The address of DiscountRateStrategy contract
+   */
+  function updateDiscountRateStrategy(
+    address ghoVariableDebtToken,
+    address newDiscountRateStrategy
+  ) external onlyOwner {
+    IGhoVariableDebtToken(ghoVariableDebtToken).updateDiscountRateStrategy(newDiscountRateStrategy);
+  }
+
+  /**
+   * @notice Updates the Discount Lock Period
+   * @param ghoVariableDebtToken The address of GhoVariableDebtToken contract
+   * @param newLockPeriod The new discount lock period (in seconds)
+   */
+  function updateDiscountLockPeriod(
+    address ghoVariableDebtToken,
+    uint256 newLockPeriod
+  ) external onlyOwner {
+    IGhoVariableDebtToken(ghoVariableDebtToken).updateDiscountLockPeriod(newLockPeriod);
+  }
+
+  /**
+   * @notice Updates the ReserveInterestRateStrategy
+   * @param poolConfigurator The address of PoolConfigurator contract
+   * @param asset The address of the GHO deployed contract
+   * @param newRateStrategyAddress The address of new RateStrategyAddress contract
+   */
+  function setReserveInterestRateStrategyAddress(
+    address poolConfigurator,
+    address asset,
+    address newRateStrategyAddress
+  ) external onlyOwner {
+    IPoolConfigurator(poolConfigurator).setReserveInterestRateStrategyAddress(
+      asset,
+      newRateStrategyAddress
+    );
+  }
+}

src/helpers/contract-getters.ts

@@ -22,6 +22,7 @@ import {
   VariableDebtToken,
   StakedTokenV2Rev4,
   GhoFlashMinter,
+  GhoManager,
 } from '../../types';
 
 // Prevent error HH9 when importing this file inside tasks or helpers at Hardhat config load
@@ -67,6 +68,9 @@ export const getGhoVariableDebtToken = async (
     address || (await hre.deployments.get('GhoVariableDebtToken')).address
   );
 
+export const getGhoManager = async (address?: tEthereumAddress): Promise<GhoManager> =>
+  getContract('GhoManager', address || (await hre.deployments.get('GhoManager')).address);
+
 export const getBaseImmutableAdminUpgradeabilityProxy = async (
   address: tEthereumAddress
 ): Promise<BaseImmutableAdminUpgradeabilityProxy> =>

src/tasks/main/gho-testnet-setup.ts

@@ -43,6 +43,13 @@ task('gho-testnet-setup', 'Deploy and Configure Gho').setAction(async (params, h
   blankSpace();
   await hre.run('upgrade-stkAave');
 
+  /*****************************************
+   *               CONFIGURE Ghomanager          *
+   ******************************************/
+  blankSpace();
+
+  await hre.run('add-gho-manager');
+
   console.log(`\nGho Setup Complete!\n`);
 
   await hre.run('print-all-deployments');

src/tasks/testnet-setup/07_add-gho-manager.ts

@@ -0,0 +1,23 @@
+import { GhoManager } from '../../../types/src/contracts/facilitators/aave/misc/GhoManager';
+import { task } from 'hardhat/config';
+import { ghoEntityConfig } from '../../helpers/config';
+import { getACLManager } from '@aave/deploy-v3';
+
+task('add-gho-manager', 'Adds ghomanager pooladmin role').setAction(async (_, hre) => {
+  const { ethers } = hre;
+
+  const ghoManager = (await ethers.getContract('GhoManager')) as GhoManager;
+  const aclArtifact = await getACLManager();
+  const addPoolAdminTx = await aclArtifact.addPoolAdmin(ghoManager.address);
+
+  const addPoolAdminTxReceipt = await addPoolAdminTx.wait();
+  const newPoolAdminEvents = addPoolAdminTxReceipt.events?.find((e) => {
+    return e.event === 'RoleGranted';
+  });
+  if (newPoolAdminEvents?.args) {
+    console.log(`Gho manager added as a pooladmin: ${JSON.stringify(newPoolAdminEvents.args[0])}`);
+  } else {
+    throw new Error(`Error at adding entity. Check tx: ${addPoolAdminTx.hash}`);
+  }
+  return;
+});

src/test/gho-manager.test.ts

@@ -0,0 +1,117 @@
+import hre from 'hardhat';
+import { expect } from 'chai';
+import { makeSuite, TestEnv } from './helpers/make-suite';
+import { impersonateAccountHardhat } from '../helpers/misc-utils';
+import { ghoReserveConfig } from '../helpers/config';
+import { ONE_ADDRESS, ZERO_ADDRESS } from '../helpers/constants';
+import { ProtocolErrors } from '@aave/core-v3';
+import { getPoolConfiguratorProxy } from '@aave/deploy-v3';
+
+export const TWO_ADDRESS = '0x0000000000000000000000000000000000000002';
+
+makeSuite('Gho Manager End-To-End', (testEnv: TestEnv) => {
+  let ethers;
+
+  let poolSigner;
+  let randomSigner;
+  let poolConfigurator;
+
+  const mockLockPeriod = 3;
+
+  before(async () => {
+    ethers = hre.ethers;
+
+    const { pool } = testEnv;
+
+    poolSigner = await impersonateAccountHardhat(pool.address);
+    randomSigner = await impersonateAccountHardhat(ONE_ADDRESS);
+    poolConfigurator = await getPoolConfiguratorProxy();
+  });
+
+  it('Update discount rate strategy from gho manager', async function () {
+    const { variableDebtToken, deployer, discountRateStrategy, ghoManager } = testEnv;
+
+    await expect(
+      ghoManager
+        .connect(deployer.signer)
+        .updateDiscountRateStrategy(variableDebtToken.address, TWO_ADDRESS)
+    ).to.emit(variableDebtToken, 'DiscountRateStrategyUpdated');
+  });
+
+  it('Get Discount Strategy - after setting', async function () {
+    const { variableDebtToken } = testEnv;
+
+    expect(await variableDebtToken.getDiscountRateStrategy()).to.be.equal(TWO_ADDRESS);
+  });
+
+  it('Update discount rate strategy from gho manager without owner role (revert expected)', async function () {
+    const { variableDebtToken, deployer, discountRateStrategy, ghoManager } = testEnv;
+
+    await expect(
+      ghoManager
+        .connect(randomSigner)
+        .updateDiscountRateStrategy(variableDebtToken.address, ONE_ADDRESS)
+    ).to.be.revertedWith(ProtocolErrors.OWNABLE_ONLY_OWNER);
+  });
+
+  it('Set Rebalance Lock Period', async function () {
+    const { ghoManager, deployer, variableDebtToken } = testEnv;
+
+    await expect(
+      ghoManager
+        .connect(deployer.signer)
+        .updateDiscountLockPeriod(variableDebtToken.address, mockLockPeriod)
+    )
+      .to.emit(variableDebtToken, 'DiscountLockPeriodUpdated')
+      .withArgs(ghoReserveConfig.DISCOUNT_LOCK_PERIOD, mockLockPeriod);
+  });
+
+  it('Get Rebalance Lock Period', async function () {
+    const { variableDebtToken } = testEnv;
+    expect(await variableDebtToken.getDiscountLockPeriod()).to.be.equal(mockLockPeriod);
+  });
+
+  it('Updates gho interest rate strategy', async function () {
+    const { ghoManager, variableDebtToken, gho, poolAdmin } = testEnv;
+    const randomAddress = ONE_ADDRESS;
+    await expect(
+      ghoManager
+        .connect(poolAdmin.signer)
+        .setReserveInterestRateStrategyAddress(poolConfigurator.address, gho.address, randomAddress)
+    ).to.emit(poolConfigurator, 'ReserveInterestRateStrategyChanged');
+  });
+
+  it('Check gho interest rate strategy is set correctly', async function () {
+    const { variableDebtToken, gho, poolAdmin, aaveDataProvider } = testEnv;
+    const randomAddress = ONE_ADDRESS;
+    await expect(await aaveDataProvider.getInterestRateStrategyAddress(gho.address)).to.be.equal(
+      randomAddress
+    );
+  });
+
+  it('Check permissions of owner modified functions (revert expected)', async () => {
+    const { variableDebtToken, users, ghoManager, gho } = testEnv;
+    const nonPoolAdmin = users[2];
+
+    const randomAddress = ONE_ADDRESS;
+    const randomNumber = '0';
+    const calls = [
+      { fn: 'updateDiscountRateStrategy', args: [variableDebtToken.address, randomAddress] },
+      { fn: 'updateDiscountLockPeriod', args: [variableDebtToken.address, randomNumber] },
+      {
+        fn: 'setReserveInterestRateStrategyAddress',
+        args: [poolConfigurator.address, gho.address, randomAddress],
+      },
+    ];
+    for (const call of calls) {
+      await expect(
+        ghoManager.connect(nonPoolAdmin.signer)[call.fn](...call.args)
+      ).to.be.revertedWith(ProtocolErrors.OWNABLE_ONLY_OWNER);
+    }
+  });
+
+  it('Check GhoManager is PoolAdmin', async function () {
+    const { ghoManager, aclManager } = testEnv;
+    await expect(await aclManager.isPoolAdmin(ghoManager.address)).to.be.equal(true);
+  });
+});

src/test/helpers/make-suite.ts

@@ -20,6 +20,7 @@ import {
   StakedTokenV2Rev4,
   MintableERC20,
   GhoFlashMinter,
+  GhoManager,
 } from '../../../types';
 import {
   getGhoDiscountRateStrategy,
@@ -32,6 +33,7 @@ import {
   getStakedAave,
   getMintableErc20,
   getGhoFlashMinter,
+  getGhoManager,
 } from '../../helpers/contract-getters';
 import {
   getPool,
@@ -85,6 +87,7 @@ export interface TestEnv {
   aaveToken: IERC20;
   flashMinter: GhoFlashMinter;
   faucetOwner: Faucet;
+  ghoManager: GhoManager;
 }
 
 let HardhatSnapshotId: string = '0x1';
@@ -122,6 +125,7 @@ const testEnv: TestEnv = {
   aaveToken: {} as IERC20,
   flashMinter: {} as GhoFlashMinter,
   faucetOwner: {} as Faucet,
+  ghoManager: {} as GhoManager,
 } as TestEnv;
 
 export async function initializeMakeSuite() {
@@ -164,6 +168,8 @@ export async function initializeMakeSuite() {
     tokenProxyAddresses.variableDebtTokenAddress
   );
 
+  testEnv.ghoManager = await getGhoManager();
+
   testEnv.aTokenImplementation = await getGhoAToken();
   testEnv.stableDebtTokenImplementation = await getStableDebtToken();
   testEnv.variableDebtTokenImplementation = await getGhoVariableDebtToken();