curation: rename minimum curation stake to deposit

abarmat · abarmat · commit f21b86ab1b5b · 2020-07-28T11:02:06.000-03:00
diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md
@@ -71,41 +71,45 @@ Example:
 
 ```
 general:
-  governor: &governor "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
+  arbitrator: &arbitrator "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
   nodeSignerAddress: &nodeSignerAddress "0x0000000000000000000000000000000000000000"
 
 contracts:
   Curation:
-    governor: *governor
-    token: "${{GraphToken.address}}"
-    reserveRatio: 500000
-    minimumCurationStake: "100000000000000000000" # 100 GRT
-    __calls:
+    init:
+      token: "${{GraphToken.address}}"
+      reserveRatio: 500000 # 50% bonding curve reserve ratio parameter
+      minimumCurationDeposit: "100000000000000000000" # 100 GRT
+    proxy: true
+    calls:
       - fn: "setWithdrawalFeePercentage"
-        withdrawalFeePercentage: 50000
+        withdrawalFeePercentage: 50000 # 5% fee for redeeming signal
   DisputeManager:
-    governor: *governor
-    arbitrator: *governor
-    token: "${{GraphToken.address}}"
-    staking: "${{Staking.address}}"
-    minimumDeposit: "100000000000000000000" # 100 GRT
-    fishermanRewardPercentage: 1000 # in basis points
-    slashingPercentage: 1000 # in basis points
+    init:
+      arbitrator: *arbitrator
+      token: "${{GraphToken.address}}"
+      staking: "${{Staking.address}}"
+      minimumDeposit: "100000000000000000000" # 100 GRT
+      fishermanRewardPercentage: 100000 # in basis points
+      slashingPercentage: 50000 # in basis points
   EpochManager:
-    governor: *governor
-    lengthInBlocks: 5760 # One day in blocks
+    init:
+      lengthInBlocks: 5760 # One day in blocks
+    proxy: true
   GNS:
-    governor: *governor
+    init:
+      didRegistry: "0xdca7ef03e98e0dc2b855be647c39abe984fcf21b"
+      curation: "${{Curation.address}}"
+      token: "${{GraphToken.address}}"
   GraphToken:
-    governor: *governor
-    initialSupply: "10000000000000000000000000" # 10000000 GRT
-  RewardManager:
-    governor: *governor
+    init:
+      initialSupply: "10000000000000000000000000" # 10000000 GRT
   Staking:
-    governor: *governor
-    token: "${{GraphToken.address}}"
-    epochManager: "${{EpochManager.address}}"
-    __calls:
+    init:
+      token: "${{GraphToken.address}}"
+      epochManager: "${{EpochManager.address}}"
+    proxy: true
+    calls:
       - fn: "setCuration"
         curation: "${{Curation.address}}"
       - fn: "setChannelDisputeEpochs"
@@ -115,12 +119,13 @@ contracts:
       - fn: "setThawingPeriod"
         thawingPeriod: 20 # in blocks
   MinimumViableMultisig:
-    node: *nodeSignerAddress
-    staking: "${{Staking.address}}"
-    CTDT: "${{IndexerCTDT.address}}"
-    singleAssetInterpreter: "${{IndexerSingleAssetInterpreter.address}}"
-    multiAssetInterpreter: "${{IndexerMultiAssetInterpreter.address}}"
-    withdrawInterpreter: "${{IndexerWithdrawInterpreter.address}}"
+    init:
+      node: *nodeSignerAddress
+      staking: "${{Staking.address}}"
+      CTDT: "${{IndexerCTDT.address}}"
+      singleAssetInterpreter: "${{IndexerSingleAssetInterpreter.address}}"
+      multiAssetInterpreter: "${{IndexerMultiAssetInterpreter.address}}"
+      withdrawInterpreter: "${{IndexerWithdrawInterpreter.address}}"
 ```
 
 ### Address book
diff --git a/contracts/curation/Curation.sol b/contracts/curation/Curation.sol
@@ -14,7 +14,7 @@ import "./ICuration.sol";
  * @dev Allows curators to signal on subgraph deployments that might be relevant to indexers by
  * staking Graph Tokens (GRT). Additionally, curators earn fees from the Query Market related to the
  * subgraph deployment they curate.
- * A curators stake goes to a curation pool along with the stakes of other curators,
+ * A curators deposit goes to a curation pool along with the deposits of other curators,
  * only one such pool exists for each subgraph deployment.
  * The contract mints Graph Signal Tokens (GST) according to a bonding curve for each individual
  * curation pool where GRT is deposited.
@@ -27,13 +27,13 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     // 100% in parts per million
     uint32 private constant MAX_PPM = 1000000;
 
