fix: assign roles to governor on timelock

Author: cybervoid0

eslint.config.mjs

@@ -9,4 +9,9 @@ export default [
   pluginJs.configs.recommended,
   ...tseslint.configs.recommended,
   eslintPluginPrettier,
+  {
+    rules: {
+      'prettier/prettier': ['warn'],
+    },
+  },
 ]

scripts/deploy-governor.ts

@@ -1,29 +1,42 @@
 import hre, { ethers, upgrades } from 'hardhat'
-import { GovernorTimelockControlUpgradeable, RootDao } from '../typechain-types'
+import { RootDao } from '../typechain-types'
 
-export const deployGovernor = async (tokenAddress: string, deployerAddress: string) => {
+export const deployGovernor = async (
+  tokenAddress: string,
+  deployerAddress: string,
+  timelockAddress: string,
+) => {
+  const timelock = await hre.ethers.getContractAt('DaoTimelockUpgradable', timelockAddress)
   const RootDAOFactory = await ethers.getContractFactory('RootDao')
-  const TimelockFactory = await ethers.getContractFactory('DaoTimelockUpgradable')
-  // TODO: figure out why it allows to put only a single argument
-  const timelock = (await upgrades.deployProxy(TimelockFactory, [1, [], [], ethers.ZeroAddress], {
-    initializer: 'initialize(uint256,address[],address[],address)',
-    kind: 'uups',
-    timeout: 0,
-  })) as unknown as GovernorTimelockControlUpgradeable
-
   const rootDAOGovernor = (await upgrades.deployProxy(
     RootDAOFactory,
-    [tokenAddress, await timelock.getAddress(), deployerAddress],
+    [tokenAddress, timelockAddress, deployerAddress],
     {
       initializer: 'initialize',
       kind: 'uups',
       timeout: 0,
     },
   )) as unknown as RootDao
+  await rootDAOGovernor.waitForDeployment()
+  const governorAddr = await rootDAOGovernor.getAddress()
+
+  // grant Proposer role to the Governor
+  const proposerRole = await timelock.PROPOSER_ROLE()
+  const grantProposerTx = await timelock.grantRole(proposerRole, governorAddr)
+  await grantProposerTx.wait()
+
+  // grant Executor role to the Governor
+  const executorRole = await timelock.EXECUTOR_ROLE()
+  const grantExecutorRoleTx = await timelock.grantRole(executorRole, governorAddr)
+  await grantExecutorRoleTx.wait()
 
-  const rootDAOContact = await rootDAOGovernor.waitForDeployment()
+  // renounce Admin role - this operation should be finally done by the DAO deployer
+  const adminRole = await timelock.DEFAULT_ADMIN_ROLE()
+  const [deployer] = await hre.ethers.getSigners()
+  const renounceTx = await timelock.renounceRole(adminRole, deployer.address)
+  await renounceTx.wait()
 
-  console.log(`Deployed Governor on ${hre.network.name} with address ${await rootDAOContact.getAddress()}`)
+  console.log(`Deployed Governor on ${hre.network.name} with address ${await rootDAOGovernor.getAddress()}`)
 
-  return rootDAOContact
+  return rootDAOGovernor
 }

scripts/deploy-timelock.ts

@@ -0,0 +1,29 @@
+import hre, { ethers, upgrades } from 'hardhat'
+import { DaoTimelockUpgradable } from '../typechain-types'
+
+export const deployTimelock = async () => {
+  const [owner] = await hre.ethers.getSigners()
+  const TimelockFactory = await ethers.getContractFactory('DaoTimelockUpgradable')
+  /* 
+  https://docs.openzeppelin.com/contracts/5.x/api/governance#TimelockController
+  Initialize the TImelock contract with the following parameters:
+      minDelay: initial minimum delay in seconds for operations
+      proposers: accounts to be granted proposer and canceller roles
+      executors: accounts to be granted executor role
+      admin: optional account to be granted admin role; disable with zero address
+  */
+  const minDelay = 60 * 60 * 24 // 24 hours in seconds
+  const proposers: string[] = []
+  const executors = [] as string[]
+  const admin = owner.address
+  const timelock = await upgrades.deployProxy(TimelockFactory, [minDelay, proposers, executors, admin], {
+    initializer: 'initialize',
+    kind: 'uups',
+    timeout: 0,
+  })
+  await timelock.waitForDeployment()
+
+  console.log(`Deployed Timelock on ${hre.network.name} with address ${await timelock.getAddress()}`)
+
+  return timelock as unknown as DaoTimelockUpgradable
+}

scripts/deploy.ts renamed to scripts/deploy-tokens.ts

@@ -2,7 +2,7 @@ import { ethers } from 'hardhat'
 import { deployStRIF } from './deploy-stRIF'
 import { deployRif } from './deploy-rif'
 
-const deploy = async () => {
+const deployTokens = async () => {
   const [deployer] = await ethers.getSigners()
   const { rifAddress } = await deployRif(deployer)
   const deployerAddress = await deployer.getAddress()
@@ -12,7 +12,7 @@ const deploy = async () => {
   console.log(`stRIFToken deployed at: ${await stRIFToken.getAddress()}`)
 }
 
-deploy().catch(err => {
+deployTokens().catch(err => {
   console.log('deployment error: ', err)
   process.exit(1)
 })

test/Governor.test.ts

@@ -3,11 +3,12 @@ import { ethers } from 'hardhat'
 import { loadFixture, mine } from '@nomicfoundation/hardhat-toolbox/network-helpers'
 import { deployRif } from '../scripts/deploy-rif'
 import { deployGovernor } from '../scripts/deploy-governor'
-import { RIFToken, RootDao, StRIFToken, TokenFaucet } from '../typechain-types'
+import { deployTimelock } from '../scripts/deploy-timelock'
+import { RIFToken, RootDao, StRIFToken, TokenFaucet, DaoTimelockUpgradable } from '../typechain-types'
 import { SignerWithAddress } from '@nomicfoundation/hardhat-ethers/signers'
 import { deployStRIF } from '../scripts/deploy-stRIF'
-import { parseEther, solidityPackedKeccak256 } from 'ethers'
-import { Proposal, ProposalState } from '../types'
+import { parseEther, solidityPackedKeccak256, toBeHex } from 'ethers'
+import { Proposal, ProposalState, OperationState } from '../types'
 
 describe('RootDAO Contact', () => {
   const initialVotingDelay = 1n // secs 1 day
@@ -16,6 +17,7 @@ describe('RootDAO Contact', () => {
 
   let rif: { rifToken: RIFToken; rifAddress: string; tokenFaucet: TokenFaucet }
   let stRIF: StRIFToken
+  let timelock: DaoTimelockUpgradable
   let governor: RootDao
   let holders: SignerWithAddress[]
   let deployer: SignerWithAddress
@@ -30,19 +32,25 @@ describe('RootDAO Contact', () => {
     rif = await loadFixture(deployRIF)
     const deployGovToken = async () => deployStRIF(rif.rifAddress, deployer.address)
     stRIF = await loadFixture(deployGovToken)
-
-    const deployDAO = async () => deployGovernor(await stRIF.getAddress(), deployer.address)
+    timelock = await loadFixture(deployTimelock)
+    const deployDAO = async () =>
+      deployGovernor(await stRIF.getAddress(), deployer.address, await timelock.getAddress())
     governor = await loadFixture(deployDAO)
   })
 
   describe('Upon deployment', () => {
     it('should deploy all contracts', async () => {
       expect(rif.rifAddress).to.be.properAddress
       expect(await stRIF.getAddress()).to.be.properAddress
+      expect(await timelock.getAddress()).to.be.properAddress
       expect(await governor.getAddress()).to.be.properAddress
       expect(await rif.tokenFaucet.getAddress()).to.be.properAddress
     })
 
+    it('min delay should be set on the Timelock', async () => {
+      expect(await timelock.getMinDelay())
+    })
+
     it('voting delay should be initialized', async () => {
       expect(await governor.votingDelay()).to.equal(initialVotingDelay)
     })
@@ -60,8 +68,8 @@ describe('RootDAO Contact', () => {
     const sendAmount = '2'
     let proposal: Proposal
     let proposalId: bigint
-    // let proposalCalldata: string
     let proposalSnapshot: bigint
+    // let proposalCalldata: string
 
     const getState = async () => await governor.state(proposalId)
 
@@ -72,7 +80,6 @@ describe('RootDAO Contact', () => {
 
     const createProposal = async (proposalDesc?: string) => {
       const blockHeight = await ethers.provider.getBlockNumber()
-      const votingPeriod = await governor.votingPeriod()
       const votingDelay = await governor.votingDelay()
 
       proposal = [
@@ -86,16 +93,10 @@ describe('RootDAO Contact', () => {
         .connect(holders[0])
         .hashProposal(proposal[0], proposal[1], proposal[2], generateDescriptionHash(proposalDesc))
 
-      const tx = await governor.connect(holders[0]).propose(...proposal)
-
-      const snapshot = votingDelay + BigInt(blockHeight) + 1n
-      const snapshotPlusDuration = votingPeriod + votingDelay + BigInt(blockHeight) + 1n
-
-      return {
-        snapshot,
-        snapshotPlusDuration,
-        tx,
-      }
+      const proposalTx = await governor.connect(holders[0]).propose(...proposal)
+      await proposalTx.wait()
+      proposalSnapshot = votingDelay + BigInt(blockHeight) + 1n
+      return proposalTx
     }
 
     const checkVotes = async () => {
@@ -145,25 +146,29 @@ describe('RootDAO Contact', () => {
       })
 
       it('holder[0] should be able to create proposal', async () => {
-        const { snapshot, snapshotPlusDuration, tx } = await createProposal()
-
+        const proposalTx = await createProposal()
+        const votingPeriod = await governor.votingPeriod()
         const ProposalCreatedEvent = [
           proposalId,
           holders[0].address, // proposer
           proposal[0], // targets
           proposal[1], // values
           [''], // ?
           proposal[2], // calldatas
-          snapshot,
-          snapshotPlusDuration,
+          proposalSnapshot,
+          proposalSnapshot + votingPeriod,
           defaultDescription,
         ]
 
-        await expect(tx)
+        await expect(proposalTx)
           .to.emit(governor, 'ProposalCreated')
           .withArgs(...ProposalCreatedEvent)
       })
 
+      it('proposal creation should initiate a Proposal Snapshot creation', async () => {
+        expect(await governor.proposalSnapshot(proposalId)).equal(proposalSnapshot)
+      })
+
       it('the rest of the holders should not be able to create proposal', async () => {
         await Promise.all(
           holders.slice(1).map(async holder => {
@@ -176,13 +181,6 @@ describe('RootDAO Contact', () => {
         )
       })
 
-      it('proposal creation should initiate a Proposal Snapshot creation', async () => {
-        const votingDelay = await governor.votingDelay()
-        const block = await ethers.provider.getBlockNumber()
-        proposalSnapshot = await governor.proposalSnapshot(proposalId)
-        expect(votingDelay + BigInt(block)).equal(proposalSnapshot)
-      })
-
       it('should calculate the quorum correctly', async () => {
         await mine((await governor.votingDelay()) + 1n)
 
@@ -254,7 +252,7 @@ describe('RootDAO Contact', () => {
         proposalSnapshot = await governor.proposalSnapshot(proposalId)
         const quorum = await governor.quorum(proposalSnapshot)
 
-        for (let holder of holders.slice(2, holders.length)) {
+        for (const holder of holders.slice(2, holders.length)) {
           if ((await checkVotes()) <= quorum) {
             await governor.connect(holder).castVote(proposalId, 1)
           }
@@ -265,14 +263,27 @@ describe('RootDAO Contact', () => {
         expect(await getState()).to.be.equal(ProposalState.Succeeded)
       })
 
-      it('after a proposal succeded it should be queued for execution', async () => {
+      it('Proposal should be registered as an operation on the Timelock', async () => {
+        expect(await timelock.isOperation(toBeHex(proposalId)))
+      })
+
+      it('Operation should be in Unset stage', async () => {
+        const state = Number(await timelock.getOperationState(toBeHex(proposalId)))
+        expect(state).to.equal(OperationState.Unset)
+      })
+
+      it('should return operation timestamp as 0 (because it is unset)', async () => {
+        expect(await timelock.getTimestamp(toBeHex(proposalId))).to.equal(0)
+      })
+
+      /* it('after a proposal succeeded it should be queued for execution', async () => {
         const tx = await governor
           .connect(deployer)
           [
             'execute(address[],uint256[],bytes[],bytes32)'
           ](proposal[0], proposal[1], proposal[2], generateDescriptionHash(otherDesc))
         await tx.wait()
-      })
+      }) */
     })
   })
 })

types/governor.ts

@@ -18,3 +18,10 @@ export enum VoteType {
 }
 
 export type Proposal = [string[], BigNumberish[], BytesLike[], string]
+
+export enum OperationState {
+  Unset,
+  Waiting,
+  Ready,
+  Done,
+}