Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Compound DAO vs Fei DAO

Created 4 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

332 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

343 lines

pragma solidity ^0.6.0;

pragma solidity ^0.5.16;

pragma experimental ABIEncoderV2;

// Forked from Compound

// See https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/GovernorAlpha.sol

contract GovernorAlpha {

/// @notice The name of this contract

string public constant name = "Compound Governor Alpha";

// solhint-disable-next-line const-name-snakecase

string public constant name = "Fei Governor Alpha";

/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed

function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Comp

function quorumVotes() public pure returns (uint) { return 25000000e18; } // 25,000,000 = 2.5% of Tribe

/// @notice The number of votes required in order for a voter to become a proposer

function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of Comp

function proposalThreshold() public pure returns (uint) { return 2500000e18; } // 2,500,000 = .25% of Tribe

/// @notice The maximum number of actions that can be included in a proposal

function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed

function votingDelay() public pure returns (uint) { return 1; } // 1 block

function votingDelay() public pure returns (uint) { return 3333; } // ~0.5 days in blocks (assuming 13s blocks)

/// @notice The duration of voting on a proposal, in blocks

function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)

function votingPeriod() public pure returns (uint) { return 10000; } // ~1.5 days in blocks (assuming 13s blocks)

/// @notice The address of the Compound Protocol Timelock

/// @notice The address of the Fei Protocol Timelock

TimelockInterface public timelock;

/// @notice The address of the Compound governance token

/// @notice The address of the Fei governance token

CompInterface public comp;

TribeInterface public tribe;

/// @notice The address of the Governor Guardian

address public guardian;

/// @notice The total number of proposals

uint public proposalCount;

struct Proposal {

/// @notice Unique id for looking up a proposal

uint id;

/// @notice Creator of the proposal

address proposer;

/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds

uint eta;

/// @notice the ordered list of target addresses for calls to be made

address[] targets;

/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made

uint[] values;

/// @notice The ordered list of function signatures to be called

string[] signatures;

/// @notice The ordered list of calldata to be passed to each call

bytes[] calldatas;

/// @notice The block at which voting begins: holders must delegate their votes prior to this block

uint startBlock;

/// @notice The block at which voting ends: votes must be cast prior to this block

uint endBlock;

/// @notice Current number of votes in favor of this proposal

uint forVotes;

/// @notice Current number of votes in opposition to this proposal

uint againstVotes;

/// @notice Flag marking whether the proposal has been canceled

bool canceled;

/// @notice Flag marking whether the proposal has been executed

bool executed;

/// @notice Receipts of ballots for the entire set of voters

mapping (address => Receipt) receipts;

}

/// @notice Ballot receipt record for a voter

struct Receipt {

/// @notice Whether or not a vote has been cast

bool hasVoted;

/// @notice Whether or not the voter supports the proposal

bool support;

/// @notice The number of votes the voter had, which were cast

uint96 votes;

}

/// @notice Possible states that a proposal may be in

enum ProposalState {

Pending,

Active,

Canceled,

Defeated,

Succeeded,

Queued,

Expired,

Executed

}

/// @notice The official record of all proposals ever proposed

mapping (uint => Proposal) public proposals;

/// @notice The latest proposal for each proposer

mapping (address => uint) public latestProposalIds;

/// @notice The EIP-712 typehash for the contract's domain

bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

/// @notice The EIP-712 typehash for the ballot struct used by the contract

bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");

/// @notice An event emitted when a new proposal is created

event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);

/// @notice An event emitted when a vote has been cast on a proposal

event VoteCast(address voter, uint proposalId, bool support, uint votes);

/// @notice An event emitted when a proposal has been canceled

event ProposalCanceled(uint id);

/// @notice An event emitted when a proposal has been queued in the Timelock

event ProposalQueued(uint id, uint eta);

/// @notice An event emitted when a proposal has been executed in the Timelock

event ProposalExecuted(uint id);