-    // Amount of signal you get with your minimum token stake
-    uint256 private constant SIGNAL_PER_MINIMUM_STAKE = 1 ether;
+    // Amount of signal you get with your minimum token deposit
+    uint256 private constant SIGNAL_PER_MINIMUM_DEPOSIT = 1e18; // 1 signal as 18 decimal number
 
     // -- Events --
 
     /**
-     * @dev Emitted when `curator` staked `tokens` on `subgraphDeploymentID` as curation signal.
+     * @dev Emitted when `curator` deposited `tokens` on `subgraphDeploymentID` as curation signal.
      * The `curator` receives `signal` amount according to the curation pool bonding curve.
      */
     event Signalled(
@@ -69,28 +69,28 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
         address _governor,
         address _token,
         uint32 _defaultReserveRatio,
-        uint256 _minimumCurationStake
+        uint256 _minimumCurationDeposit
     ) external onlyImpl {
         Governed._initialize(_governor);
         BancorFormula._initialize();
 
         token = IGraphToken(_token);
         defaultReserveRatio = _defaultReserveRatio;
-        minimumCurationStake = _minimumCurationStake;
+        minimumCurationDeposit = _minimumCurationDeposit;
     }
 
     /**
      * @dev Accept to be an implementation of proxy and run initializer.
      * @param _proxy Graph proxy delegate caller
      * @param _token Address of the Graph Protocol token
      * @param _defaultReserveRatio Reserve ratio to initialize the bonding curve of CurationPool
-     * @param _minimumCurationStake Minimum amount of tokens that curators can stake
+     * @param _minimumCurationDeposit Minimum amount of tokens that curators can deposit
      */
     function acceptProxy(
         GraphProxy _proxy,
         address _token,
         uint32 _defaultReserveRatio,
-        uint256 _minimumCurationStake
+        uint256 _minimumCurationDeposit
     ) external {
         // Accept to be the implementation for this proxy
         _acceptUpgrade(_proxy);
@@ -100,7 +100,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
             _proxy.admin(), // default governor is proxy admin
             _token,
             _defaultReserveRatio,
-            _minimumCurationStake
+            _minimumCurationDeposit
         );
     }
 
@@ -132,19 +132,23 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     }
 
     /**
-     * @dev Set the minimum stake amount for curators.
-     * @notice Update the minimum stake amount to `_minimumCurationStake`
-     * @param _minimumCurationStake Minimum amount of tokens required stake
+     * @dev Set the minimum deposit amount for curators.
+     * @notice Update the minimum deposit amount to `_minimumCurationDeposit`
+     * @param _minimumCurationDeposit Minimum amount of tokens required deposit
      */
-    function setMinimumCurationStake(uint256 _minimumCurationStake) external override onlyGovernor {
-        require(_minimumCurationStake > 0, "Minimum curation stake cannot be 0");
-        minimumCurationStake = _minimumCurationStake;
-        emit ParameterUpdated("minimumCurationStake");
+    function setMinimumCurationDeposit(uint256 _minimumCurationDeposit)
+        external
+        override
+        onlyGovernor
+    {
+        require(_minimumCurationDeposit > 0, "Minimum curation deposit cannot be 0");
+        minimumCurationDeposit = _minimumCurationDeposit;
+        emit ParameterUpdated("minimumCurationDeposit");
     }
 
     /**
-     * @dev Set the fee percentage to charge when a curator withdraws stake.
-     * @param _percentage Percentage fee charged when withdrawing stake
+     * @dev Set the fee percentage to charge when a curator withdraws GRT tokens.
+     * @param _percentage Percentage fee charged when withdrawing GRT tokens
      */
     function setWithdrawalFeePercentage(uint32 _percentage) external override onlyGovernor {
         // Must be within 0% to 100% (inclusive)
@@ -175,9 +179,9 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     }
 
     /**
-     * @dev Stake Graph Tokens in exchange for signal of a SubgraphDeployment curation pool.
+     * @dev Deposit Graph Tokens in exchange for signal of a SubgraphDeployment curation pool.
      * @param _subgraphDeploymentID Subgraph deployment pool from where to mint signal
-     * @param _tokens Amount of Graph Tokens to stake
+     * @param _tokens Amount of Graph Tokens to deposit
      * @return Signal minted
      */
     function mint(bytes32 _subgraphDeploymentID, uint256 _tokens)
@@ -187,16 +191,16 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     {
         address curator = msg.sender;
 
-        // Need to stake some funds
-        require(_tokens > 0, "Cannot stake zero tokens");
+        // Need to deposit some funds
+        require(_tokens > 0, "Cannot deposit zero tokens");
 
         // Transfer tokens from the curator to this contract
         require(
             token.transferFrom(curator, address(this), _tokens),
-            "Cannot transfer tokens to stake"
+            "Cannot transfer tokens to deposit"
         );
 
-        // Stake tokens to a curation pool reserve
+        // Deposit tokens to a curation pool reserve
         return _mint(curator, _subgraphDeploymentID, _tokens);
     }
 
@@ -245,7 +249,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     }
 
     /**
-     * @dev Check if any Graph tokens are staked for a SubgraphDeployment.
+     * @dev Check if any GRT tokens are deposited for a SubgraphDeployment.
      * @param _subgraphDeploymentID SubgraphDeployment to check if curated
      * @return True if curated
      */
