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

/**
 * This contract is a programmatic delegate for the ENS DAO. It allows anyone
 * who has been given access to it to "veto" an executable vote by voting No on
 * it, using all the votes delegated to this contract.
 *
 * In order to be given access, delegates must agree to a pledge to only use
 * this veto power to prevent a governance attack against the DAO, or to veto a
 * vote that would violate the ENS constitution. The full pledge can be found here:
 *
 * https://ens.mypinata.cloud/ipfs/QmbCNmTtMgjVXsqirZRy8tZbq3zh92g1g6PE3V4QGpNJ1b
 */

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.9/contracts/governance/IGovernor.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/access/AccessControl.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/utils/cryptography/SignatureChecker.sol";
import "https://github.com/ensdomains/ens-contracts/blob/21736916300b26cb8ea1802dbf6c9ff054adaeab/contracts/reverseRegistrar/ReverseClaimer.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/utils/cryptography/MessageHashUtils.sol";

contract Veto is AccessControl, ReverseClaimer {
    IGovernor public governor;
    string public pledge;
    bytes32 public constant VETO_CANDIDATE_ROLE = keccak256("VETO_CANDIDATE_ROLE");
    bytes32 public constant VETO_ROLE = keccak256("VETO_ROLE");

    enum VoteType {
        Against,
        For,
        Abstain
    }
    
    error InvalidSignature();
    error AccessDenied();

    event NewGovernor(address governor);

    /**
     * @dev Constructor
     * @param ens The ENS registry, used to set the reverse record for this contract.
     * @param _governor The OZ governor contract to target.
     * @param _pledge The pledge that veto candidates must sign to gain access.
     */
    constructor(ENS ens, address _governor, string memory _pledge) ReverseClaimer(ens, msg.sender) {
        governor = IGovernor(_governor);
        emit NewGovernor(_governor);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        pledge = _pledge;
    }

    /**
     * @dev Updates the governor address.
     * @param _governor The address of the new governor contract.
     */
    function setGovernor(address _governor) external onlyRole(DEFAULT_ADMIN_ROLE) {
        governor = IGovernor(_governor);
        emit NewGovernor(_governor);        
    }

    /**
     * @dev Enables a candidate to accept veto power by signing the pledge.
     * @param signature A signature over the message in `pledge`.
     */
    function enableVeto(bytes memory signature) external onlyRole(VETO_CANDIDATE_ROLE) {
        if(!SignatureChecker.isValidSignatureNow(msg.sender, MessageHashUtils.toEthSignedMessageHash(bytes(pledge)), signature)) {
            revert InvalidSignature();
        }
        _grantRole(VETO_ROLE, msg.sender);
        _revokeRole(VETO_CANDIDATE_ROLE, msg.sender);
    }

    /**
     * @dev Enables a vetoer to veto the specified proposal.
     * @param proposalId The proposal ID of the proposal to veto.
     */
    function castVote(uint256 proposalId) public virtual onlyRole(VETO_ROLE) returns (uint256 balance) {
        return governor.castVote(proposalId, uint8(VoteType.Against));
    }

    /**
     * @dev Enables a vetoer to veto the specified proposal.
     * @param proposalId The proposal ID of the proposal to veto.
     * @param reason An explanation of why the vote is being vetoed.
     */
    function castVoteWithReason(
        uint256 proposalId,
        string calldata reason
    ) public virtual onlyRole(VETO_ROLE) returns (uint256 balance) {
        return governor.castVoteWithReason(proposalId, uint8(VoteType.Against), reason);
    }
}

{
  "compilationTarget": {
    "Veto.sol": "Veto"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}