disputes: update fisherman deposit to be fixed amount (#168)

Author: abarmat

DEPLOYMENT.md

@@ -1,19 +1,20 @@
 ## Deploying the Solidity Smart Contracts via Truffle
 
 `/migrations/2_deploy_contracts.js` contains the parameters needed to deploy the contracts. Please edit these params as you see fit.
+
 ```
 const initialSupply = 1000000, // total supply of Graph Tokens at time of deployment
   minimumCurationStakingAmount = 100, // minimum amount allowed to be staked by Market Curators
   defaultReserveRatio = 500000, // reserve ratio (percent as PPM)
   minimumIndexingStakingAmount = 100, // minimum amount allowed to be staked by Indexing Nodes
   maximumIndexers = 10, // maximum number of Indexing Nodes staked higher than stake to consider
-  slashingPercent = 10, // percent of stake to slash in successful dispute
+  slashingPercentage = 10, // percent of stake to slash in successful dispute
   thawingPeriod = 60 * 60 * 24 * 7, // amount of seconds to wait until indexer can finish stake logout
   multiSigRequiredVote = 0, // votes required (setting a required amount here will override a formula used later)
   multiSigOwners = [] // add addresses of the owners of the multisig contract here
 ```
 
-The `MultiSigWallet` contract is deployed first in order to retain its address for use in deploying the remaining contracts. 
+The `MultiSigWallet` contract is deployed first in order to retain its address for use in deploying the remaining contracts.
 
 The `Staking` contract requires both the address of the `MultiSigWallet` and the `GraphToken`.
 

contracts/DisputeManager.sol

@@ -82,9 +82,12 @@ contract DisputeManager is Governed {
     // The arbitrator is solely in control of arbitrating disputes
     address public arbitrator;
 
-    // Percent of stake to slash in successful dispute
+    // Minimum deposit required to create a Dispute
+    uint256 public minimumDeposit;
+
+    // Percentage of index node stake to slash in successful dispute
     // Parts per million. (Allows for 4 decimal points, 999,999 = 99.9999%)
-    uint256 public slashingPercent;
+    uint256 public slashingPercentage;
 
     // Graph Token address
     GraphToken public token;
@@ -137,20 +140,23 @@ contract DisputeManager is Governed {
      * @param _token <address> - Address of the Graph Protocol token
      * @param _arbitrator <address> - Arbitrator role
      * @param _staking <address> - Address of the staking contract used for slashing
-     * @param _slashingPercent <uint256> - Percent of stake the fisherman gets on slashing (in PPM)
+     * @param _slashingPercentage <uint256> - Percent of stake the fisherman gets on slashing (in PPM)
+     * @param _minimumDeposit <uint256> - Minimum deposit required to create a Dispute
      */
     constructor(
         address _governor,
         address _token,
         address _arbitrator,
         address _staking,
-        uint256 _slashingPercent
+        uint256 _slashingPercentage,
+        uint256 _minimumDeposit
     ) public Governed(_governor) {
         _setArbitrator(_arbitrator);
         token = GraphToken(_token);
         staking = Staking(_staking);
 
-        slashingPercent = _slashingPercent;
+        minimumDeposit = _minimumDeposit;
+        slashingPercentage = _slashingPercentage;
 
         // EIP-712 domain separator
         DOMAIN_SEPARATOR = keccak256(
@@ -180,7 +186,7 @@ contract DisputeManager is Governed {
      * @return <uint256> - Percentage of validator's stake to be considered a reward
      */
     function getRewardForStake(uint256 _value) public view returns (uint256) {
-        return slashingPercent.mul(_value).div(MAX_PPM); // slashingPercent is in PPM
+        return slashingPercentage.mul(_value).div(MAX_PPM); // slashingPercentage is in PPM
     }
 
     /**
@@ -229,26 +235,38 @@ contract DisputeManager is Governed {
         arbitrator = _arbitrator;
     }
 
+    /**
+     * @dev Set the minimum deposit required to create a dispute
+     * @notice Update the minimum deposit to `_minimumDeposit` Graph Tokens
+     * @param _minimumDeposit <uint256> - The minimum deposit in Graph Tokens
+     */
+    function setMinimumDeposit(uint256 _minimumDeposit)
+        external
+        onlyGovernance
+    {
+        minimumDeposit = _minimumDeposit;
+    }
+
     /**
      * @dev Set the percent that the fisherman gets when slashing occurs
-     * @notice Update the slashing percent to `_slashingPercent`
-     * @param _slashingPercent <uint256> - Slashing percent
+     * @notice Update the slashing percent to `_slashingPercentage`
+     * @param _slashingPercentage <uint256> - Slashing percentage
      */
-    function setSlashingPercent(uint256 _slashingPercent)
+    function setSlashingPercentage(uint256 _slashingPercentage)
         external
         onlyGovernance
     {
-        // Slashing Percent must be within 0% to 100% (inclusive)
+        // Must be within 0% to 100% (inclusive)
         require(
-            _slashingPercent >= 0,
-            "Slashing percent must above or equal to 0"
+            _slashingPercentage >= 0,
+            "Slashing percentage must above or equal to 0"
         );
         require(
-            _slashingPercent <= MAX_PPM,
-            "Slashing percent must be below or equal to MAX_PPM"
+            _slashingPercentage <= MAX_PPM,
+            "Slashing percentage must be below or equal to MAX_PPM"
         );
 
-        slashingPercent = _slashingPercent;
+        slashingPercentage = _slashingPercentage;
     }
 
     /**
@@ -307,7 +325,7 @@ contract DisputeManager is Governed {
         delete disputes[_disputeID]; // Re-entrancy protection
 
         // Have staking slash the index node and reward the fisherman
-        // Give the fisherman a reward equal to the slashingPercent of the indexer's stake
+        // Give the fisherman a reward equal to the slashingPercentage of the indexer's stake
         uint256 stake = staking.getIndexingNodeStake(
             dispute.subgraphID,
             dispute.indexNode
@@ -422,9 +440,9 @@ contract DisputeManager is Governed {
             "Dispute has no stake on the subgraph by the indexer node"
         );
 
-        // Ensure that fisherman has posted at least that amount
+        // Ensure that fisherman has staked at least that amount
         require(
-            _deposit >= getRewardForStake(stake),
+            _deposit >= minimumDeposit,
             "Dispute deposit under minimum required"
         );
 

graphProtocol.js

@@ -107,11 +107,11 @@ module.exports = (options = {}) => {
     }
 
     /**
-     * @dev Getter for `slashingPercent`
-     * @returns {Number} Slashing percent
+     * @dev Getter for `slashingPercentage`
+     * @returns {Number} Slashing percentage
      */
-    static slashingPercent() {
-      return Staking.slashingPercent()
+    static slashingPercentage() {
+      return Staking.slashingPercentage()
     }
 
     /**

migrations/2_deploy_contracts.js

@@ -22,7 +22,7 @@ const minimumIndexingStakingAmount = new BN('100000000000000000000')
 // maximum number of Indexing Nodes staked higher than stake to consider
 const maximumIndexers = 10
 // percent of stake to slash in successful dispute
-// const slashingPercent = 10
+// const slashingPercentage = 10
 // amount of seconds to wait until indexer can finish stake logout
 const thawingPeriod = 60 * 60 * 24 * 7
 // votes required (setting a required amount here will override a formula used later)

test/disputes.test.js

@@ -83,35 +83,64 @@ contract(
         )
       })
 
-      it('should set `slashingPercent`', async function() {
+      it('should set `slashingPercentage`', async function() {
+        const slashingPercentage = helpers.stakingConstants.slashingPercentage
+
         // Set right in the constructor
         expect(
-          await this.disputeManager.slashingPercent(),
-        ).to.be.bignumber.equal(
-          helpers.stakingConstants.slashingPercent.toString(),
-        )
-
-        // Can set if allowed
-        await this.disputeManager.setSlashingPercent(0, { from: governor })
-        await this.disputeManager.setSlashingPercent(1, { from: governor })
-        await this.disputeManager.setSlashingPercent(
-          helpers.stakingConstants.slashingPercent,
-          { from: governor },
-        )
+          await this.disputeManager.slashingPercentage(),
+        ).to.be.bignumber.equal(slashingPercentage.toString())
+
+        // Set new value
+        await this.disputeManager.setSlashingPercentage(0, { from: governor })
+        await this.disputeManager.setSlashingPercentage(1, { from: governor })
+        await this.disputeManager.setSlashingPercentage(slashingPercentage, {
+          from: governor,
+        })
       })
 
-      it('reject set `slashingPercent` if out of bounds', async function() {
+      it('reject set `slashingPercentage` if out of bounds', async function() {
         await expectRevert(
-          this.disputeManager.setSlashingPercent(MAX_PPM + 1, {
+          this.disputeManager.setSlashingPercentage(MAX_PPM + 1, {
             from: governor,
           }),
-          'Slashing percent must be below or equal to MAX_PPM',
+          'Slashing percentage must be below or equal to MAX_PPM',
         )
       })
 
-      it('reject set `slashingPercent` if not allowed', async function() {
+      it('reject set `slashingPercentage` if not allowed', async function() {
         await expectRevert(
-          this.disputeManager.setSlashingPercent(50, { from: other }),
+          this.disputeManager.setSlashingPercentage(50, { from: other }),
+          'Only Governor can call',
+        )
+      })
+      it('should set `minimumDeposit`', async function() {
+        const minimumDeposit =
+          helpers.stakingConstants.minimumDisputeDepositAmount
+        const newMinimumDeposit = web3.utils.toBN(1)
+
+        // Set right in the constructor
+        expect(
+          await this.disputeManager.minimumDeposit(),
+        ).to.be.bignumber.equal(minimumDeposit)
+
+        // Set new value
+        await this.disputeManager.setMinimumDeposit(newMinimumDeposit, {
+          from: governor,
+        })
+        expect(
+          await this.disputeManager.minimumDeposit(),
+        ).to.be.bignumber.equal(newMinimumDeposit)
+      })
+
+      it('reject set `minimumDeposit` if not allowed', async function() {
+        const minimumDeposit =
+          helpers.stakingConstants.minimumDisputeDepositAmount
+
+        await expectRevert(
+          this.disputeManager.setMinimumDeposit(minimumDeposit, {
+            from: other,
+          }),
           'Only Governor can call',
         )
       })
@@ -132,7 +161,7 @@ contract(
       it('should calculate the reward for a stake', async function() {
         const stakedAmount = 1000
         const trueReward =
-          (helpers.stakingConstants.slashingPercent * stakedAmount) / MAX_PPM
+          (helpers.stakingConstants.slashingPercentage * stakedAmount) / MAX_PPM
         const funcReward = await this.disputeManager.getRewardForStake(
           stakedAmount,
         )
@@ -219,9 +248,7 @@ contract(
             })
 
             // Minimum deposit a fisherman is required to do should be >= reward
-            const minimumDeposit = await this.disputeManager.getRewardForStake(
-              this.indexNodeStake,
-            )
+            const minimumDeposit = await this.disputeManager.minimumDeposit()
             const belowMinimumDeposit = minimumDeposit.sub(web3.utils.toBN(1))
 
             // Create invalid dispute as deposit is below minimum

test/lib/deployment.js

@@ -40,14 +40,17 @@ function deployDisputeManagerContract(
   staking,
   params,
 ) {
-  const slashingPercent = helpers.stakingConstants.slashingPercent
+  const slashingPercentage = helpers.stakingConstants.slashingPercentage
+  const minimumDisputeDepositAmount =
+    helpers.stakingConstants.minimumDisputeDepositAmount
 
   return DisputeManager.new(
     owner,
     graphToken,
     arbitrator,
     staking,
-    slashingPercent,
+    slashingPercentage,
+    minimumDisputeDepositAmount,
     params,
   )
 }

test/lib/testHelpers.js

@@ -297,11 +297,13 @@ module.exports = {
   stakingConstants: {
     // 100 * 10^18 minimum amount allowed to be staked by Market Curators
     minimumCurationStakingAmount: new BN('100000000000000000000'),
-    // 100 * 10^18 minimum amount allowed to be staked by Market Curators
+    // 100 * 10^18 minimum amount allowed to be staked by Indexers
     minimumIndexingStakingAmount: new BN('100000000000000000000'),
+    // 100 * 10^18 minimum amount required as deposit to create a Dispute
+    minimumDisputeDepositAmount: new BN('100000000000000000000'),
     defaultReserveRatio: 500000,
     maximumIndexers: 10,
-    slashingPercent: 1000,
+    slashingPercentage: 1000,
     thawingPeriod: 60 * 60 * 24 * 7, // In seconds
     thawingPeriodSimple: 0,
   },