4331034964

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/0xProject/protocol/commit/<a class=hub.com/0xProject/protocol/commit/<a class="double-link" href="https://git"><a class=hub.com/0xProject/protocol/commit/<a class="double-link" href="https://git"><a class=hub.com/0xProject/protocol/commit/<a class="double-link" href="https://git"><a class=hub.com/0xProject/protocol/commit/<a class="double-link" href="https://git"><a class=hub.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93">5be8bb65c">&lt;a href=&quot;https://github.com/0xProject/protocol/commit/</a><a class="double-link" href="https://github.com/0xProject/protocol/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/0xProject/protocol/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/0xProject/protocol/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93">5be8bb65c</a><a href="https://github.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93">&lt;a href=&quot;https://github.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/0xProject/protocol/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/0xProject/protocol/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93&amp;quot;&amp;gt;5be8bb65c&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8dbc20c93&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/0xProject/protocol/commit/5be8bb65c4236cb47b31fa937852fbe8&amp;lt;/a&amp;gt;dbc20c</a>93&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/0xProject/protocol/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/0xProject/protocol/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/0xProject/protocol/commit/ff10bd025&... (continued)

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

Run Details

37 of 54 branches covered (68.52%)

Branch coverage included in aggregate %.

169 of 169 new or added lines in 7 files covered. (100.0%)

155 of 169 relevant lines covered (91.72%)

18.04 hits per line

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

87.31

