staking: add more staking tests (#202)

* staking: add more tests to staking and test improvements
* staking: fix edge conditions when settling
* staking:
- fix edge case when epochSince is in the future
- add more tests for settle and claim
- use ABDKMath64x64 for sqrt() calculations
* staking: add state checks after settle
* staking:
- Add check to DisputeManager to avoid accepting disputes of indexers with zero tokens to slash
- Add check to Staking to avoid slashing zero tokens
- Add check to Staking to avoid staking zero tokens
- Add check in Rebates calculation to avoid division by zero when no fees in rebate pool
- Improve check in Staking contract `settle()` when comparing allocation channelID
- Allow to claim a zero tokens settlement from the rebate pool
- Fix comment in test helpers config
- Add tests for all of the above

Author: abarmat

.soliumignore

@@ -4,3 +4,4 @@ contracts/Migrations.sol
 contracts/bancor
 contracts/openzeppelin
 contracts/MultiSigWallet.sol
+contracts/abdk-libraries-solidity

contracts/Curation.sol

@@ -9,12 +9,10 @@ pragma experimental ABIEncoderV2;
 import "./Governed.sol";
 import "./GraphToken.sol";
 import "./bancor/BancorFormula.sol";
-import "./bytes/BytesLib.sol";
 import "@openzeppelin/contracts/math/SafeMath.sol";
 
 
 contract Curation is Governed, BancorFormula {
-    using BytesLib for bytes;
     using SafeMath for uint256;
 
     // -- Curation --
@@ -29,9 +27,6 @@ contract Curation is Governed, BancorFormula {
     // 100% in parts per million
     uint256 private constant MAX_PPM = 1000000;
 
-    // 1 basis point (0.01%) is 100 parts per million (PPM)
-    uint256 private constant BASIS_PT = 100;
-
     // Amount of shares you get with your minimum token stake
     uint256 private constant SHARES_PER_MINIMUM_STAKE = 1;
 

contracts/DisputeManager.sol

@@ -51,9 +51,6 @@ contract DisputeManager is Governed {
     // 100% in parts per million
     uint256 private constant MAX_PPM = 1000000;
 
-    // 1 basis point (0.01%) is 100 parts per million (PPM)
-    uint256 private constant BASIS_PT = 100;
-
     // -- State --
 
     bytes32 private DOMAIN_SEPARATOR;
@@ -206,7 +203,7 @@ contract DisputeManager is Governed {
      * @return Amount of tokens to slash
      */
     function getTokensToSlash(address _indexer) public view returns (uint256) {
-        uint256 tokens = staking.getIndexerStakeTokens(_indexer); // slashable tokens
+        uint256 tokens = staking.getIndexerStakedTokens(_indexer); // slashable tokens
         return slashingPercentage.mul(tokens).div(MAX_PPM);
     }
 
@@ -319,8 +316,10 @@ contract DisputeManager is Governed {
 
         // Have staking contract slash the indexer and reward the fisherman
         // Give the fisherman a reward equal to the fishermanRewardPercentage of slashed amount
-        uint256 tokensToReward = getTokensToReward(dispute.indexer);
         uint256 tokensToSlash = getTokensToSlash(dispute.indexer);
+        uint256 tokensToReward = getTokensToReward(dispute.indexer);
+
+        require(tokensToSlash > 0, "Dispute has zero tokens to slash");
         staking.slash(dispute.indexer, tokensToSlash, tokensToReward, dispute.fisherman);
 
         // Give the fisherman their deposit back

contracts/EpochManager.sol

@@ -139,7 +139,7 @@ contract EpochManager is Governed {
      */
     function epochsSince(uint256 _epoch) public view returns (uint256, uint256) {
         uint256 epoch = currentEpoch();
-        return (epoch.sub(_epoch), epoch);
+        return (_epoch < epoch ? epoch.sub(_epoch) : 0, epoch);
     }
 
     /**

contracts/Staking.sol

@@ -31,9 +31,6 @@ contract Staking is Governed {
     // 100% in parts per million
     uint256 private constant MAX_PPM = 1000000;
 
-    // 1 basis point (0.01%) is 100 parts per million (PPM)
-    uint256 private constant BASIS_PT = 100;
-
     // -- State --
 
     // Percentage of fees going to curators
@@ -157,17 +154,14 @@ contract Staking is Governed {
      * @param _governor Owner address of this contract
      * @param _token Address of the Graph Protocol token
      * @param _epochManager Address of the EpochManager contract
-     * @param _curation Address of the Curation contract
      */
     constructor(
         address _governor,
         address _token,
-        address _epochManager,
-        address _curation
+        address _epochManager
     ) public Governed(_governor) {
         token = GraphToken(_token);
         epochManager = EpochManager(_epochManager);
-        curation = Curation(_curation);
     }
 
     /**
@@ -250,7 +244,7 @@ contract Staking is Governed {
      * @param _indexer Address of the indexer
      * @return Amount of tokens staked by the indexer
      */
-    function getIndexerStakeTokens(address _indexer) public view returns (uint256) {
+    function getIndexerStakedTokens(address _indexer) public view returns (uint256) {
         return stakes[_indexer].tokensIndexer;
     }
 
@@ -268,6 +262,21 @@ contract Staking is Governed {
         return stakes[_indexer].allocations[_subgraphID];
     }
 
+    /**
+     * @dev Get an outstanding unclaimed settlement
+     * @param _epoch Epoch when the settlement ocurred
+     * @param _indexer Address of the indexer
+     * @param _subgraphID ID of the subgraph settled
+     * @return Settlement data
+     */
+    function getSettlement(
+        uint256 _epoch,
+        address _indexer,
+        bytes32 _subgraphID
+    ) public view returns (Rebates.Settlement memory) {
+        return rebates[_epoch].settlements[_indexer][_subgraphID];
+    }
+
     /**
      * @dev Slash the indexer stake
      * @param _indexer Address of indexer to slash
@@ -283,9 +292,10 @@ contract Staking is Governed {
     ) external onlySlasher {
         Stakes.Indexer storage indexerStake = stakes[_indexer];
 
+        require(_tokens > 0, "Slashing: cannot slash zero tokens");
+        require(_tokens >= _reward, "Slashing: reward cannot be higher than slashed amount");
         require(indexerStake.hasTokens(), "Slashing: indexer has no stakes");
         require(_beneficiary != address(0), "Slashing: beneficiary must not be an empty address");
-        require(_tokens >= _reward, "Slashing: reward cannot be higher than slashed amount");
         require(
             _tokens <= indexerStake.tokensSlashable(),
             "Slashing: cannot slash more than staked amount"
@@ -328,11 +338,14 @@ contract Staking is Governed {
     function stake(uint256 _tokens) external {
         address indexer = msg.sender;
 
+        require(_tokens > 0, "Staking: cannot stake zero tokens");
+
         // Transfer tokens to stake from indexer to this contract
         require(
             token.transferFrom(indexer, address(this), _tokens),
             "Staking: Cannot transfer tokens to stake"
         );
+
         // Stake the transferred tokens
         _stake(indexer, _tokens);
     }
@@ -460,24 +473,27 @@ contract Staking is Governed {
             epochsSinceSettlement >= channelDisputeEpochs,
             "Rebate: need to wait channel dispute period"
         );
+
         require(settlement.allocation > 0, "Rebate: settlement does not exist");
 
         // Process rebate
         uint256 tokensToClaim = pool.redeem(indexer, _subgraphID);
-        require(tokensToClaim > 0, "Rebate: no tokens available to claim");
 
-        // All settlements processed then prune rebate pool
+        // When all settlements processed then prune rebate pool
         if (pool.settlementsCount == 0) {
             delete rebates[_epoch];
         }
 
-        // Assign claimed tokens
-        if (_restake) {
-            // Restake to place fees into the indexer stake
-            _stake(indexer, tokensToClaim);
-        } else {
-            // Transfer funds back to the indexer
-            require(token.transfer(indexer, tokensToClaim), "Rebate: cannot transfer tokens");
+        // When there are tokens to claim from the rebate pool, transfer or restake
+        if (tokensToClaim > 0) {
+            // Assign claimed tokens
+            if (_restake) {
+                // Restake to place fees into the indexer stake
+                _stake(indexer, tokensToClaim);
+            } else {
+                // Transfer funds back to the indexer
+                require(token.transfer(indexer, tokensToClaim), "Rebate: cannot transfer tokens");
+            }
         }
 
         emit RebateClaimed(
@@ -517,7 +533,11 @@ contract Staking is Governed {
         bytes32 subgraphID = channels[_channelID].subgraphID;
         Stakes.Allocation storage alloc = stakes[indexer].allocations[subgraphID];
 
-        require(alloc.hasChannel(), "Channel: Must be active for settlement");
+        require(_channelID != address(0), "Channel: ChannelID cannot be empty address");
+        require(
+            alloc.channelID == _channelID,
+            "Channel: The allocation has no channel, or the channel was already settled"
+        );
 
         // Time conditions
         (uint256 epochs, uint256 currentEpoch) = epochManager.epochsSince(alloc.createdAtEpoch);
@@ -558,8 +578,8 @@ contract Staking is Governed {
             _tokens,
             _channelID,
             _from,
-            rebateFees,
             curationFees,
+            rebateFees,
             effectiveAllocation
         );
     }

contracts/abdk-libraries-solidity/ABDKMath64x64.sol

@@ -0,0 +1,79 @@
+/*
+ * TheGraph is using this software as described in the README.md in this folder
+ * https://github.com/abdk-consulting/abdk-libraries-solidity/tree/939f0a264f2d07a9e2c7a3a020f0db2c0885dc01
+ *
+ * This library has been significantly reduced to only include the functions needed for the Graph Protocol
+ * Please visit the library at the link above for more details
+ */
+
+/*
+ * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
+ * Author: Mikhail Vladimirov <[email protected]>
+ */
+pragma solidity 0.6.4;
+
+
+/**
+ * Smart contract library of mathematical functions operating with signed
+ * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
+ * basically a simple fraction whose numerator is signed 128-bit integer and
+ * denominator is 2^64.  As long as denominator is always the same, there is no
+ * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
+ * represented by int128 type holding only the numerator.
+ */
+library ABDKMath64x64 {
+    /**
+     * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
+     * number.  Revert on overflow.
+     *
+     * @param x unsigned 256-bit integer number
+     * @return signed 64.64-bit fixed point number
+     */
+    function fromUInt(uint256 x) internal pure returns (int128) {
+        require(x <= 0x7FFFFFFFFFFFFFFF);
+        return int128(x << 64);
+    }
+
+    /**
+     * Convert signed 64.64 fixed point number into unsigned 64-bit integer
+     * number rounding down.  Revert on underflow.
+     *
+     * @param x signed 64.64-bit fixed point number
+     * @return unsigned 64-bit integer number
+     */
+    function toUInt(int128 x) internal pure returns (uint64) {
+        require(x >= 0);
+        return uint64(x >> 64);
+    }
+
+    /**
+     * Calculate sqrt (x) rounding down.  Revert if x < 0.
+     *
+     * @param x signed 64.64-bit fixed point number
+     * @return signed 64.64-bit fixed point number
+     */
+    function sqrt(int128 x) internal pure returns (int128) {
+        require(x >= 0);
+        return int128(sqrtu(uint256(x) << 64, 0x10000000000000000));
+    }
+
+    /**
+     * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
+     * number.
+     *
+     * @param x unsigned 256-bit integer number
+     * @return unsigned 128-bit integer number
+     */
+    function sqrtu(uint256 x, uint256 r) private pure returns (uint128) {
+        if (x == 0) return 0;
+        else {
+            require(r > 0);
+            while (true) {
+                uint256 rr = x / r;
+                if (r == rr || r + 1 == rr) return uint128(r);
+                else if (r == rr + 1) return uint128(rr);
+                r = (r + rr + 1) >> 1;
+            }
+        }
+    }
+}

contracts/abdk-libraries-solidity/README.md

@@ -0,0 +1,47 @@
+ABDK Libraries for Solidity
+===========================
+
+Copyright (c) 2019, [ABDK Consulting](https://abdk.consulting/)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software must
+   display the following acknowledgement: This product includes software
+   developed by ABDK Consulting.
+4. Neither the name of ABDK Consulting nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY ABDK CONSULTING ''AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL ABDK CONSULTING BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+
+Math 64.64
+----------
+
+Library of mathematical functions operating with signed 64.64-bit fixed point
+numbers.
+
+\[ [documentation](ABDKMath64x64.md) | [source](ABDKMath64x64.sol) \]
+
+Math Quad
+---------
+
+Library of mathematical functions operating with IEEE 754 quadruple precision
+(128 bit) floating point numbers.
+
+\[ [documentation](ABDKMathQuad.md) | [source](ABDKMathQuad.sol) \]