pragmasolidity ^0.7.0;pragmaexperimentalABIEncoderV2;import { GovernorBravoDelegatorStorage, GovernorBravoEvents } from"./GovernorBravoInterfaces.sol";
contractInstaGovernorBravoDelegatorisGovernorBravoDelegatorStorage, GovernorBravoEvents{
constructor(address timelock_,
address admin_,
address token_,
address implementation_,
uint votingPeriod_,
uint votingDelay_,
uint proposalThreshold_
) {
// Admin set to msg.sender for initialization
admin =msg.sender;
delegateTo(
implementation_,
abi.encodeWithSignature(
"initialize(address,address,uint256,uint256,uint256)",
timelock_,
token_,
votingPeriod_,
votingDelay_,
proposalThreshold_
)
);
_setImplementation(implementation_);
admin = admin_;
}
/**
* @notice Called by the admin to update the implementation of the delegator
* @param implementation_ The address of the new implementation for delegation
*/function_setImplementation(address implementation_) public{
require(msg.sender== admin, "GovernorBravoDelegator::_setImplementation: admin only");
require(implementation_ !=address(0), "GovernorBravoDelegator::_setImplementation: invalid implementation address");
address oldImplementation = implementation;
implementation = implementation_;
emit NewImplementation(oldImplementation, implementation);
}
/**
* @notice Internal method to delegate execution to another contract
* @dev It returns to the external caller whatever the implementation returns or forwards reverts
* @param callee The contract to delegatecall
* @param data The raw data to delegatecall
*/functiondelegateTo(address callee, bytesmemory data) internal{
(bool success, bytesmemory returnData) = callee.delegatecall(data);
assembly {
ifeq(success, 0) {
revert(add(returnData, 0x20), returndatasize())
}
}
}
/**
* @dev Delegates execution to an implementation contract.
* It returns to the external caller whatever the implementation returns
* or forwards reverts.
*/fallback () externalpayable{
// delegate all other functions to current implementation
(bool success, ) = implementation.delegatecall(msg.data);
assembly {
let free_mem_ptr :=mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize())
switch success
case0 { revert(free_mem_ptr, returndatasize()) }
default { return(free_mem_ptr, returndatasize()) }
}
}
}
Contract Source Code
File 2 of 2: GovernorBravoInterfaces.sol
pragmasolidity ^0.7.0;pragmaexperimentalABIEncoderV2;interfaceTimelockInterface{
functiondelay() externalviewreturns (uint);
functionGRACE_PERIOD() externalviewreturns (uint);
functionacceptAdmin() external;
functionqueuedTransactions(bytes32 hash) externalviewreturns (bool);
functionqueueTransaction(address target, uint value, stringcalldata signature, bytescalldata data, uint eta) externalreturns (bytes32);
functioncancelTransaction(address target, uint value, stringcalldata signature, bytescalldata data, uint eta) external;
functionexecuteTransaction(address target, uint value, stringcalldata signature, bytescalldata data, uint eta) externalpayablereturns (bytesmemory);
}
interfaceTokenInterface{
functiongetPriorVotes(address account, uint blockNumber) externalviewreturns (uint96);
}
contractGovernorBravoEvents{
/// @notice An event emitted when a new proposal is createdeventProposalCreated(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/// @param voter The address which casted a vote/// @param proposalId The proposal id which was voted on/// @param support Support value for the vote. 0=against, 1=for, 2=abstain/// @param votes Number of votes which were cast by the voter/// @param reason The reason given for the vote by the votereventVoteCast(addressindexed voter, uint proposalId, uint8 support, uint votes, string reason);
/// @notice An event emitted when a proposal has been canceledeventProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the TimelockeventProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the TimelockeventProposalExecuted(uint id);
/// @notice An event emitted when the voting delay is seteventVotingDelaySet(uint oldVotingDelay, uint newVotingDelay);
/// @notice An event emitted when the voting period is seteventVotingPeriodSet(uint oldVotingPeriod, uint newVotingPeriod);
/// @notice Emitted when implementation is changedeventNewImplementation(address oldImplementation, address newImplementation);
/// @notice Emitted when proposal threshold is seteventProposalThresholdSet(uint oldProposalThreshold, uint newProposalThreshold);
/// @notice Emitted when pendingAdmin is changedeventNewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
/// @notice Emitted when pendingAdmin is accepted, which means admin is updatedeventNewAdmin(address oldAdmin, address newAdmin);
}
contractGovernorBravoDelegatorStorage{
/// @notice Administrator for this contractaddresspublic admin;
/// @notice Pending administrator for this contractaddresspublic pendingAdmin;
/// @notice Active brains of Governoraddresspublic implementation;
}
/**
* @title Storage for Governor Bravo Delegate
* @notice For future upgrades, do not change GovernorBravoDelegateStorageV1. Create a new
* contract which implements GovernorBravoDelegateStorageV1 and following the naming convention
* GovernorBravoDelegateStorageVX.
*/contractGovernorBravoDelegateStorageV1isGovernorBravoDelegatorStorage{
/// @notice The delay before voting on a proposal may take place, once proposed, in blocksuintpublic votingDelay;
/// @notice The duration of voting on a proposal, in blocksuintpublic votingPeriod;
/// @notice The number of votes required in order for a voter to become a proposeruintpublic proposalThreshold;
/// @notice The total number of proposalsuintpublic proposalCount;
/// @notice The address of the DSL Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the DSL governance token
TokenInterface public token;
/// @notice The official record of all proposals ever proposedmapping (uint=> Proposal) public proposals;
/// @notice The latest proposal for each proposermapping (address=>uint) public latestProposalIds;
structProposal {
// Unique id for looking up a proposaluint id;
// Creator of the proposaladdress proposer;
// The timestamp that the proposal will be available for execution, set once the vote succeedsuint eta;
// the ordered list of target addresses for calls to be madeaddress[] targets;
// The ordered list of values (i.e. msg.value) to be passed to the calls to be madeuint[] values;
// The ordered list of function signatures to be calledstring[] signatures;
// The ordered list of calldata to be passed to each callbytes[] calldatas;
// The block at which voting begins: holders must delegate their votes prior to this blockuint startBlock;
// The block at which voting ends: votes must be cast prior to this blockuint endBlock;
// Current number of votes in favor of this proposaluint forVotes;
// Current number of votes in opposition to this proposaluint againstVotes;
// Current number of votes for abstaining for this proposaluint abstainVotes;
// Flag marking whether the proposal has been canceledbool canceled;
// Flag marking whether the proposal has been executedbool executed;
// Receipts of ballots for the entire set of votersmapping (address=> Receipt) receipts;
}
/// @notice Ballot receipt record for a voterstructReceipt {
// Whether or not a vote has been castbool hasVoted;
// Whether or not the voter supports the proposal or abstainsuint8 support;
// The number of votes the voter had, which were castuint96 votes;
}
/// @notice Possible states that a proposal may be inenumProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
}