feat: Governor basic

.vscode/settings.json

@@ -1,3 +1,5 @@
 {
-  "solidity.compileUsingRemoteVersion": "v0.8.24+commit.e11b9ed9"
+  "solidity.compileUsingRemoteVersion": "v0.8.24+commit.e11b9ed9",
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true
 }

contracts/DaoTimelockUpgradable.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/TimelockControllerUpgradeable.sol";
+
+contract DaoTimelockUpgradable is
+    UUPSUpgradeable,
+    TimelockControllerUpgradeable
+{
+    function initialize(
+        uint256 minDelay,
+        address[] memory proposers,
+        address[] memory executors,
+        address admin
+    ) public initializer {
+        __UUPSUpgradeable_init();
+        __AccessControl_init();
+        __TimelockController_init(minDelay, proposers, executors, admin);
+    }
+    function _authorizeUpgrade(
+        address newImplementation
+    ) internal override onlyRole(DEFAULT_ADMIN_ROLE) {}
+}

contracts/Governor.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorSettingsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorStorageUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesQuorumFractionUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract RootDao is
+  Initializable,
+  GovernorUpgradeable,
+  GovernorSettingsUpgradeable,
+  GovernorCountingSimpleUpgradeable,
+  GovernorStorageUpgradeable,
+  GovernorVotesUpgradeable,
+  GovernorVotesQuorumFractionUpgradeable,
+  GovernorTimelockControlUpgradeable,
+  OwnableUpgradeable,
+  UUPSUpgradeable
+{
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor() {
+    _disableInitializers();
+  }
+
+  function initialize(
+    IVotes voteToken,
+    TimelockControllerUpgradeable timelockController,
+    address initialOwner
+  ) public initializer {
+    __Governor_init("RootDao");
+    __GovernorSettings_init(7200 /* 1 day */, 50400 /* 1 week */, 10 * 10 ** 18);
+    __GovernorCountingSimple_init();
+    __GovernorStorage_init();
+    __GovernorVotes_init(voteToken);
+    __GovernorVotesQuorumFraction_init(4);
+    __GovernorTimelockControl_init(timelockController);
+    __Ownable_init(initialOwner);
+    __UUPSUpgradeable_init();
+  }
+
+  function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+  // The following functions are overrides required by Solidity.
+
+  function votingDelay()
+    public
+    view
+    override(GovernorUpgradeable, GovernorSettingsUpgradeable)
+    returns (uint256)
+  {
+    return super.votingDelay();
+  }
+
+  function votingPeriod()
+    public
+    view
+    override(GovernorUpgradeable, GovernorSettingsUpgradeable)
+    returns (uint256)
+  {
+    return super.votingPeriod();
+  }
+
+  function quorum(
+    uint256 blockNumber
+  ) public view override(GovernorUpgradeable, GovernorVotesQuorumFractionUpgradeable) returns (uint256) {
+    return super.quorum(blockNumber);
+  }
+
+  function state(
+    uint256 proposalId
+  ) public view override(GovernorUpgradeable, GovernorTimelockControlUpgradeable) returns (ProposalState) {
+    return super.state(proposalId);
+  }
+
+  function proposalNeedsQueuing(
+    uint256 proposalId
+  ) public view override(GovernorUpgradeable, GovernorTimelockControlUpgradeable) returns (bool) {
+    return super.proposalNeedsQueuing(proposalId);
+  }
+
+  function proposalThreshold()
+    public
+    view
+    override(GovernorUpgradeable, GovernorSettingsUpgradeable)
+    returns (uint256)
+  {
+    return super.proposalThreshold();
+  }
+
+  function _propose(
+    address[] memory targets,
+    uint256[] memory values,
+    bytes[] memory calldatas,
+    string memory description,
+    address proposer
+  ) internal override(GovernorUpgradeable, GovernorStorageUpgradeable) returns (uint256) {
+    return super._propose(targets, values, calldatas, description, proposer);
+  }
+
+  function _queueOperations(
+    uint256 proposalId,
+    address[] memory targets,
+    uint256[] memory values,
+    bytes[] memory calldatas,
+    bytes32 descriptionHash
+  ) internal override(GovernorUpgradeable, GovernorTimelockControlUpgradeable) returns (uint48) {
+    return super._queueOperations(proposalId, targets, values, calldatas, descriptionHash);
+  }
+
+  function _executeOperations(
+    uint256 proposalId,
+    address[] memory targets,
+    uint256[] memory values,
+    bytes[] memory calldatas,
+    bytes32 descriptionHash
+  ) internal override(GovernorUpgradeable, GovernorTimelockControlUpgradeable) {
+    super._executeOperations(proposalId, targets, values, calldatas, descriptionHash);
+  }
+
+  function _cancel(
+    address[] memory targets,
+    uint256[] memory values,
+    bytes[] memory calldatas,
+    bytes32 descriptionHash
+  ) internal override(GovernorUpgradeable, GovernorTimelockControlUpgradeable) returns (uint256) {
+    return super._cancel(targets, values, calldatas, descriptionHash);
+  }
+
+  function _executor()
+    internal
+    view
+    override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+    returns (address)
+  {
+    return super._executor();
+  }
+}

