Governança Descentralizada: Desenvolvendo uma Aplicação DAO com Elementos da Web3 (PARTE 2)

pip install eth-brownie

git clone https://github.com/HarithDilshan/DAO---Template-by-Roxen.git

cd .\DAO---Template-by-Roxen\
code .

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

import "@openzeppelin/contracts/access/Ownable.sol";

contract Box is Ownable {
    uint256 private value;

    event ValueChanged(uint256 newValue);

    function store(uint256 newValue) public onlyOwner {
        value = newValue;
        emit ValueChanged(newValue);
    }

    function retrieve() public view returns (uint256) {
        return value;
    }
}

//SPDX-License-Identifier: MIT

import "@openzeppelin/contracts/token/ERC20/Extensions/ERC20Votes.sol";

pragma solidity ^0.8.7;

contract GovernanceToken is ERC20Votes {
   // eventos para o token de governança
   event TokenTransfered(
       address indexed from,
       address indexed to,
       uint256 amount
   );

   // Eventos
   event TokenMinted(address indexed to, uint256 amount);
   event TokenBurned(address indexed from, uint256 amount);

   // máximo de tokens por usuário
   uint256 constant TOKENS_PER_USER = 1000;
   uint256 constant TOTAL_SUPPLY = 1000000 * 10**18;

   // Mapeamentos
   mapping(address => bool) public s_claimedTokens;

   // Número de detentores
   address[] public s_holders;

   constructor(uint256 _keepPercentage)
       ERC20("MoralisToken", "MRST")
       ERC20Permit("MoralisToken")
   {
       uint256 keepAmount = (TOTAL_SUPPLY * _keepPercentage) / 100;
       _mint(msg.sender, TOTAL_SUPPLY);
       _transfer(msg.sender, address(this), TOTAL_SUPPLY - keepAmount);
       s_holders.push(msg.sender);
   }

   // Reivindicar tokens gratuitamente
   function claimTokens() external {
       require(!s_claimedTokens[msg.sender], "Already claimed tokens");
       s_claimedTokens[msg.sender] = true;
       _transfer(address(this), msg.sender, TOKENS_PER_USER * 10**18);
       s_holders.push(msg.sender);
   }

   function getHolderLength() external view returns (uint256) {
       return s_holders.length;
   }

   // Substituições necessárias para o Solidity
   function _afterTokenTransfer(
       address from,
       address to,
       uint256 amount
   ) internal override(ERC20Votes) {
       super._afterTokenTransfer(from, to, amount);
       emit TokenTransfered(from, to, amount);
   }

   function _mint(address to, uint256 amount) internal override(ERC20Votes) {
       super._mint(to, amount);
       emit TokenMinted(to, amount);
   }

   function _burn(address account, uint256 amount)
       internal
       override(ERC20Votes)
   {
       super._burn(account, amount);
       emit TokenBurned(account, amount);
   }
}

// Proposta atraente em breve => Compre uma tonelada de tokens e se desfaça deles após o término da votação
// Precisamos evitar isso definindo um Snapshop de tokens em um determinado bloco.

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

import "@openzeppelin/contracts/governance/TimelockController.sol";

contract TimeLock is TimelockController {
   // Atraso mínimo é o tempo mínimo necessário para que uma proposta possa ser executada
   // Os proponentes são os endereços que podem criar propostas
   // Os executores são os endereços que podem executar propostas
   // Admin é o endereço que pode definir o atraso
   constructor(
       uint256 minDelay,
       address[] memory proposers,
       address[] memory executors,
       address admin
   ) TimelockController(minDelay, proposers, executors, admin) {}
}

// O bloqueio de tempo será o proprietário do contrato regido
// Usamos o bloqueio de tempo porque queremos esperar até que uma nova votação seja executada
// Também queremos definir uma taxa mínima para poder votar, digamos 7 tokens.
// Isso dá tempo para sair se a proposta não for do seu agrado.

// O atraso da votação é o tempo entre a criação da proposta e o início da votação
// Período de votação é o tempo entre o início e o término da votação
// O limite da proposta é a quantidade mínima de votos que uma conta deve ter para poder criar uma proposta
// Quorum é a quantidade mínima de votos que uma proposta deve ter para poder ser executada em porcentagem
// Configurações atualizáveis permitem alterar as configurações do contrato, como atraso, período, limite.
// Bravo Compatible permite usar as funções compatíveis com o Bravo, como getVotes e getReceipts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";

contract MoralisGovernor is
   Governor,
   GovernorSettings,
   GovernorCountingSimple,
   GovernorVotes,
   GovernorVotesQuorumFraction,
   GovernorTimelockControl
{
   // Contagens de propostas
   uint256 public s_proposalCount;

   constructor(
       IVotes _token,
       TimelockController _timelock,
       uint256 _votingDelay,
       uint256 _votingPeriod,
       uint256 _quorumPercentage
   )
       Governor("Governor")
       GovernorSettings(
           _votingDelay, /* 1 => 1 block */
           _votingPeriod, /* 300 blocks => 1 hour */
           0 /* 0 => Because we want anyone to be able to create a proposal */
       )
       GovernorVotes(_token)
       GovernorVotesQuorumFraction(_quorumPercentage) /* 4 => 4% */
       GovernorTimelockControl(_timelock)
   {
       s_proposalCount = 0;
   }

   // As funções a seguir são substituições exigidas pelo Solidity.

   function votingDelay()
       public
       view
       override(IGovernor, GovernorSettings)
       returns (uint256)
   {
       return super.votingDelay();
   }

   function votingPeriod()
       public
       view
       override(IGovernor, GovernorSettings)
       returns (uint256)
   {
       return super.votingPeriod();
   }

   function quorum(uint256 blockNumber)
       public
       view
       override(IGovernor, GovernorVotesQuorumFraction)
       returns (uint256)
   {
       return super.quorum(blockNumber);
   }

   function state(uint256 proposalId)
       public
       view
       override(Governor, GovernorTimelockControl)
       returns (ProposalState)
   {
       return super.state(proposalId);
   }

   function propose(
       address[] memory targets,
       uint256[] memory values,
       bytes[] memory calldatas,
       string memory description
   ) public override(Governor, IGovernor) returns (uint256) {
       s_proposalCount++;
       return super.propose(targets, values, calldatas, description);
   }

   function proposalThreshold()
       public
       view
       override(Governor, GovernorSettings)
       returns (uint256)
   {
       return super.proposalThreshold();
   }

   function _execute(
       uint256 proposalId,
       address[] memory targets,
       uint256[] memory values,
       bytes[] memory calldatas,
       bytes32 descriptionHash
   ) internal override(Governor, GovernorTimelockControl) {
       super._execute(proposalId, targets, values, calldatas, descriptionHash);
   }

   function _cancel(
       address[] memory targets,
       uint256[] memory values,
       bytes[] memory calldatas,
       bytes32 descriptionHash
   ) internal override(Governor, GovernorTimelockControl) returns (uint256) {
       return super._cancel(targets, values, calldatas, descriptionHash);
   }

   function _executor()
       internal
       view
       override(Governor, GovernorTimelockControl)
       returns (address)
   {
       return super._executor();
   }

   function supportsInterface(bytes4 interfaceId)
       public
       view
       override(Governor, GovernorTimelockControl)
       returns (bool)
   {
       return super.supportsInterface(interfaceId);
   }

   function getNumberOfProposals() public view returns (uint256) {
       return s_proposalCount;
   }
}