/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, "Only the token is allowed to perform this operation");
        _;
    }

    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 moveEntireVotingPower(
        address srcDelegatee,
        address dstDelegatee,
        uint256 delegateBalance
    ) public override onlyToken {
        if (srcDelegatee != dstDelegatee && delegateBalance > 0) {
            if (srcDelegatee != address(0)) {
                uint256 pos = _checkpoints[srcDelegatee].length;
                Checkpoint memory oldCkptSrcDelegate = pos == 0
                    ? Checkpoint(0, 0, 0)
                    : _unsafeAccess(_checkpoints[srcDelegatee], pos - 1);

                uint256 newLinearBalance = oldCkptSrcDelegate.votes - delegateBalance;
                uint256 newQuadraticBalance = oldCkptSrcDelegate.quadraticVotes - Math.sqrt(delegateBalance);

                _writeCheckpoint(_checkpoints[srcDelegatee], newLinearBalance, newQuadraticBalance);

                emit DelegateVotesChanged(srcDelegatee, oldCkptSrcDelegate.votes, newLinearBalance);

                emit DelegateQuadraticVotesChanged(
                    srcDelegatee,
                    oldCkptSrcDelegate.quadraticVotes,
                    newQuadraticBalance
                );
            }

            if (dstDelegatee != address(0)) {
                uint256 pos = _checkpoints[dstDelegatee].length;
                Checkpoint memory oldCkptDstDelegate = pos == 0
                    ? Checkpoint(0, 0, 0)
                    : _unsafeAccess(_checkpoints[dstDelegatee], pos - 1);

                uint256 newLinearBalance = oldCkptDstDelegate.votes + delegateBalance;
                uint256 newQuadraticBalance = oldCkptDstDelegate.quadraticVotes + Math.sqrt(delegateBalance);

                _writeCheckpoint(_checkpoints[dstDelegatee], newLinearBalance, newQuadraticBalance);

                emit DelegateVotesChanged(dstDelegatee, oldCkptDstDelegate.votes, newLinearBalance);

                emit DelegateQuadraticVotesChanged(
                    dstDelegatee,
                    oldCkptDstDelegate.quadraticVotes,
                    newQuadraticBalance
                );
            }
        }
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function movePartialVotingPower(
        address srcDelegatee,
        address dstDelegatee,
        uint256 srcDelegateBalance,
        uint256 dstDelegateBalance,
        uint256 amount
    ) public override onlyToken {
        if (srcDelegatee != dstDelegatee && amount > 0) {
            if (srcDelegatee != address(0)) {
                uint256 pos = _checkpoints[srcDelegatee].length;
                Checkpoint memory oldCkptSrcDelegate = pos == 0
                    ? Checkpoint(0, 0, 0)
                    : _unsafeAccess(_checkpoints[srcDelegatee], pos - 1);

                // Remove the entire source delegator's sqrt balance from delegatee's voting power.
                // `srcDelegateBalance` is value _after_ transfer so add the amount that was transferred.
                if (pos > 0)
                    oldCkptSrcDelegate.quadraticVotes -= SafeCast.toUint48(Math.sqrt(srcDelegateBalance + amount));

                uint256 newLinearBalance = oldCkptSrcDelegate.votes - amount;
                uint256 newQuadraticBalance = oldCkptSrcDelegate.quadraticVotes + Math.sqrt(srcDelegateBalance);

                _writeCheckpoint(_checkpoints[srcDelegatee], newLinearBalance, newQuadraticBalance);

                emit DelegateVotesChanged(srcDelegatee, oldCkptSrcDelegate.votes, newLinearBalance);

                emit DelegateQuadraticVotesChanged(
                    srcDelegatee,
                    oldCkptSrcDelegate.quadraticVotes,
                    newQuadraticBalance
                );
            }

            if (dstDelegatee != address(0)) {
                uint256 pos = _checkpoints[dstDelegatee].length;
                Checkpoint memory oldCkptDstDelegate = pos == 0
                    ? Checkpoint(0, 0, 0)
                    : _unsafeAccess(_checkpoints[dstDelegatee], pos - 1);

                // Remove the entire destination delegator's sqrt balance from delegatee's voting power.
                // `dstDelegateBalance` is value _after_ transfer so remove the amount that was transferred.
                if (pos > 0)
                    oldCkptDstDelegate.quadraticVotes -= SafeCast.toUint48(Math.sqrt(dstDelegateBalance - amount));

                uint256 newLinearBalance = oldCkptDstDelegate.votes + amount;
                uint256 newQuadraticBalance = oldCkptDstDelegate.quadraticVotes + Math.sqrt(dstDelegateBalance);

                _writeCheckpoint(_checkpoints[dstDelegatee], newLinearBalance, newQuadraticBalance);

                emit DelegateVotesChanged(dstDelegatee, oldCkptDstDelegate.votes, newLinearBalance);

                emit DelegateQuadraticVotesChanged(
                    dstDelegatee,
                    oldCkptDstDelegate.quadraticVotes,
                    newQuadraticBalance
                );
            }
        }
    }

    /**
     * @inheritdoc IZeroExVotes
     */
    function writeCheckpointTotalSupplyMint(
        address account,
        uint256 amount,
        uint256 accountBalance
    ) public override onlyToken {
        uint256 pos = _totalSupplyCheckpoints.length;
        Checkpoint memory oldCkptTotalSuply = pos == 0
            ? Checkpoint(0, 0, 0)
            : _unsafeAccess(_totalSupplyCheckpoints, pos - 1);

        // Remove the account sqrt balance from total quadratic supply.
        // `accountBalance` is value _after_ minting
        if (pos > 0) oldCkptTotalSuply.quadraticVotes -= SafeCast.toUint48(Math.sqrt(accountBalance - amount));

        uint256 newLinearBalance = oldCkptTotalSuply.votes + amount;
        uint256 newQuadraticBalance = oldCkptTotalSuply.quadraticVotes + Math.sqrt(accountBalance);

        _writeCheckpoint(_totalSupplyCheckpoints, newLinearBalance, newQuadraticBalance);

        emit TotalSupplyChanged(newLinearBalance, newQuadraticBalance);
    }

    function writeCheckpointTotalSupplyBurn(
        address account,
        uint256 amount,
        uint256 accountBalance
    ) public override onlyToken {
        uint256 pos = _totalSupplyCheckpoints.length;
        Checkpoint memory oldCkptTotalSuply = pos == 0
            ? Checkpoint(0, 0, 0)
            : _unsafeAccess(_totalSupplyCheckpoints, pos - 1);

        // Remove the account sqrt balance from total quadratic supply.
        // `accountBalance` is value _after_ burning
        if (pos > 0) oldCkptTotalSuply.quadraticVotes -= SafeCast.toUint48(Math.sqrt(accountBalance + amount));

        uint256 newLinearBalance = oldCkptTotalSuply.votes - amount;
        uint256 newQuadraticBalance = oldCkptTotalSuply.quadraticVotes + Math.sqrt(accountBalance);

        _writeCheckpoint(_totalSupplyCheckpoints, newLinearBalance, newQuadraticBalance);

        emit TotalSupplyChanged(newLinearBalance, newQuadraticBalance);
    }

    /**
     * @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;
    }

    /**
     * Alternative version of openzeppelin/token/ERC20/extensions/ERC20Votes.sol implementation
     * which accepts the new voting weight values directly as opposed to calculating these within the function
     * based on a addition/subtraction operation.
     */
    function _writeCheckpoint(Checkpoint[] storage ckpts, uint256 voteWeight, uint256 quadraticVoteWeight) private {
        uint256 pos = ckpts.length;

        if (pos > 0 && _unsafeAccess(ckpts, pos - 1).fromBlock == block.number) {
            Checkpoint storage chpt = _unsafeAccess(ckpts, pos - 1);
            chpt.votes = SafeCast.toUint96(voteWeight);
            chpt.quadraticVotes = SafeCast.toUint48(quadraticVoteWeight);

            emit CheckpointUpdated(chpt.fromBlock, chpt.votes, chpt.quadraticVotes);
        } else {
            ckpts.push(
                Checkpoint({
                    fromBlock: SafeCast.toUint32(block.number),
                    votes: SafeCast.toUint96(voteWeight),
                    quadraticVotes: SafeCast.toUint48(quadraticVoteWeight)
                })
            );

            emit CheckpointAdded(ckpts[pos].fromBlock, ckpts[pos].votes, ckpts[pos].quadraticVotes);
        }
    }

    /**
     * @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, "Only the token is allowed to perform this operation");
35	_;
36	}
37
38	function initialize(address _token) public {
39	require(token == address(0), "ZeroExVotes: Already initialized");	1!
40	token = _token;	×
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];	×
48	}
49
50	/**
51	* @inheritdoc IZeroExVotes
52	*/
53	function numCheckpoints(address account) public view override returns (uint32) {
54	return SafeCast.toUint32(_checkpoints[account].length);	×
55	}
56
57	/**
58	* @inheritdoc IZeroExVotes
59	*/
60	function getVotes(address account) public view override returns (uint256) {
61	uint256 pos = _checkpoints[account].length;	18✔
62	return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;	18✔
63	}
64
65	/**
66	* @inheritdoc IZeroExVotes
67	*/
68	function getQuadraticVotes(address account) public view override returns (uint256) {
69	uint256 pos = _checkpoints[account].length;	14✔
70	return pos == 0 ? 0 : _checkpoints[account][pos - 1].quadraticVotes;	14✔
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 moveEntireVotingPower(
121	address srcDelegatee,
122	address dstDelegatee,
123	uint256 delegateBalance
124	) public override onlyToken {
125	if (srcDelegatee != dstDelegatee && delegateBalance > 0) {	11✔
126	if (srcDelegatee != address(0)) {	11!
127	uint256 pos = _checkpoints[srcDelegatee].length;	2✔
128	Checkpoint memory oldCkptSrcDelegate = pos == 0	2✔
129	? Checkpoint(0, 0, 0)
130	: _unsafeAccess(_checkpoints[srcDelegatee], pos - 1);
131
132	uint256 newLinearBalance = oldCkptSrcDelegate.votes - delegateBalance;	2✔
133	uint256 newQuadraticBalance = oldCkptSrcDelegate.quadraticVotes - Math.sqrt(delegateBalance);	2✔
134
135	_writeCheckpoint(_checkpoints[srcDelegatee], newLinearBalance, newQuadraticBalance);	2✔
136
137	emit DelegateVotesChanged(srcDelegatee, oldCkptSrcDelegate.votes, newLinearBalance);	2✔
138
139	emit DelegateQuadraticVotesChanged(	2✔
140	srcDelegatee,
141	oldCkptSrcDelegate.quadraticVotes,
142	newQuadraticBalance
143	);
144	}
145
146	if (dstDelegatee != address(0)) {	11✔
147	uint256 pos = _checkpoints[dstDelegatee].length;	11✔
148	Checkpoint memory oldCkptDstDelegate = pos == 0	11✔
149	? Checkpoint(0, 0, 0)
150	: _unsafeAccess(_checkpoints[dstDelegatee], pos - 1);
151
152	uint256 newLinearBalance = oldCkptDstDelegate.votes + delegateBalance;	11✔
153	uint256 newQuadraticBalance = oldCkptDstDelegate.quadraticVotes + Math.sqrt(delegateBalance);	11✔
154
155	_writeCheckpoint(_checkpoints[dstDelegatee], newLinearBalance, newQuadraticBalance);	11✔
156
157	emit DelegateVotesChanged(dstDelegatee, oldCkptDstDelegate.votes, newLinearBalance);	11✔
158
159	emit DelegateQuadraticVotesChanged(	11✔
160	dstDelegatee,
161	oldCkptDstDelegate.quadraticVotes,
162	newQuadraticBalance
163	);
164	}
165	}
166	}
167
168	/**
169	* @inheritdoc IZeroExVotes
170	*/
171	function movePartialVotingPower(
172	address srcDelegatee,
173	address dstDelegatee,
174	uint256 srcDelegateBalance,
175	uint256 dstDelegateBalance,
176	uint256 amount
177	) public override onlyToken {
178	if (srcDelegatee != dstDelegatee && amount > 0) {	31✔
179	if (srcDelegatee != address(0)) {	2✔
180	uint256 pos = _checkpoints[srcDelegatee].length;	1✔
181	Checkpoint memory oldCkptSrcDelegate = pos == 0	1✔
182	? Checkpoint(0, 0, 0)
183	: _unsafeAccess(_checkpoints[srcDelegatee], pos - 1);
184
185	// Remove the entire source delegator's sqrt balance from delegatee's voting power.
186	// `srcDelegateBalance` is value _after_ transfer so add the amount that was transferred.
187	if (pos > 0)	1✔
188	oldCkptSrcDelegate.quadraticVotes -= SafeCast.toUint48(Math.sqrt(srcDelegateBalance + amount));	1✔
189
190	uint256 newLinearBalance = oldCkptSrcDelegate.votes - amount;	1✔
191	uint256 newQuadraticBalance = oldCkptSrcDelegate.quadraticVotes + Math.sqrt(srcDelegateBalance);	1✔
192
193	_writeCheckpoint(_checkpoints[srcDelegatee], newLinearBalance, newQuadraticBalance);	1✔
194
195	emit DelegateVotesChanged(srcDelegatee, oldCkptSrcDelegate.votes, newLinearBalance);	1✔
196
197	emit DelegateQuadraticVotesChanged(	1✔
198	srcDelegatee,
199	oldCkptSrcDelegate.quadraticVotes,
200	newQuadraticBalance
201	);
202	}
203
204	if (dstDelegatee != address(0)) {	2✔
205	uint256 pos = _checkpoints[dstDelegatee].length;	1✔
206	Checkpoint memory oldCkptDstDelegate = pos == 0	1✔
207	? Checkpoint(0, 0, 0)
208	: _unsafeAccess(_checkpoints[dstDelegatee], pos - 1);
209
210	// Remove the entire destination delegator's sqrt balance from delegatee's voting power.
211	// `dstDelegateBalance` is value _after_ transfer so remove the amount that was transferred.
212	if (pos > 0)	1✔
213	oldCkptDstDelegate.quadraticVotes -= SafeCast.toUint48(Math.sqrt(dstDelegateBalance - amount));	1✔
214
215	uint256 newLinearBalance = oldCkptDstDelegate.votes + amount;	1✔
216	uint256 newQuadraticBalance = oldCkptDstDelegate.quadraticVotes + Math.sqrt(dstDelegateBalance);	1✔
217
218	_writeCheckpoint(_checkpoints[dstDelegatee], newLinearBalance, newQuadraticBalance);	1✔
219
220	emit DelegateVotesChanged(dstDelegatee, oldCkptDstDelegate.votes, newLinearBalance);	1✔
221
222	emit DelegateQuadraticVotesChanged(	1✔
223	dstDelegatee,
224	oldCkptDstDelegate.quadraticVotes,
225	newQuadraticBalance
226	);
227	}
228	}
229	}
230
231	/**
232	* @inheritdoc IZeroExVotes
233	*/
234	function writeCheckpointTotalSupplyMint(
235	address account,
236	uint256 amount,
237	uint256 accountBalance
238	) public override onlyToken {
239	uint256 pos = _totalSupplyCheckpoints.length;	24✔
240	Checkpoint memory oldCkptTotalSuply = pos == 0	24✔
241	? Checkpoint(0, 0, 0)
242	: _unsafeAccess(_totalSupplyCheckpoints, pos - 1);
243
244	// Remove the account sqrt balance from total quadratic supply.
245	// `accountBalance` is value _after_ minting
246	if (pos > 0) oldCkptTotalSuply.quadraticVotes -= SafeCast.toUint48(Math.sqrt(accountBalance - amount));	24✔
247
248	uint256 newLinearBalance = oldCkptTotalSuply.votes + amount;	24✔
249	uint256 newQuadraticBalance = oldCkptTotalSuply.quadraticVotes + Math.sqrt(accountBalance);	24✔
250
251	_writeCheckpoint(_totalSupplyCheckpoints, newLinearBalance, newQuadraticBalance);	24✔
252
253	emit TotalSupplyChanged(newLinearBalance, newQuadraticBalance);	24✔
254	}
255
256	function writeCheckpointTotalSupplyBurn(
257	address account,
258	uint256 amount,
259	uint256 accountBalance
260	) public override onlyToken {
261	uint256 pos = _totalSupplyCheckpoints.length;	5✔
262	Checkpoint memory oldCkptTotalSuply = pos == 0	5✔
263	? Checkpoint(0, 0, 0)
264	: _unsafeAccess(_totalSupplyCheckpoints, pos - 1);
265
266	// Remove the account sqrt balance from total quadratic supply.
267	// `accountBalance` is value _after_ burning
268	if (pos > 0) oldCkptTotalSuply.quadraticVotes -= SafeCast.toUint48(Math.sqrt(accountBalance + amount));	5✔
269
270	uint256 newLinearBalance = oldCkptTotalSuply.votes - amount;	5✔
271	uint256 newQuadraticBalance = oldCkptTotalSuply.quadraticVotes + Math.sqrt(accountBalance);	5✔
272
273	_writeCheckpoint(_totalSupplyCheckpoints, newLinearBalance, newQuadraticBalance);	5✔
274
275	emit TotalSupplyChanged(newLinearBalance, newQuadraticBalance);	5✔
276	}
277
278	/**
279	* @dev Lookup a value in a list of (sorted) checkpoints.
280	* Implementation as in openzeppelin/token/ERC20/extensions/ERC20Votes.sol except here we return the entire
281	* checkpoint rather than part of it
282	*/
283	function _checkpointsLookup(
284	Checkpoint[] storage ckpts,
285	uint256 blockNumber
286	) private view returns (Checkpoint memory) {
287	// We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
288	//
289	// Initially we check if the block is recent to narrow the search range.
290	// During the loop, the index of the wanted checkpoint remains in the range [low-1, high).
291	// With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the
292	// invariant.
293	// - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
294	// - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)
295	// Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
296	// out of bounds (in which case we're looking too far in the past and the result is 0).
297	// Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
298	// past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
299	// the same.
300	uint256 length = ckpts.length;	94✔
301
302	uint256 low = 0;	94✔
303	uint256 high = length;	94✔
304
305	if (length > 5) {	94!
306	uint256 mid = length - Math.sqrt(length);	×
307	if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {	×
308	high = mid;	×
309	} else {
310	low = mid + 1;	×
311	}
312	}
313
314	while (low < high) {	188✔
315	uint256 mid = Math.average(low, high);	94✔
316	if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) {	94✔
317	high = mid;	2✔
318	} else {
319	low = mid + 1;	92✔
320	}
321	}
322
323	// Leaving here for posterity this is the original OZ implementation which we've replaced
324	// return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes;
325	Checkpoint memory checkpoint = high == 0 ? Checkpoint(0, 0, 0) : _unsafeAccess(ckpts, high - 1);	94✔
326	return checkpoint;	94✔
327	}
328
329	/**
330	* Alternative version of openzeppelin/token/ERC20/extensions/ERC20Votes.sol implementation
331	* which accepts the new voting weight values directly as opposed to calculating these within the function
332	* based on a addition/subtraction operation.
333	*/
334	function _writeCheckpoint(Checkpoint[] storage ckpts, uint256 voteWeight, uint256 quadraticVoteWeight) private {
335	uint256 pos = ckpts.length;	44✔
336
337	if (pos > 0 && _unsafeAccess(ckpts, pos - 1).fromBlock == block.number) {	44✔
338	Checkpoint storage chpt = _unsafeAccess(ckpts, pos - 1);	16✔
339	chpt.votes = SafeCast.toUint96(voteWeight);	16✔
340	chpt.quadraticVotes = SafeCast.toUint48(quadraticVoteWeight);	16✔
341
342	emit CheckpointUpdated(chpt.fromBlock, chpt.votes, chpt.quadraticVotes);	16✔
343	} else {
344	ckpts.push(	28✔
345	Checkpoint({
346	fromBlock: SafeCast.toUint32(block.number),
347	votes: SafeCast.toUint96(voteWeight),
348	quadraticVotes: SafeCast.toUint48(quadraticVoteWeight)
349	})
350	);
351
352	emit CheckpointAdded(ckpts[pos].fromBlock, ckpts[pos].votes, ckpts[pos].quadraticVotes);	28✔
353	}
354	}
355
356	/**
357	* @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
358	* Implementation from openzeppelin/token/ERC20/extensions/ERC20Votes.sol
359	* https://github.com/ethereum/solidity/issues/9117
360	*/
361	function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) {
362	assembly {
363	mstore(0, ckpts.slot)
364	result.slot := add(keccak256(0, 0x20), pos)	244✔
365	}
366	}
367	}

0xProject / protocol / 4331034964

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