Inverse Finance

1pragma solidity ^0.5.16;
2pragma experimental ABIEncoderV2;
3
4interface InvInterface {
5    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
6    function totalSupply() external view returns (uint256);
7}
8
9interface XinvInterface {
10    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
11    function totalSupply() external view returns (uint256);
12    function exchangeRateCurrent() external returns (uint);
13}
14
15interface TimelockInterface {
16    function delay() external view returns (uint);
17    function GRACE_PERIOD() external view returns (uint);
18    function setDelay(uint256 delay_) external;
19    function acceptAdmin() external;
20    function setPendingAdmin(address pendingAdmin_) external;
21    function queuedTransactions(bytes32 hash) external view returns (bool);
22    function queueTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes32);
23    function cancelTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external;
24    function executeTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes memory);
25}
26
27contract GovernorMills {
28    /// @notice The name of this contract
29    string public constant name = "Inverse Governor Mills";
30
31    /// @notice The maximum number of actions that can be included in a proposal
32    function proposalMaxOperations() public pure returns (uint) { return 20; } // 20 actions
33
34    /// @notice The delay before voting on a proposal may take place, once proposed
35    function votingDelay() public pure returns (uint) { return 1; } // 1 block
36
37    /// @notice The duration of voting on a proposal, in blocks
38    function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
39
40    /// @notice The address of the Protocol Timelock
41    TimelockInterface public timelock;
42
43    /// @notice The address of the governance token A
44    InvInterface public inv;
45
46    /// @notice The address of the governance token B
47    XinvInterface public xinv;
48
49    /// @notice The total number of proposals
50    uint256 public proposalCount;
51
52    /// @notice The guardian
53    address public guardian;
54
55    /// @notice proposal threshold
56    uint256 public proposalThreshold = 1000 ether; // 1k INV
57
58    /// @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
59    uint256 public quorumVotes = 4000 ether; // 4k INV
60
61    struct Proposal {
62        /// @notice Unique id for looking up a proposal
63        uint id;
64
65        /// @notice Creator of the proposal
66        address proposer;
67
68        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
69        uint eta;
70
71        /// @notice the ordered list of target addresses for calls to be made
72        address[] targets;
73
74        /// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
75        uint[] values;
76
77        /// @notice The ordered list of function signatures to be called
78        string[] signatures;
79
80        /// @notice The ordered list of calldata to be passed to each call
81        bytes[] calldatas;
82
83        /// @notice The block at which voting begins: holders must delegate their votes prior to this block
84        uint startBlock;
85
86        /// @notice The block at which voting ends: votes must be cast prior to this block
87        uint endBlock;
88
89        /// @notice Current number of votes in favor of this proposal
90        uint forVotes;
91
92        /// @notice Current number of votes in opposition to this proposal
93        uint againstVotes;
94
95        /// @notice Flag marking whether the proposal has been canceled
96        bool canceled;
97
98        /// @notice Flag marking whether the proposal has been executed
99        bool executed;
100
101        /// @notice Receipts of ballots for the entire set of voters
102        mapping (address => Receipt) receipts;
103    }
104
105    /// @notice Ballot receipt record for a voter
106    struct Receipt {
107        /// @notice Whether or not a vote has been cast
108        bool hasVoted;
109
110        /// @notice Whether or not the voter supports the proposal
111        bool support;
112
113        /// @notice The number of votes the voter had, which were cast
114        uint96 votes;
115    }
116
117    /// @notice Possible states that a proposal may be in
118    enum ProposalState {
119        Pending,
120        Active,
121        Canceled,
122        Defeated,
123        Succeeded,
124        Queued,
125        Expired,
126        Executed
127    }
128
129    /// @notice The official record of all proposals ever proposed
130    mapping (uint => Proposal) public proposals;
131
132    /// @notice The latest proposal for each proposer
133    mapping (address => uint) public latestProposalIds;
134
135    /// @notice Addresses that can propose without voting power
136    mapping (address => bool) public proposerWhitelist;
137
138    /// @notice proposal id => xinv.exchangeRateCurrent
139    mapping (uint => uint) public xinvExchangeRates;
140
141    /// @notice The EIP-712 typehash for the contract's domain
142    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
143
144    /// @notice The EIP-712 typehash for the ballot struct used by the contract
145    bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
146
147    /// @notice An event emitted when a new proposal is created
148    event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
149
150    /// @notice An event emitted when a vote has been cast on a proposal
151    event VoteCast(address voter, uint proposalId, bool support, uint votes);
152
153    /// @notice An event emitted when a proposal has been canceled
154    event ProposalCanceled(uint id);
155
156    /// @notice An event emitted when a proposal has been queued in the Timelock
157    event ProposalQueued(uint id, uint eta);
158
159    /// @notice An event emitted when a proposal has been executed in the Timelock
160    event ProposalExecuted(uint id);
161
162    /// @notice An event emitted when a new guardian has been set
163    event NewGuardian(address guardian);
164
165    /// @notice An event emitted when proposal threshold is updated
166    event ProposalThresholdUpdated(uint256 oldThreshold, uint256 newThreshold);
167
168    /// @notice An event emitted when proposal quorum is updated
169    event QuorumUpdated(uint256 oldQuorum, uint256 newQuorum);
170
171    /// @notice An event emitted when an address is added or removed from the proposer whitelist
172    event ProposerWhitelistUpdated(address proposer, bool value);
173
174    constructor(TimelockInterface timelock_, InvInterface inv_, XinvInterface xinv_) public {
175        timelock = timelock_;
176        inv = inv_;
177        xinv = xinv_;
178        guardian = msg.sender;
179    }
180
181    function _getPriorVotes(address _proposer, uint256 _blockNumber, uint256 _exchangeRate) internal view returns (uint96) {
182        uint96 invPriorVotes = inv.getPriorVotes(_proposer, _blockNumber);
183        uint96 xinvPriorVotes = uint96(
184            (
185                uint256(
186                    xinv.getPriorVotes(_proposer, _blockNumber)
187                ) * _exchangeRate
188            ) / 1 ether
189        );
190        
191        return add96(invPriorVotes, xinvPriorVotes);
192    }
193
194    function setGuardian(address _newGuardian) public {
195        require(msg.sender == guardian, "GovernorMills::setGuardian: only guardian");
196        guardian = _newGuardian;
197        
198        emit NewGuardian(guardian);
199    }
200
201    /**
202     * @notice Add new pending admin to queue
203     * @param newPendingAdmin The new admin
204     * @param eta ETA
205     */
206    function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
207        require(msg.sender == guardian, "GovernorMills::__queueSetTimelockPendingAdmin: only guardian");
208        timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
209    }
210
211    function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
212        require(msg.sender == guardian, "GovernorMills::__executeSetTimelockPendingAdmin: only guardian");
213        timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
214    }
215
216    function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
217        require(_getPriorVotes(msg.sender, sub256(block.number, 1), xinv.exchangeRateCurrent()) > proposalThreshold || proposerWhitelist[msg.sender], "GovernorMills::propose: proposer votes below proposal threshold");
218        require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorMills::propose: proposal function information arity mismatch");
219        require(targets.length != 0, "GovernorMills::propose: must provide actions");
220        require(targets.length <= proposalMaxOperations(), "GovernorMills::propose: too many actions");
221
222        uint latestProposalId = latestProposalIds[msg.sender];
223        if (latestProposalId != 0) {
224          ProposalState proposersLatestProposalState = state(latestProposalId);
225          require(proposersLatestProposalState != ProposalState.Active, "GovernorMills::propose: one live proposal per proposer, found an already active proposal");
226          require(proposersLatestProposalState != ProposalState.Pending, "GovernorMills::propose: one live proposal per proposer, found an already pending proposal");
227        }
228
229        uint startBlock = add256(block.number, votingDelay());
230        uint endBlock = add256(startBlock, votingPeriod());
231
232        proposalCount++;
233        Proposal memory newProposal = Proposal({
234            id: proposalCount,
235            proposer: msg.sender,
236            eta: 0,
237            targets: targets,
238            values: values,
239            signatures: signatures,
240            calldatas: calldatas,
241            startBlock: startBlock,
242            endBlock: endBlock,
243            forVotes: 0,
244            againstVotes: 0,
245            canceled: false,
246            executed: false
247        });
248
249        proposals[newProposal.id] = newProposal;
250        xinvExchangeRates[newProposal.id] = xinv.exchangeRateCurrent();
251        latestProposalIds[newProposal.proposer] = newProposal.id;
252
253        emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
254        return newProposal.id;
255    }

JavaScript Tests