contracts/RIFToken.sol

@@ -3,4 +3,8 @@ pragma solidity ^0.4.24;
 
 import "rif-token-contracts/contracts/RIF/RIFToken.sol";
 
+contract RIFTokenContact is RIFToken {
+
+}
+
 /* File must exist, else test/RIFToken.test.ts will fail */

contracts/TokenFaucet.sol

@@ -0,0 +1,52 @@
+/**
+ * @title RIF Token Faucet
+ * @author IOV Labs
+ * @notice Original source code is taken from the repository:
+ * https://github.com/riflabs/rif-faucet/blob/master/contracts/TokenFaucet.sol
+ */
+
+pragma solidity ^0.8.20;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+contract TokenFaucet is Ownable {
+  IERC20 public immutable tokenContract;
+
+  mapping(address => uint) cannotDispenseUntil;
+
+  uint256 public dispenseValue = 10 * 10 ** 18; // 10 tRIFs
+  uint256 public dispenceFrequency = 1 hours;
+
+  event DispenceFrequencyChanged(address changer, uint256 oldValue, uint256 newValue);
+  event DispenceValueChanged(address changer, uint256 oldValue, uint256 newValue);
+
+  modifier canDispense(address to) {
+    require(cannotDispenseUntil[to] < block.timestamp, "CANNOT DISPENSE MORE THAN 1 TIME PER HOUR");
+    _;
+  }
+
+  constructor(IERC20 rifToken) Ownable(msg.sender) {
+    tokenContract = rifToken;
+  }
+
+  function recover() public returns (bool) {
+    uint256 totalAmount = tokenContract.balanceOf(address(this));
+    return tokenContract.transfer(owner(), totalAmount);
+  }
+
+  function dispense(address to) public canDispense(to) returns (bool) {
+    cannotDispenseUntil[to] = block.timestamp + dispenceFrequency;
+    return tokenContract.transfer(to, dispenseValue);
+  }
+
+  function setDispenseValue(uint256 value) public onlyOwner {
+    emit DispenceValueChanged(msg.sender, dispenseValue, value);
+    dispenseValue = value;
+  }
+
+  function setDispenseFrequency(uint256 freqSeconds) public onlyOwner {
+    emit DispenceFrequencyChanged(msg.sender, dispenceFrequency, freqSeconds);
+    dispenceFrequency = freqSeconds;
+  }
+}

hardhat.config.ts

@@ -1,6 +1,7 @@
 import { HardhatUserConfig } from 'hardhat/config'
 import '@nomicfoundation/hardhat-toolbox'
 import '@openzeppelin/hardhat-upgrades'
+import '@nomicfoundation/hardhat-viem'
 
 const config: HardhatUserConfig = {
   solidity: {
@@ -14,6 +15,11 @@ const config: HardhatUserConfig = {
       { version: '0.4.24' },
     ],
   },
+  networks: {
+    hardhat: {
+      allowUnlimitedContractSize: true,
+    },
+  },
 }
 
 export default config

package.json