constructor(address timelock_, address comp_, address guardian_) public {

constructor(address timelock_, address tribe_, address guardian_) public {

timelock = TimelockInterface(timelock_);

comp = CompInterface(comp_);

tribe = TribeInterface(tribe_);

guardian = guardian_;

}

function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {

require(comp.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");

require(tribe.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha: proposer votes below proposal threshold");

require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");

require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha: proposal function information arity mismatch");

require(targets.length != 0, "GovernorAlpha::propose: must provide actions");

require(targets.length != 0, "GovernorAlpha: must provide actions");

require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");

require(targets.length <= proposalMaxOperations(), "GovernorAlpha: too many actions");

uint latestProposalId = latestProposalIds[msg.sender];

if (latestProposalId != 0) {

ProposalState proposersLatestProposalState = state(latestProposalId);

require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");

require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha: one live proposal per proposer, found an already active proposal");

require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");

require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha: one live proposal per proposer, found an already pending proposal");

}

uint startBlock = add256(block.number, votingDelay());

uint endBlock = add256(startBlock, votingPeriod());

proposalCount++;

Proposal memory newProposal = Proposal({

id: proposalCount,

proposer: msg.sender,

eta: 0,

targets: targets,

values: values,

signatures: signatures,

calldatas: calldatas,

startBlock: startBlock,

endBlock: endBlock,

forVotes: 0,

againstVotes: 0,

canceled: false,

executed: false

});

proposals[newProposal.id] = newProposal;

latestProposalIds[newProposal.proposer] = newProposal.id;

emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);

return newProposal.id;

}

function queue(uint proposalId) public {

require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");

require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha: proposal can only be queued if it is succeeded");

Proposal storage proposal = proposals[proposalId];

// solhint-disable-next-line not-rely-on-time

uint eta = add256(block.timestamp, timelock.delay());

for (uint i = 0; i < proposal.targets.length; i++) {

_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);

}

proposal.eta = eta;

emit ProposalQueued(proposalId, eta);

}

function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {

require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");

require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha: proposal action already queued at eta");

timelock.queueTransaction(target, value, signature, data, eta);

}

function execute(uint proposalId) public payable {

require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");

require(state(proposalId) == ProposalState.Queued, "GovernorAlpha: proposal can only be executed if it is queued");

Proposal storage proposal = proposals[proposalId];

proposal.executed = true;

for (uint i = 0; i < proposal.targets.length; i++) {

timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);

timelock.executeTransaction{value : proposal.values[i]}(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);

}

emit ProposalExecuted(proposalId);

}

function cancel(uint proposalId) public {

ProposalState state = state(proposalId);

require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");

require(state == ProposalState.Active || state == ProposalState.Pending, "GovernorAlpha: can only cancel Active or Pending Proposal");

Proposal storage proposal = proposals[proposalId];

require(msg.sender == guardian || comp.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");

require(msg.sender == guardian || tribe.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha: proposer above threshold");

proposal.canceled = true;

for (uint i = 0; i < proposal.targets.length; i++) {

timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);

}

emit ProposalCanceled(proposalId);

}

function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {

Proposal storage p = proposals[proposalId];

return (p.targets, p.values, p.signatures, p.calldatas);

}

function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {

return proposals[proposalId].receipts[voter];

}

function state(uint proposalId) public view returns (ProposalState) {

require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");

require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha: invalid proposal id");

Proposal storage proposal = proposals[proposalId];

if (proposal.canceled) {

return ProposalState.Canceled;

} else if (block.number <= proposal.startBlock) {

return ProposalState.Pending;

} else if (block.number <= proposal.endBlock) {

return ProposalState.Active;

} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {

return ProposalState.Defeated;

} else if (proposal.eta == 0) {

return ProposalState.Succeeded;

} else if (proposal.executed) {

return ProposalState.Executed;

// solhint-disable-next-line not-rely-on-time

} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {

return ProposalState.Expired;

} else {

return ProposalState.Queued;

}

function castVote(uint proposalId, bool support) public {

return _castVote(msg.sender, proposalId, support);

}

function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {

bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));

bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));

bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));

address signatory = ecrecover(digest, v, r, s);

require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");

require(signatory != address(0), "GovernorAlpha: invalid signature");

return _castVote(signatory, proposalId, support);

}

function _castVote(address voter, uint proposalId, bool support) internal {

require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");

require(state(proposalId) == ProposalState.Active, "GovernorAlpha: voting is closed");

Proposal storage proposal = proposals[proposalId];

Receipt storage receipt = proposal.receipts[voter];

require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");

require(receipt.hasVoted == false, "GovernorAlpha: voter already voted");

uint96 votes = comp.getPriorVotes(voter, proposal.startBlock);

uint96 votes = tribe.getPriorVotes(voter, proposal.startBlock);

if (support) {

proposal.forVotes = add256(proposal.forVotes, votes);

} else {

proposal.againstVotes = add256(proposal.againstVotes, votes);

}

receipt.hasVoted = true;

receipt.support = support;

receipt.votes = votes;

emit VoteCast(voter, proposalId, support, votes);

}