@@ -309,9 +313,9 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
 
         // Init curation pool
         if (curationPool.tokens == 0) {
-            newTokens = newTokens.sub(minimumCurationStake);
-            curTokens = minimumCurationStake;
-            curSignal = SIGNAL_PER_MINIMUM_STAKE;
+            newTokens = newTokens.sub(minimumCurationDeposit);
+            curTokens = minimumCurationDeposit;
+            curSignal = SIGNAL_PER_MINIMUM_DEPOSIT;
             reserveRatio = defaultReserveRatio;
         }
 
@@ -424,7 +428,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
      * @dev Deposit Graph Tokens in exchange for signal of a curation pool.
      * @param _curator Address of the staking party
      * @param _subgraphDeploymentID Subgraph deployment from where the curator is minting
-     * @param _tokens Amount of Graph Tokens to stake
+     * @param _tokens Amount of Graph Tokens to deposit
      * @return Signal minted
      */
     function _mint(
@@ -436,7 +440,10 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
 
         // If it hasn't been curated before then initialize the curve
         if (!isCurated(_subgraphDeploymentID)) {
-            require(_tokens >= minimumCurationStake, "Curation stake is below minimum required");
+            require(
+                _tokens >= minimumCurationDeposit,
+                "Curation deposit is below minimum required"
+            );
 
             // Initialize
             curationPool.reserveRatio = defaultReserveRatio;
diff --git a/contracts/curation/CurationStorage.sol b/contracts/curation/CurationStorage.sol
@@ -17,17 +17,17 @@ contract CurationV1Storage is BancorFormula {
 
     // -- State --
 
-    // Fee charged when curator withdraw stake
+    // Fee charged when curator withdraw deposit
     // Parts per million. (Allows for 4 decimal points, 999,999 = 99.9999%)
     uint32 public withdrawalFeePercentage;
 
     // Default reserve ratio to configure curator shares bonding curve
     // Parts per million. (Allows for 4 decimal points, 999,999 = 99.9999%)
     uint32 public defaultReserveRatio;
 
-    // Minimum amount allowed to be staked by curators
+    // Minimum amount allowed to be deposit by curators
     // This is the `startPoolBalance` for the bonding curve
-    uint256 public minimumCurationStake;
+    uint256 public minimumCurationDeposit;
 
     // Mapping of subgraphDeploymentID => CurationPool
     // There is only one CurationPool per SubgraphDeploymentID
diff --git a/contracts/curation/ICuration.sol b/contracts/curation/ICuration.sol
@@ -7,7 +7,7 @@ interface ICuration {
 
     function setStaking(address _staking) external;
 
-    function setMinimumCurationStake(uint256 _minimumCurationStake) external;
+    function setMinimumCurationDeposit(uint256 _minimumCurationDeposit) external;
 
     function setWithdrawalFeePercentage(uint32 _percentage) external;
 
diff --git a/graph.config.yml b/graph.config.yml
@@ -7,7 +7,7 @@ contracts:
     init:
       token: "${{GraphToken.address}}"
       reserveRatio: 500000 # 50% bonding curve reserve ratio parameter
-      minimumCurationStake: "100000000000000000000" # 100 GRT
+      minimumCurationDeposit: "100000000000000000000" # 100 GRT
     proxy: true
     calls:
       - fn: "setWithdrawalFeePercentage"
diff --git a/test/curation/configuration.test.ts b/test/curation/configuration.test.ts
@@ -86,26 +86,26 @@ describe('Curation:Config', () => {
     })
   })
 
-  describe('minimumCurationStake', function () {
-    it('should set `minimumCurationStake`', async function () {
+  describe('minimumCurationDeposit', function () {
+    it('should set `minimumCurationDeposit`', async function () {
       // Set right in the constructor
-      expect(await curation.minimumCurationStake()).eq(defaults.curation.minimumCurationStake)
+      expect(await curation.minimumCurationDeposit()).eq(defaults.curation.minimumCurationDeposit)
 
       // Can set if allowed
       const newValue = toBN('100')
-      await curation.connect(governor.signer).setMinimumCurationStake(newValue)
-      expect(await curation.minimumCurationStake()).eq(newValue)
+      await curation.connect(governor.signer).setMinimumCurationDeposit(newValue)
+      expect(await curation.minimumCurationDeposit()).eq(newValue)
     })
 
-    it('reject set `minimumCurationStake` if out of bounds', async function () {
-      const tx = curation.connect(governor.signer).setMinimumCurationStake(0)
-      await expect(tx).revertedWith('Minimum curation stake cannot be 0')
+    it('reject set `minimumCurationDeposit` if out of bounds', async function () {
+      const tx = curation.connect(governor.signer).setMinimumCurationDeposit(0)
+      await expect(tx).revertedWith('Minimum curation deposit cannot be 0')
     })
 
-    it('reject set `minimumCurationStake` if not allowed', async function () {
+    it('reject set `minimumCurationDeposit` if not allowed', async function () {
       const tx = curation
         .connect(me.signer)
-        .setMinimumCurationStake(defaults.curation.minimumCurationStake)
+        .setMinimumCurationDeposit(defaults.curation.minimumCurationDeposit)
       await expect(tx).revertedWith('Only Governor can call')
     })
   })
diff --git a/test/curation/curation.test.ts b/test/curation/curation.test.ts
diff --git a/test/lib/deployment.ts b/test/lib/deployment.ts
