Court: Polish main court contract functionality

contracts/CRVoting.sol

@@ -280,7 +280,7 @@ contract CRVoting is Initializable, ICRVoting {
     */
     function _ensureVoterWeightToCommit(uint256 _voteId, address _voter) internal returns (uint256) {
         uint256 weight = uint256(owner.getVoterWeightToCommit(_voteId, _voter));
-        require(weight > uint256(0), ERROR_COMMIT_DENIED_BY_OWNER);
+        require(weight > 0, ERROR_COMMIT_DENIED_BY_OWNER);
         return weight;
     }
 
@@ -292,7 +292,7 @@ contract CRVoting is Initializable, ICRVoting {
     */
     function _ensureVoterWeightToReveal(uint256 _voteId, address _voter) internal returns (uint256) {
         uint256 weight = uint256(owner.getVoterWeightToReveal(_voteId, _voter));
-        require(weight > uint256(0), ERROR_REVEAL_DENIED_BY_OWNER);
+        require(weight > 0, ERROR_REVEAL_DENIED_BY_OWNER);
         return weight;
     }
 

contracts/JurorsRegistry.sol

@@ -135,7 +135,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
         _processDeactivationRequest(msg.sender, termId);
 
         uint256 availableBalance = jurorsByAddress[msg.sender].availableBalance;
-        uint256 amountToActivate = _amount == uint256(0) ? availableBalance : _amount;
+        uint256 amountToActivate = _amount == 0 ? availableBalance : _amount;
         require(amountToActivate > 0, ERROR_INVALID_ZERO_AMOUNT);
         require(amountToActivate <= availableBalance, ERROR_INVALID_ACTIVATION_AMOUNT);
 
@@ -150,13 +150,13 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
         uint64 termId = owner.ensureAndGetTermId();
 
         uint256 unlockedActiveBalance = unlockedActiveBalanceOf(msg.sender);
-        uint256 amountToDeactivate = _amount == uint256(0) ? unlockedActiveBalance : _amount;
+        uint256 amountToDeactivate = _amount == 0 ? unlockedActiveBalance : _amount;
         require(amountToDeactivate > 0, ERROR_INVALID_ZERO_AMOUNT);
         require(amountToDeactivate <= unlockedActiveBalance, ERROR_INVALID_DEACTIVATION_AMOUNT);
 
         // No need to use SafeMath here, we already checked values above
         uint256 futureActiveBalance = unlockedActiveBalance - amountToDeactivate;
-        require(futureActiveBalance == uint256(0) || futureActiveBalance >= minActiveBalance, ERROR_INVALID_DEACTIVATION_AMOUNT);
+        require(futureActiveBalance == 0 || futureActiveBalance >= minActiveBalance, ERROR_INVALID_DEACTIVATION_AMOUNT);
 
         _createDeactivationRequest(msg.sender, termId, amountToDeactivate);
     }
@@ -215,7 +215,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     *        3. uint256 Number of seats already filled
     *        4. uint256 Number of seats left to be filled
     *        5. uint64  Number of jurors required for the draft
-    *        6. uint16  Percentage of the minimum active balance to be locked for the draft
+    *        6. uint16  Per ten thousand of the minimum active balance to be locked for the draft
     *
     * @return jurors List of jurors selected for the draft
     * @return weights List of weights corresponding to each juror
@@ -325,7 +325,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     * @return True if the juror has enough unlocked tokens to be collected for the requested term, false otherwise
     */
     function collectTokens(address _juror, uint256 _amount, uint64 _termId) external onlyOwner returns (bool) {
-        if (_amount == uint256(0)) {
+        if (_amount == 0) {
             return true;
         }
 
@@ -347,7 +347,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
             // Note there's no need to use SafeMath here, amounts were already checked above
             uint256 amountToReduce = _amount - unlockedActiveBalance;
             _reduceDeactivationRequest(_juror, amountToReduce, _termId);
-            tree.set(juror.id, nextTermId, uint256(0));
+            tree.set(juror.id, nextTermId, 0);
         } else {
             tree.update(juror.id, nextTermId, _amount, false);
         }
@@ -410,7 +410,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     */
     function activeBalanceOfAt(address _juror, uint64 _termId) external view returns (uint256) {
         Juror storage juror = jurorsByAddress[_juror];
-        return _existsJuror(juror) ? tree.getItemAt(juror.id, _termId) : uint256(0);
+        return _existsJuror(juror) ? tree.getItemAt(juror.id, _termId) : 0;
     }
 
     /**
@@ -453,7 +453,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     function balanceOf(address _juror) public view returns (uint256 active, uint256 available, uint256 locked, uint256 pendingDeactivation) {
         Juror storage juror = jurorsByAddress[_juror];
 
-        active = _existsJuror(juror) ? tree.getItem(juror.id) : uint256(0);
+        active = _existsJuror(juror) ? tree.getItem(juror.id) : 0;
         available = juror.availableBalance;
         locked = juror.lockedBalance;
         pendingDeactivation = juror.deactivationRequest.amount;
@@ -550,7 +550,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
         // Note that we can use a zeroed term id to denote void here since we are storing
         // the minimum allowed term to deactivate tokens which will always be at least 1
         request.availableTermId = uint64(0);
-        request.amount = uint256(0);
+        request.amount = 0;
         _updateAvailableBalanceOf(_juror, deactivationAmount, true);
 
         emit JurorDeactivationProcessed(_juror, deactivationAvailableTermId, deactivationAmount, _termId);
@@ -647,7 +647,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
         // We are not using a require here to avoid reverting in case any of the accounting maths reaches this point
         // with a zeroed amount value. Instead, we are doing this validation in the external entry points such as
         // stake, unstake, activate, deactivate, among others.
-        if (_amount == uint256(0)) {
+        if (_amount == 0) {
             return;
         }
 
@@ -668,7 +668,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     * @return Amount of active tokens of a juror that are not locked due to ongoing disputes
     */
     function _unlockedActiveBalanceOf(Juror storage _juror) internal view returns (uint256) {
-        return _existsJuror(_juror) ? tree.getItem(_juror.id).sub(_juror.lockedBalance) : uint256(0);
+        return _existsJuror(_juror) ? tree.getItem(_juror.id).sub(_juror.lockedBalance) : 0;
     }
 
     /**
@@ -677,7 +677,7 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     * @return True if the given juror was already registered, false otherwise
     */
     function _existsJuror(Juror storage _juror) internal view returns (bool) {
-        return _juror.id != uint256(0);
+        return _juror.id != 0;
     }
 
     /**
@@ -688,12 +688,12 @@ contract JurorsRegistry is Initializable, IsContract, IJurorsRegistry, ERC900, A
     */
     function _deactivationRequestedAmountForTerm(Juror storage _juror, uint64 _termId) internal view returns (uint256) {
         DeactivationRequest storage request = _juror.deactivationRequest;
-        return request.availableTermId == _termId ? request.amount : uint256(0);
+        return request.availableTermId == _termId ? request.amount : 0;
     }
 
     /**
     * @dev Internal function to tell the fraction of minimum active tokens that must be locked for a draft
-    * @param _pct Percentage of the minimum active balance to be locked for a draft
+    * @param _pct Per ten thousand of the minimum active balance to be locked for a draft
     * @return The fraction of minimum active tokens that must be locked for a draft
     */
     function _draftLockAmount(uint16 _pct) internal view returns (uint256) {

contracts/lib/Checkpointing.sol

@@ -50,11 +50,11 @@ library Checkpointing {
     */
     function getLast(History storage self) internal view returns (uint256) {
         uint256 length = self.history.length;
-        if (length > uint256(0)) {
+        if (length > 0) {
             return uint256(self.history[length - 1].value);
         }
 
-        return uint256(0);
+        return 0;
     }
 
     /**
@@ -89,7 +89,7 @@ library Checkpointing {
     */
     function _add192(History storage self, uint64 _time, uint192 _value) private {
         uint256 length = self.history.length;
-        if (length == uint256(0) || self.history[self.history.length - 1].time < _time) {
+        if (length == 0 || self.history[self.history.length - 1].time < _time) {
             // If there was no value registered or the given point in time is after the latest registered value,
             // we can insert it to the history directly
             self.history.push(Checkpoint(_time, _value));
@@ -113,8 +113,8 @@ library Checkpointing {
     function _backwardsLinearSearch(History storage self, uint64 _time) private view returns (uint256) {
         // If there was no value registered for the given history return simply zero
         uint256 length = self.history.length;
-        if (length == uint256(0)) {
-            return uint256(0);
+        if (length == 0) {
+            return 0;
         }
 
         uint256 index = length - 1;
@@ -124,7 +124,7 @@ library Checkpointing {
             checkpoint = self.history[index];
         }
 
-        return checkpoint.time > _time ? uint256(0) : uint256(checkpoint.value);
+        return checkpoint.time > _time ? 0 : uint256(checkpoint.value);
     }
 
     /**
@@ -138,13 +138,13 @@ library Checkpointing {
     function _binarySearch(History storage self, uint64 _time) private view returns (uint256) {
         // If there was no value registered for the given history return simply zero
         uint256 length = self.history.length;
-        if (length == uint256(0)) {
-            return uint256(0);
+        if (length == 0) {
+            return 0;
         }
 
         // If the requested time is previous to the first registered value, return zero to denote missing checkpoint
         if (_time < self.history[0].time) {
-            return uint256(0);
+            return 0;
         }
 
         // Execute a binary search between the checkpointed times of the history

contracts/lib/HexSumTree.sol

@@ -97,7 +97,7 @@ library HexSumTree {
 
         // If the new value is not zero, first set the value of the new leaf node, then add a new level at the top of
         // the tree if necessary, and finally update sums cached in all the non-leaf nodes.
-        if (_value > uint256(0)) {
+        if (_value > 0) {
             _add(self, ITEMS_LEVEL, key, _time, _value);
             _updateSums(self, key, _time, _value, true);
         }
@@ -154,11 +154,11 @@ library HexSumTree {
      * @return values List of node values found for each requested value in the same order
      */
     function search(Tree storage self, uint256[] _values, uint64 _time) internal view returns (uint256[] keys, uint256[] values) {
-        require(_values.length > uint256(0), ERROR_MISSING_SEARCH_VALUES);
+        require(_values.length > 0, ERROR_MISSING_SEARCH_VALUES);
 
         // Throw out-of-bounds error if there are no items in the tree or the highest value being searched is greater than the total
         uint256 total = getTotalAt(self, _time, true);
-        require(total > uint256(0) && total >= _values[_values.length - 1], ERROR_SEARCH_OUT_OF_BOUNDS);
+        require(total > 0 && total >= _values[_values.length - 1], ERROR_SEARCH_OUT_OF_BOUNDS);
 
         // Build search params for the first iteration
         uint256 rootLevel = getHeightAt(self, _time);
@@ -401,7 +401,7 @@ library HexSumTree {
         uint256 mask = uint256(-1) << shift;
 
         // Check if the given key can be represented in the tree with the current given height using the mask.
-        return (_newKey & mask) != uint256(0);
+        return (_newKey & mask) != 0;
     }
 
     /**
@@ -413,8 +413,8 @@ library HexSumTree {
     */
     function _getValuesIncludedInSubtree(uint256[] memory _values, uint256 _foundValues, uint256 _subtreeTotal) private pure returns (uint256) {
         // If the given subtree total is zero, we already know any value will be included in it
-        if (_subtreeTotal == uint256(0)) {
-            return uint256(0);
+        if (_subtreeTotal == 0) {
+            return 0;
         }
 
         // Otherwise, look for all the values that can be found in the given subtree

contracts/lib/JurorsTreeSortition.sol

@@ -69,7 +69,7 @@ library JurorsTreeSortition {
         // first iteration. Thus, we can make sure we are not excluding any juror from the tree.
         uint256 totalActiveBalance = tree.getTotalAt(_termId, true);
         uint256 ratio = totalActiveBalance / _roundRequestedJurors;
-        low = _selectedJurors == uint256(0) ? uint256(1) : (_selectedJurors * ratio) + 1;
+        low = _selectedJurors == 0 ? 1 : (_selectedJurors * ratio) + 1;
 
         // This function assumes that `_roundRequestedJurors` is greater than or equal to `newSelectedJurors`
         uint256 newSelectedJurors = _selectedJurors + _batchRequestedJurors;

contracts/test/registry/JurorsRegistryMock.sol

@@ -40,11 +40,11 @@ contract JurorsRegistryMock is JurorsRegistry, TimeHelpersMock {
     }
 
     function _runHijackedSearch(uint256[7] _params) internal view returns (uint256[] keys, uint256[] nodeValues) {
-        uint256 _jurorsRequested = _params[4];
+        uint256 _requestedJurors = _params[4];
 
-        keys = new uint256[](_jurorsRequested);
-        nodeValues = new uint256[](_jurorsRequested);
-        for (uint256 i = 0; i < _jurorsRequested; i++) {
+        keys = new uint256[](_requestedJurors);
+        nodeValues = new uint256[](_requestedJurors);
+        for (uint256 i = 0; i < _requestedJurors; i++) {
             uint256 key = i % (tree.nextKey - 1) + 1; // loop, and avoid 0
             keys[i] = key;
             nodeValues[i] = tree.getItem(key);

test/court/court-appeal.js

@@ -181,7 +181,7 @@ contract('Court', ([_, disputer, drafter, appealMaker, appealTaker, juror500, ju
                   it('cannot be appealed twice', async () => {
                     await court.appeal(disputeId, roundId, appealMakerRuling, { from: appealMaker })
 
-                    await assertRevert(court.appeal(disputeId, roundId, appealMakerRuling, { from: appealMaker }), 'CT_ROUND_ALREADY_APPEALED')
+                    await assertRevert(court.appeal(disputeId, roundId, appealMakerRuling, { from: appealMaker }), 'CT_INVALID_ADJUDICATION_STATE')
                   })
                 })
 
@@ -223,7 +223,7 @@ contract('Court', ([_, disputer, drafter, appealMaker, appealTaker, juror500, ju
                 await courtHelper.passTerms(courtHelper.appealTerms)
               })
 
-              itIsAtState(roundId, ROUND_STATES.CONFIRMING_APPEAL)
+              itIsAtState(roundId, ROUND_STATES.ENDED)
               itFailsToAppeal(roundId)
             })
 
@@ -354,8 +354,7 @@ contract('Court', ([_, disputer, drafter, appealMaker, appealTaker, juror500, ju
       })
     })
 
-    // TODO: this scenario is not implemented in the contracts yet
-    context.skip('when the given dispute does not exist', () => {
+    context('when the given dispute does not exist', () => {
       it('reverts', async () => {
         await assertRevert(court.appeal(0, 0, OUTCOMES.LOW), 'CT_DISPUTE_DOES_NOT_EXIST')
       })

test/court/court-confirm-appeal.js

@@ -106,8 +106,8 @@ contract('Court', ([_, disputer, drafter, appealMaker, appealTaker, juror500, ju
                 await courtHelper.passTerms(courtHelper.appealTerms)
               })
 
-              itIsAtState(roundId, ROUND_STATES.CONFIRMING_APPEAL)
-              itFailsToConfirmAppeal(roundId, 'CT_ROUND_NOT_APPEALED')
+              itIsAtState(roundId, ROUND_STATES.ENDED)
+              itFailsToConfirmAppeal(roundId)
             })
 
             context('when the round was appealed', () => {

test/court/court-disputes.js

@@ -1,6 +1,6 @@
-const { bigExp } = require('../helpers/numbers')(web3)
+const { bn, bigExp } = require('../helpers/numbers')(web3)
 const { assertRevert } = require('@aragon/os/test/helpers/assertThrow')
-const { TOMORROW, ONE_DAY } = require('../helpers/time')
+const { NEXT_WEEK, ONE_DAY } = require('../helpers/time')
 const { buildHelper, DISPUTE_STATES } = require('../helpers/court')(web3, artifacts)
 const { assertAmountOfEvents, assertEvent } = require('@aragon/os/test/helpers/assertEvent')(web3)
 
@@ -12,8 +12,8 @@ const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 contract('Court', ([_, sender]) => {
   let courtHelper, court, feeToken, arbitrable
 
-  const termDuration = ONE_DAY
-  const firstTermStartTime = TOMORROW
+  const termDuration = bn(ONE_DAY)
+  const firstTermStartTime = bn(NEXT_WEEK)
   const jurorFee = bigExp(10, 18)
   const heartbeatFee = bigExp(20, 18)
   const draftFee = bigExp(30, 18)
@@ -115,13 +115,14 @@ contract('Court', ([_, sender]) => {
         })
       }
 
-      context('when the court is at term zero', () => {
+      context('when the given draft term is not after the current term', () => {
         it('reverts', async () => {
+          await courtHelper.setTerm(draftTermId)
           await assertRevert(court.createDispute(arbitrable.address, possibleRulings, jurorsNumber, draftTermId), 'CT_CANNOT_CREATE_DISPUTE')
         })
       })
 
-      context('when the court is after term zero', () => {
+      context('when the given draft term is after the current term', () => {
         beforeEach('set timestamp at the beginning of the first term', async () => {
           await courtHelper.setTimestamp(firstTermStartTime)
         })
@@ -144,7 +145,7 @@ contract('Court', ([_, sender]) => {
 
         context('when the term is outdated by more than one term', () => {
           beforeEach('set timestamp two terms after the first term', async () => {
-            await courtHelper.setTimestamp(firstTermStartTime + termDuration * 2)
+            await courtHelper.setTimestamp(firstTermStartTime.add(termDuration.mul(2)))
           })
 
           it('reverts', async () => {