function __acceptAdmin() public {

require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");

require(msg.sender == guardian, "GovernorAlpha: sender must be gov guardian");

timelock.acceptAdmin();

}

function __abdicate() public {

require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");

require(msg.sender == guardian, "GovernorAlpha: sender must be gov guardian");

guardian = address(0);

}

function __transferGuardian(address newGuardian) public {

require(msg.sender == guardian, "GovernorAlpha: sender must be gov guardian");

guardian = newGuardian;

}

function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {

require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");

require(msg.sender == guardian, "GovernorAlpha: sender must be gov guardian");

timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);

}

function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {

require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");

require(msg.sender == guardian, "GovernorAlpha: sender must be gov guardian");

timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);

}

function add256(uint256 a, uint256 b) internal pure returns (uint) {

uint c = a + b;

require(c >= a, "addition overflow");

return c;

}

function sub256(uint256 a, uint256 b) internal pure returns (uint) {

require(b <= a, "subtraction underflow");

return a - b;

}

function getChainId() internal pure returns (uint) {

uint chainId;

// solhint-disable-next-line no-inline-assembly

assembly { chainId := chainid() }

return chainId;

}

interface TimelockInterface {

function delay() external view returns (uint);

// solhint-disable-next-line func-name-mixedcase

function GRACE_PERIOD() external view returns (uint);

function acceptAdmin() external;

function queuedTransactions(bytes32 hash) external view returns (bool);

function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);

function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;

function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);

}

interface CompInterface {

interface TribeInterface {

function getPriorVotes(address account, uint blockNumber) external view returns (uint96);

}

Saved diffs

Original text

Open file

pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;

contract GovernorAlpha {
    /// @notice The name of this contract
    string public constant name = "Compound Governor Alpha";

/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
    function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Comp

/// @notice The number of votes required in order for a voter to become a proposer
    function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of Comp

/// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed
    function votingDelay() public pure returns (uint) { return 1; } // 1 block

/// @notice The duration of voting on a proposal, in blocks
    function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)

/// @notice The address of the Compound Protocol Timelock
    TimelockInterface public timelock;

/// @notice The address of the Compound governance token
    CompInterface public comp;

/// @notice The address of the Governor Guardian
    address public guardian;

/// @notice The total number of proposals
    uint public proposalCount;

struct Proposal {
        /// @notice Unique id for looking up a proposal
        uint id;

/// @notice Creator of the proposal
        address proposer;

/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint eta;

/// @notice the ordered list of target addresses for calls to be made
        address[] targets;

/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
        uint[] values;

/// @notice The ordered list of function signatures to be called
        string[] signatures;

/// @notice The ordered list of calldata to be passed to each call
        bytes[] calldatas;

/// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint startBlock;

/// @notice The block at which voting ends: votes must be cast prior to this block
        uint endBlock;

/// @notice Current number of votes in favor of this proposal
        uint forVotes;

/// @notice Current number of votes in opposition to this proposal
        uint againstVotes;

/// @notice Flag marking whether the proposal has been canceled
        bool canceled;

/// @notice Flag marking whether the proposal has been executed
        bool executed;

/// @notice Receipts of ballots for the entire set of voters
        mapping (address => Receipt) receipts;
    }

/// @notice Ballot receipt record for a voter
    struct Receipt {
        /// @notice Whether or not a vote has been cast
        bool hasVoted;

/// @notice Whether or not the voter supports the proposal
        bool support;

/// @notice The number of votes the voter had, which were cast
        uint96 votes;
    }

/// @notice Possible states that a proposal may be in
    enum ProposalState {
        Pending,
        Active,
        Canceled,
        Defeated,
        Succeeded,
        Queued,
        Expired,
        Executed
    }

/// @notice The official record of all proposals ever proposed
    mapping (uint => Proposal) public proposals;

/// @notice The latest proposal for each proposer
    mapping (address => uint) public latestProposalIds;

/// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

/// @notice The EIP-712 typehash for the ballot struct used by the contract
    bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");

/// @notice An event emitted when a new proposal is created
    event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);

/// @notice An event emitted when a vote has been cast on a proposal
    event VoteCast(address voter, uint proposalId, bool support, uint votes);

/// @notice An event emitted when a proposal has been canceled
    event ProposalCanceled(uint id);

/// @notice An event emitted when a proposal has been queued in the Timelock
    event ProposalQueued(uint id, uint eta);

/// @notice An event emitted when a proposal has been executed in the Timelock
    event ProposalExecuted(uint id);

constructor(address timelock_, address comp_, address guardian_) public {
        timelock = TimelockInterface(timelock_);
        comp = CompInterface(comp_);
        guardian = guardian_;
    }

