4392622672

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/0xProject/protocol/commit/<a class=hub.com/0xProject/protocol/commit/4213670e886e855f102444f197ca56ec80479363">4213670e8<a href="https://github.com/0xProject/protocol/commit/4213670e886e855f102444f197ca56ec80479363">">Merge </a><a class="double-link" href="https://github.com/0xProject/protocol/commit/<a class="double-link" href="https://github.com/0xProject/protocol/commit/a54a94ef94f0a0c98bb27505fe5fcae9aaad68d5">a54a94ef9</a>">a54a94ef9</a><a href="https://github.com/0xProject/protocol/commit/4213670e886e855f102444f197ca56ec80479363"> into 03fc744bb">03fc744bb</a>

Pull Request Pull Request #641: Decentralised governance of 0x protocol and treasury

Run Details

31 of 42 branches covered (73.81%)

Branch coverage included in aggregate %.

166 of 166 new or added lines in 8 files covered. (100.0%)

134 of 166 relevant lines covered (80.72%)

21.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.81

/contracts/governance/src/ZeroExVotes.sol

// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2023 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/
pragma solidity ^0.8.19;

import "@openzeppelin/utils/math/SafeCast.sol";
import "@openzeppelin/utils/math/Math.sol";
import "@openzeppelin/token/ERC20/ERC20.sol";
import "@openzeppelin/governance/utils/IVotes.sol";
import "./IZeroExVotes.sol";