@@ -6,12 +6,12 @@
   "author": "RootstockLabs",
   "license": "MIT",
   "scripts": {
-    "compile": "hardhat compile",
+    "compile": "npx hardhat compile",
     "clean": "hardhat clean",
     "lint:ts": "eslint 'test/**/*.ts'",
     "lint:sol": "solhint 'contracts/**/*.sol'",
     "lint": "yarn lint:ts && yarn lint:sol",
-    "test": "hardhat test"
+    "test": "npx hardhat test"
   },
   "devDependencies": {
     "@eslint/js": "^9.5.0",
@@ -21,7 +21,9 @@
     "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-toolbox-viem": "^3.0.0",
     "@nomicfoundation/hardhat-verify": "^2.0.0",
+    "@nomicfoundation/hardhat-viem": "^2.0.2",
     "@openzeppelin/contracts": "^5.0.2",
     "@openzeppelin/contracts-upgradeable": "^5.0.2",
     "@openzeppelin/hardhat-upgrades": "^3.2.0",
@@ -33,6 +35,7 @@
     "@types/node": ">=18.0.0",
     "@typescript-eslint/eslint-plugin": "^7.11.0",
     "@typescript-eslint/parser": "^7.11.0",
+    "bigint-crypto-utils": "^3.3.0",
     "chai": "^4.2.0",
     "eslint": "^9.5.0",
     "eslint-config-prettier": "^9.1.0",
@@ -48,7 +51,8 @@
     "ts-node": ">=8.0.0",
     "typechain": "^8.3.2",
     "typescript": "^5.4.5",
-    "typescript-eslint": "^7.14.1"
+    "typescript-eslint": "^7.14.1",
+    "viem": "^2.15.1"
   },
   "dependencies": {
     "rif-token-contracts": "https://github.com/Freshenext/RIF-Token"

scripts/deploy-governor.ts

@@ -0,0 +1,29 @@
+import hre, { ethers, upgrades } from 'hardhat'
+import { GovernorTimelockControlUpgradeable, RootDao } from '../typechain-types'
+
+export const deployGovernor = async (tokenAddress: string, deployerAddress: string) => {
+  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],
+    {
+      initializer: 'initialize',
+      kind: 'uups',
+      timeout: 0,
+    },
+  )) as unknown as RootDao
+
+  const rootDAOContact = await rootDAOGovernor.waitForDeployment()
+
+  console.log(`Deployed Governor on ${hre.network.name} with address ${await rootDAOContact.getAddress()}`)
+
+  return rootDAOContact
+}

scripts/deploy-rif.ts

@@ -0,0 +1,36 @@
+import { SignerWithAddress } from '@nomicfoundation/hardhat-ethers/signers'
+import hre, { ethers } from 'hardhat'
+
+export const deployRif = async (deployer: SignerWithAddress) => {
+  const rifToken = await ethers.deployContract('RIFToken')
+  await rifToken.waitForDeployment()
+
+  const rifAddress = await rifToken.getAddress()
+
+  console.log(`Deployed RIF Token on ${hre.network.name} with address ${rifAddress}`)
+
+  // `setAuthorizedManagerContract` transfers all tokens to Deployer
+  const tx1 = await rifToken.setAuthorizedManagerContract(deployer.address)
+  await tx1.wait()
+  console.log(`All RIF tokens transferred to ${deployer.address}`)
+
+  // close distribution
+  const block = await ethers.provider.getBlock('latest')
+  const now = Math.round(Date.now() / 1000)
+  const tx2 = await rifToken.closeTokenDistribution(block?.timestamp ?? now)
+  await tx2.wait()
+  console.log(`RIF distribution closed`)
+
+  const tokenFaucet = await (await ethers.deployContract('TokenFaucet', [rifToken])).waitForDeployment()
+
+  // transfer half of RIFs to the faucet
+  const rifSupply = 10n ** 27n
+
+  const tx3 = await rifToken.transfer(await tokenFaucet.getAddress(), rifSupply / 2n)
+  await tx3.wait()
+  console.log(`RIF tokens transferred to the Faucet`)
+
+  console.log(`Deployed Token Faucet on ${hre.network.name} with address ${await tokenFaucet.getAddress()}`)
+
+  return { rifToken, rifAddress, tokenFaucet }
+}

scripts/deploy-stRIF.ts

@@ -1,4 +1,4 @@
-import { ethers, upgrades } from 'hardhat'
+import hre, { ethers, upgrades } from 'hardhat'
 import { StRIFToken } from '../typechain-types'
 
 export const deployStRIF = async (rifTokenAddress: string, deployerAddress: string) => {
@@ -8,7 +8,13 @@ export const deployStRIF = async (rifTokenAddress: string, deployerAddress: stri
     kind: 'uups',
     timeout: 0, // wait indefinitely
     unsafeAllow: ['internal-function-storage'],
-  }) as unknown as StRIFToken)
+  })) as unknown as StRIFToken
 
-  return await stRIFToken.waitForDeployment()
+  const stRIFContract = await stRIFToken.waitForDeployment()
+
+  console.log(
+    `Deployed RIF Governance Token on ${hre.network.name} with address ${await stRIFContract.getAddress()}`,
+  )
+
+  return stRIFContract
 }