function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
        require(comp.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
        require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
        require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
        require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");

uint latestProposalId = latestProposalIds[msg.sender];
        if (latestProposalId != 0) {
          ProposalState proposersLatestProposalState = state(latestProposalId);
          require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
          require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
        }

uint startBlock = add256(block.number, votingDelay());
        uint endBlock = add256(startBlock, votingPeriod());

proposalCount++;
        Proposal memory newProposal = Proposal({
            id: proposalCount,
            proposer: msg.sender,
            eta: 0,
            targets: targets,
            values: values,
            signatures: signatures,
            calldatas: calldatas,
            startBlock: startBlock,
            endBlock: endBlock,
            forVotes: 0,
            againstVotes: 0,
            canceled: false,
            executed: false
        });

proposals[newProposal.id] = newProposal;
        latestProposalIds[newProposal.proposer] = newProposal.id;

emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
        return newProposal.id;
    }

function queue(uint proposalId) public {
        require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
        Proposal storage proposal = proposals[proposalId];
        uint eta = add256(block.timestamp, timelock.delay());
        for (uint i = 0; i < proposal.targets.length; i++) {
            _queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
        }
        proposal.eta = eta;
        emit ProposalQueued(proposalId, eta);
    }

function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
        require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
        timelock.queueTransaction(target, value, signature, data, eta);
    }

function execute(uint proposalId) public payable {
        require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
        Proposal storage proposal = proposals[proposalId];
        proposal.executed = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }
        emit ProposalExecuted(proposalId);
    }

function cancel(uint proposalId) public {
        ProposalState state = state(proposalId);
        require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");

Proposal storage proposal = proposals[proposalId];
        require(msg.sender == guardian || comp.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");

proposal.canceled = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }

emit ProposalCanceled(proposalId);
    }

function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
        Proposal storage p = proposals[proposalId];
        return (p.targets, p.values, p.signatures, p.calldatas);
    }

function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
        return proposals[proposalId].receipts[voter];
    }

function castVote(uint proposalId, bool support) public {
        return _castVote(msg.sender, proposalId, support);
    }

function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
        return _castVote(signatory, proposalId, support);
    }

function _castVote(address voter, uint proposalId, bool support) internal {
        require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
        Proposal storage proposal = proposals[proposalId];
        Receipt storage receipt = proposal.receipts[voter];
        require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
        uint96 votes = comp.getPriorVotes(voter, proposal.startBlock);

if (support) {
            proposal.forVotes = add256(proposal.forVotes, votes);
        } else {
            proposal.againstVotes = add256(proposal.againstVotes, votes);
        }

receipt.hasVoted = true;
        receipt.support = support;
        receipt.votes = votes;

emit VoteCast(voter, proposalId, support, votes);
    }

function __acceptAdmin() public {
        require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
        timelock.acceptAdmin();
    }

function __abdicate() public {
        require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
        guardian = address(0);
    }

function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
        require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
        timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
    }

function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
        require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
        timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
    }

function add256(uint256 a, uint256 b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "addition overflow");
        return c;
    }

function sub256(uint256 a, uint256 b) internal pure returns (uint) {
        require(b <= a, "subtraction underflow");
        return a - b;
    }

function getChainId() internal pure returns (uint) {
        uint chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

interface TimelockInterface {
    function delay() external view returns (uint);
    function GRACE_PERIOD() external view returns (uint);
    function acceptAdmin() external;
    function queuedTransactions(bytes32 hash) external view returns (bool);
    function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
    function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
    function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}

interface CompInterface {
    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}

Changed text

Open file

pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

// Forked from Compound
// See https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/GovernorAlpha.sol
contract GovernorAlpha {
    /// @notice The name of this contract
    // solhint-disable-next-line const-name-snakecase
    string public constant name = "Fei Governor Alpha";

/// @notice The number of votes required in order for a voter to become a proposer
    function proposalThreshold() public pure returns (uint) { return 2500000e18; } // 2,500,000 = .25% of Tribe

/// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed
    function votingDelay() public pure returns (uint) { return 3333; } // ~0.5 days in blocks (assuming 13s blocks)

/// @notice The duration of voting on a proposal, in blocks
    function votingPeriod() public pure returns (uint) { return 10000; } // ~1.5 days in blocks (assuming 13s blocks)

/// @notice The address of the Fei Protocol Timelock
    TimelockInterface public timelock;

/// @notice The address of the Fei governance token
    TribeInterface public tribe;