contract ZeroExVotes is IZeroExVotes {
    address public token;

    mapping(address => Checkpoint[]) private _checkpoints;
    Checkpoint[] private _totalSupplyCheckpoints;

    modifier onlyToken() {
        require(msg.sender == token, "ZeroExVotes: only token allowed");
        _;
    }

    function initialize(address _token) public {
        require(token == address(0), "ZeroExVotes: already initialized");
        token = _token;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function checkpoints(address account, uint32 pos) public view override returns (Checkpoint memory) {
        return _checkpoints[account][pos];
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function numCheckpoints(address account) public view override returns (uint32) {
        return SafeCast.toUint32(_checkpoints[account].length);
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getVotes(address account) public view override returns (uint256) {
        uint256 pos = _checkpoints[account].length;
        return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getQuadraticVotes(address account) public view override returns (uint256) {
        uint256 pos = _checkpoints[account].length;
        return pos == 0 ? 0 : _checkpoints[account][pos - 1].quadraticVotes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getPastVotes(address account, uint256 blockNumber) public view override returns (uint256) {
        require(blockNumber < block.number, "ZeroExVotes: block not yet mined");

        Checkpoint memory checkpoint = _checkpointsLookup(_checkpoints[account], blockNumber);
        return checkpoint.votes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getPastQuadraticVotes(address account, uint256 blockNumber) public view override returns (uint256) {
        require(blockNumber < block.number, "ZeroExVotes: block not yet mined");

        Checkpoint memory checkpoint = _checkpointsLookup(_checkpoints[account], blockNumber);
        return checkpoint.quadraticVotes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getPastTotalSupply(uint256 blockNumber) public view override returns (uint256) {
        require(blockNumber < block.number, "ZeroExVotes: block not yet mined");

        // Note that due to the disabled updates of `_totalSupplyCheckpoints` in `writeCheckpointTotalSupply` function
        // this always returns 0.
        Checkpoint memory checkpoint = _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
        return checkpoint.votes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function getPastQuadraticTotalSupply(uint256 blockNumber) public view override returns (uint256) {
        require(blockNumber < block.number, "ZeroExVotes: block not yet mined");

        // Note that due to the disabled updates of `_totalSupplyCheckpoints` in `writeCheckpointTotalSupply` function
        // this always returns 0.
        Checkpoint memory checkpoint = _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
        return checkpoint.quadraticVotes;
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function moveVotingPower(address src, address dst, uint256 srcBalance, uint256 dstBalance, uint256 amount) public {
        if (src != dst && amount > 0) {
            if (src != address(0)) {
                (
                    uint256 oldWeight,
                    uint256 newWeight,
                    uint256 oldQuadraticWeight,
                    uint256 newQuadraticWeight
                ) = _writeCheckpoint(_checkpoints[src], _subtract, srcBalance, amount);

                emit DelegateVotesChanged(src, oldWeight, newWeight);
                emit DelegateQuadraticVotesChanged(src, oldQuadraticWeight, newQuadraticWeight);
            }

            if (dst != address(0)) {
                (
                    uint256 oldWeight,
                    uint256 newWeight,
                    uint256 oldQuadraticWeight,
                    uint256 newQuadraticWeight
                ) = _writeCheckpoint(_checkpoints[dst], _add, dstBalance, amount);

                emit DelegateVotesChanged(dst, oldWeight, newWeight);
                emit DelegateQuadraticVotesChanged(dst, oldQuadraticWeight, newQuadraticWeight);
            }
        }
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function writeCheckpointTotalSupplyMint(uint256 accountBalance, uint256 amount) public override onlyToken {
        (, uint256 newWeight, , uint256 newQuadraticWeight) = _writeCheckpoint(
            _totalSupplyCheckpoints,
            _add,
            accountBalance,
            amount
        );

        emit TotalSupplyChanged(newWeight, newQuadraticWeight);
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function writeCheckpointTotalSupplyBurn(uint256 accountBalance, uint256 amount) public override onlyToken {
        (, uint256 newWeight, , uint256 newQuadraticWeight) = _writeCheckpoint(
            _totalSupplyCheckpoints,
            _subtract,
            accountBalance,
            amount
        );

        emit TotalSupplyChanged(newWeight, newQuadraticWeight);
    }

    /**
     * @dev Lookup a value in a list of (sorted) checkpoints.
     * Implementation as in openzeppelin/token/ERC20/extensions/ERC20Votes.sol except here we return the entire
     * checkpoint rather than part of it
     */
    function _checkpointsLookup(
        Checkpoint[] storage ckpts,
        uint256 blockNumber
    ) private view returns (Checkpoint memory) {
        // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
        //
        // Initially we check if the block is recent to narrow the search range.
        // During the loop, the index of the wanted checkpoint remains in the range [low-1, high).
        // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the
        // invariant.
        // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
        // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)
        // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
        // out of bounds (in which case we're looking too far in the past and the result is 0).
        // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
        // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
        // the same.
        uint256 length = ckpts.length;

        uint256 low = 0;
        uint256 high = length;

        if (length > 5) {
            uint256 mid = length - Math.sqrt(length);
            if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // Leaving here for posterity this is the original OZ implementation which we've replaced
        // return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes;
        Checkpoint memory checkpoint = high == 0 ? Checkpoint(0, 0, 0) : _unsafeAccess(ckpts, high - 1);
        return checkpoint;
    }

    function _writeCheckpoint(
        Checkpoint[] storage ckpts,
        function(uint256, uint256) view returns (uint256) op,
        uint256 userBalance,
        uint256 delta
    ) private returns (uint256 oldWeight, uint256 newWeight, uint256 oldQuadraticWeight, uint256 newQuadraticWeight) {
        uint256 pos = ckpts.length;

        Checkpoint memory oldCkpt = pos == 0 ? Checkpoint(0, 0, 0) : _unsafeAccess(ckpts, pos - 1);

        oldWeight = oldCkpt.votes;
        newWeight = op(oldWeight, delta);

        oldQuadraticWeight = oldCkpt.quadraticVotes;

        // Remove the entire sqrt userBalance from quadratic voting power.
        // Note that `userBalance` is value _before_ transfer.
        if (pos > 0) oldCkpt.quadraticVotes -= SafeCast.toUint48(Math.sqrt(userBalance));

        newQuadraticWeight = oldCkpt.quadraticVotes + Math.sqrt(op(userBalance, delta));

        if (pos > 0 && oldCkpt.fromBlock == block.number) {
            Checkpoint storage chpt = _unsafeAccess(ckpts, pos - 1);
            chpt.votes = SafeCast.toUint96(newWeight);
            chpt.quadraticVotes = SafeCast.toUint48(newQuadraticWeight);
        } else {
            ckpts.push(
                Checkpoint({
                    fromBlock: SafeCast.toUint32(block.number),
                    votes: SafeCast.toUint96(newWeight),
                    quadraticVotes: SafeCast.toUint48(newQuadraticWeight)
                })
            );
        }
    }

    function _add(uint256 a, uint256 b) private pure returns (uint256) {
        return a + b;
    }

    function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
     * Implementation from openzeppelin/token/ERC20/extensions/ERC20Votes.sol
     * https://github.com/ethereum/solidity/issues/9117
     */
    function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) {
        assembly {
            mstore(0, ckpts.slot)
            result.slot := add(keccak256(0, 0x20), pos)
        }
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	/*
3
4	Copyright 2023 ZeroEx Intl.
5
6	Licensed under the Apache License, Version 2.0 (the "License");
7	you may not use this file except in compliance with the License.
8	You may obtain a copy of the License at
9
10	http://www.apache.org/licenses/LICENSE-2.0
11
12	Unless required by applicable law or agreed to in writing, software
13	distributed under the License is distributed on an "AS IS" BASIS,
14	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	See the License for the specific language governing permissions and
16	limitations under the License.
17
18	*/
19	pragma solidity ^0.8.19;
20
21	import "@openzeppelin/utils/math/SafeCast.sol";
22	import "@openzeppelin/utils/math/Math.sol";
23	import "@openzeppelin/token/ERC20/ERC20.sol";
24	import "@openzeppelin/governance/utils/IVotes.sol";
25	import "./IZeroExVotes.sol";
26
27	contract ZeroExVotes is IZeroExVotes {
28	address public token;
29
30	mapping(address => Checkpoint[]) private _checkpoints;
31	Checkpoint[] private _totalSupplyCheckpoints;
32
33	modifier onlyToken() {
34	require(msg.sender == token, "ZeroExVotes: only token allowed");
35	_;
36	}
37
38	function initialize(address _token) public {
39	require(token == address(0), "ZeroExVotes: already initialized");	2✔
40	token = _token;	1✔
41	}
42
43	/**
44	* @inheritdoc IZeroExVotes
45	*/
46	function checkpoints(address account, uint32 pos) public view override returns (Checkpoint memory) {
47	return _checkpoints[account][pos];	6✔
48	}
49
50	/**
51	* @inheritdoc IZeroExVotes
52	*/
53	function numCheckpoints(address account) public view override returns (uint32) {
54	return SafeCast.toUint32(_checkpoints[account].length);	5✔
55	}
56
57	/**
58	* @inheritdoc IZeroExVotes
59	*/
60	function getVotes(address account) public view override returns (uint256) {
61	uint256 pos = _checkpoints[account].length;	20✔
62	return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;	20✔
63	}
64
65	/**
66	* @inheritdoc IZeroExVotes
67	*/
68	function getQuadraticVotes(address account) public view override returns (uint256) {
69	uint256 pos = _checkpoints[account].length;	16✔
70	return pos == 0 ? 0 : _checkpoints[account][pos - 1].quadraticVotes;	16✔
71	}
72
73	/**
74	* @inheritdoc IZeroExVotes
75	*/
76	function getPastVotes(address account, uint256 blockNumber) public view override returns (uint256) {
77	require(blockNumber < block.number, "ZeroExVotes: block not yet mined");	28!
78
79	Checkpoint memory checkpoint = _checkpointsLookup(_checkpoints[account], blockNumber);	28✔
80	return checkpoint.votes;	28✔
81	}
82
83	/**
84	* @inheritdoc IZeroExVotes
85	*/
86	function getPastQuadraticVotes(address account, uint256 blockNumber) public view override returns (uint256) {
87	require(blockNumber < block.number, "ZeroExVotes: block not yet mined");	28!
88
89	Checkpoint memory checkpoint = _checkpointsLookup(_checkpoints[account], blockNumber);	28✔
90	return checkpoint.quadraticVotes;	28✔
91	}
92
93	/**
94	* @inheritdoc IZeroExVotes
95	*/
96	function getPastTotalSupply(uint256 blockNumber) public view override returns (uint256) {
97	require(blockNumber < block.number, "ZeroExVotes: block not yet mined");	5!
98
99	// Note that due to the disabled updates of `_totalSupplyCheckpoints` in `writeCheckpointTotalSupply` function
100	// this always returns 0.
101	Checkpoint memory checkpoint = _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);	5✔
102	return checkpoint.votes;	5✔
103	}
104
105	/**
106	* @inheritdoc IZeroExVotes
107	*/
108	function getPastQuadraticTotalSupply(uint256 blockNumber) public view override returns (uint256) {
109	require(blockNumber < block.number, "ZeroExVotes: block not yet mined");	33!
110
111	// Note that due to the disabled updates of `_totalSupplyCheckpoints` in `writeCheckpointTotalSupply` function
112	// this always returns 0.
113	Checkpoint memory checkpoint = _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);	33✔
114	return checkpoint.quadraticVotes;	33✔
115	}
116
117	/**
118	* @inheritdoc IZeroExVotes
119	*/
120	function moveVotingPower(address src, address dst, uint256 srcBalance, uint256 dstBalance, uint256 amount) public {
121	if (src != dst && amount > 0) {	55✔
122	if (src != address(0)) {	19✔
123	(	3✔
124	uint256 oldWeight,
125	uint256 newWeight,
126	uint256 oldQuadraticWeight,
127	uint256 newQuadraticWeight
128	) = _writeCheckpoint(_checkpoints[src], _subtract, srcBalance, amount);	3✔
129
130	emit DelegateVotesChanged(src, oldWeight, newWeight);	3✔
131	emit DelegateQuadraticVotesChanged(src, oldQuadraticWeight, newQuadraticWeight);	3✔
132	}
133
134	if (dst != address(0)) {	19✔
135	(	18✔
136	uint256 oldWeight,
137	uint256 newWeight,
138	uint256 oldQuadraticWeight,
139	uint256 newQuadraticWeight
140	) = _writeCheckpoint(_checkpoints[dst], _add, dstBalance, amount);	18✔
141
142	emit DelegateVotesChanged(dst, oldWeight, newWeight);	18✔
143	emit DelegateQuadraticVotesChanged(dst, oldQuadraticWeight, newQuadraticWeight);	18✔
144	}
145	}
146	}
147
148	/**
149	* @inheritdoc IZeroExVotes
150	*/
151	function writeCheckpointTotalSupplyMint(uint256 accountBalance, uint256 amount) public override onlyToken {
152	(, uint256 newWeight, , uint256 newQuadraticWeight) = _writeCheckpoint(	31✔
153	_totalSupplyCheckpoints,
154	_add,
155	accountBalance,
156	amount
157	);
158
159	emit TotalSupplyChanged(newWeight, newQuadraticWeight);	31✔
160	}
161
162	/**
163	* @inheritdoc IZeroExVotes
164	*/
165	function writeCheckpointTotalSupplyBurn(uint256 accountBalance, uint256 amount) public override onlyToken {
166	(, uint256 newWeight, , uint256 newQuadraticWeight) = _writeCheckpoint(	5✔
167	_totalSupplyCheckpoints,
168	_subtract,
169	accountBalance,
170	amount
171	);
172
173	emit TotalSupplyChanged(newWeight, newQuadraticWeight);	5✔
174	}
175
176	/**
177	* @dev Lookup a value in a list of (sorted) checkpoints.
178	* Implementation as in openzeppelin/token/ERC20/extensions/ERC20Votes.sol except here we return the entire
179	* checkpoint rather than part of it
180	*/
181	function _checkpointsLookup(
182	Checkpoint[] storage ckpts,
183	uint256 blockNumber
184	) private view returns (Checkpoint memory) {
185	// We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
186	//
187	// Initially we check if the block is recent to narrow the search range.
188	// During the loop, the index of the wanted checkpoint remains in the range [low-1, high).
189	// With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the
190	// invariant.
191	// - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
192	// - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)
193	// Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
194	// out of bounds (in which case we're looking too far in the past and the result is 0).
195	// Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
196	// past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
197	// the same.
198	uint256 length = ckpts.length;	94✔
199
200	uint256 low = 0;	94✔
201	uint256 high = length;	94✔
202
203	if (length > 5) {	94!
204	uint256 mid = length - Math.sqrt(length);	×
205	if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {	×
206	high = mid;	×
207	} else {
208	low = mid + 1;	×
209	}
210	}
211
212	while (low < high) {	188✔
213	uint256 mid = Math.average(low, high);	94✔
214	if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {	94✔
215	high = mid;	2✔
216	} else {
217	low = mid + 1;	92✔
218	}
219	}
220
221	// Leaving here for posterity this is the original OZ implementation which we've replaced
222	// return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes;
223	Checkpoint memory checkpoint = high == 0 ? Checkpoint(0, 0, 0) : _unsafeAccess(ckpts, high - 1);	94✔
224	return checkpoint;	94✔
225	}
226
227	function _writeCheckpoint(
228	Checkpoint[] storage ckpts,
229	function(uint256, uint256) view returns (uint256) op,
230	uint256 userBalance,
231	uint256 delta
232	) private returns (uint256 oldWeight, uint256 newWeight, uint256 oldQuadraticWeight, uint256 newQuadraticWeight) {
233	uint256 pos = ckpts.length;	57✔
234
235	Checkpoint memory oldCkpt = pos == 0 ? Checkpoint(0, 0, 0) : _unsafeAccess(ckpts, pos - 1);	57✔
236
237	oldWeight = oldCkpt.votes;	57✔
238	newWeight = op(oldWeight, delta);	57✔
239
240	oldQuadraticWeight = oldCkpt.quadraticVotes;	57✔
241
242	// Remove the entire sqrt userBalance from quadratic voting power.
243	// Note that `userBalance` is value _before_ transfer.
244	if (pos > 0) oldCkpt.quadraticVotes -= SafeCast.toUint48(Math.sqrt(userBalance));	57✔
245
246	newQuadraticWeight = oldCkpt.quadraticVotes + Math.sqrt(op(userBalance, delta));	57✔
247
248	if (pos > 0 && oldCkpt.fromBlock == block.number) {	57✔
249	Checkpoint storage chpt = _unsafeAccess(ckpts, pos - 1);	18✔
250	chpt.votes = SafeCast.toUint96(newWeight);	18✔
251	chpt.quadraticVotes = SafeCast.toUint48(newQuadraticWeight);	18✔
252	} else {
253	ckpts.push(	39✔
254	Checkpoint({
255	fromBlock: SafeCast.toUint32(block.number),
256	votes: SafeCast.toUint96(newWeight),
257	quadraticVotes: SafeCast.toUint48(newQuadraticWeight)
258	})
259	);
260	}
261	}
262
263	function _add(uint256 a, uint256 b) private pure returns (uint256) {
264	return a + b;	98✔
265	}
266
267	function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
268	return a - b;	16✔
269	}
270
271	/**
272	* @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
273	* Implementation from openzeppelin/token/ERC20/extensions/ERC20Votes.sol
274	* https://github.com/ethereum/solidity/issues/9117
275	*/
276	function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) {
277	assembly {
278	mstore(0, ckpts.slot)
279	result.slot := add(keccak256(0, 0x20), pos)	229✔
280	}
281	}
282	}

0xProject / protocol / 4392622672

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous