rewards: implement a rewards contract that assigns GRT tokens to indexer based on participation (allocations) and subgraph popularity (curation)

Author: abarmat

contracts/curation/Curation.sol

@@ -114,6 +114,15 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
         emit ParameterUpdated("staking");
     }
 
+    /**
+     * @dev Set the rewards manager contract.
+     * @param _rewardsManager Address of the rewards manager contract
+     */
+    function setRewardsManager(address _rewardsManager) external override onlyGovernor {
+        rewardsManager = IRewardsManager(_rewardsManager);
+        emit ParameterUpdated("rewardsManager");
+    }
+
     /**
      * @dev Set the default reserve ratio percentage for a curation pool.
      * @notice Update the default reserver ratio to `_defaultReserveRatio`
@@ -224,6 +233,9 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
             "Cannot burn more signal than you own"
         );
 
+        // Trigger update rewards calculation
+        _updateRewards(_subgraphDeploymentID);
+
         // Update balance and get the amount of tokens to refund based on returned signal
         (uint256 tokens, uint256 withdrawalFees) = _burnSignal(
             curator,
@@ -278,7 +290,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
     /**
      * @dev Get the amount of signal in a curation pool.
      * @param _subgraphDeploymentID Subgraph deployment curation poool
-     * @return Amount of signal owned by a curator for the subgraph deployment
+     * @return Amount of signal minted for the subgraph deployment
      */
     function getCurationPoolSignal(bytes32 _subgraphDeploymentID)
         public
@@ -292,6 +304,20 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
         return pools[_subgraphDeploymentID].gst.totalSupply();
     }
 
+    /**
+     * @dev Get the amount of token reserves in a curation pool.
+     * @param _subgraphDeploymentID Subgraph deployment curation poool
+     * @return Amount of token reserves in the curation pool
+     */
+    function getCurationPoolTokens(bytes32 _subgraphDeploymentID)
+        public
+        override
+        view
+        returns (uint256)
+    {
+        return pools[_subgraphDeploymentID].tokens;
+    }
+
     /**
      * @dev Calculate amount of signal that can be bought with tokens in a curation pool.
      * @param _subgraphDeploymentID Subgraph deployment to mint signal
@@ -374,15 +400,18 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
         bytes32 _subgraphDeploymentID,
         uint256 _tokens
     ) private returns (uint256) {
-        CurationPool storage curationPool = pools[_subgraphDeploymentID];
         uint256 signal = tokensToSignal(_subgraphDeploymentID, _tokens);
 
+        // Update curation pool
+        CurationPool storage curationPool = pools[_subgraphDeploymentID];
         // Update GRT tokens held as reserves
         curationPool.tokens = curationPool.tokens.add(_tokens);
-
         // Mint signal to the curator
         curationPool.gst.mint(_curator, signal);
 
+        // Update the global reserve
+        totalTokens = totalTokens.add(_tokens);
+
         return signal;
     }
 
@@ -398,15 +427,19 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
         bytes32 _subgraphDeploymentID,
         uint256 _signal
     ) private returns (uint256, uint256) {
-        CurationPool storage curationPool = pools[_subgraphDeploymentID];
         (uint256 tokens, uint256 withdrawalFees) = signalToTokens(_subgraphDeploymentID, _signal);
+        uint256 outTokens = tokens.add(withdrawalFees);
 
+        // Update curation pool
+        CurationPool storage curationPool = pools[_subgraphDeploymentID];
         // Update GRT tokens held as reserves
-        curationPool.tokens = curationPool.tokens.sub(tokens.add(withdrawalFees));
-
+        curationPool.tokens = curationPool.tokens.sub(outTokens);
         // Burn signal from curator
         curationPool.gst.burnFrom(_curator, _signal);
 
+        // Update the global reserve
+        totalTokens = totalTokens.sub(outTokens);
+
         return (tokens, withdrawalFees);
     }
 
@@ -458,10 +491,24 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration, Governed {
             }
         }
 
-        // Update balances
+        // Trigger update rewards calculation
+        _updateRewards(_subgraphDeploymentID);
+
+        // Exchange GRT tokens for GST of the subgraph pool
         uint256 signal = _mintSignal(_curator, _subgraphDeploymentID, _tokens);
 
         emit Signalled(_curator, _subgraphDeploymentID, _tokens, signal);
         return signal;
     }
+
+    /**
+     * @dev Triggers an update of rewards due to a change in signal.
+     * @param _subgraphDeploymentID Subgrapy deployment updated
+     */
+    function _updateRewards(bytes32 _subgraphDeploymentID) internal returns (uint256) {
+        if (address(rewardsManager) != address(0)) {
+            return rewardsManager.onSubgraphSignalUpdate(_subgraphDeploymentID);
+        }
+        return 0;
+    }
 }

contracts/curation/CurationStorage.sol

@@ -1,43 +1,37 @@
 pragma solidity ^0.6.4;
 
 import "../bancor/BancorFormula.sol";
+import "../rewards/IRewardsManager.sol";
 import "../staking/IStaking.sol";
 import "../token/IGraphToken.sol";
 
-import "./GraphSignalToken.sol";
+import "./ICuration.sol";
 
 contract CurationV1Storage is BancorFormula {
-    // -- Pool --
-
-    struct CurationPool {
-        uint256 tokens; // GRT Tokens stored as reserves for the subgraph deployment
-        uint32 reserveRatio; // Ratio for the bonding curve
-        GraphSignalToken gst; // Signal token contract for this curation pool
-    }
-
     // -- State --
 
-    // Fee charged when curator withdraw deposit
+    // Fee charged when curator withdraw a 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 deposit by curators
+    // Minimum amount allowed to be deposited by curators to initialize a pool
     // This is the `startPoolBalance` for the bonding curve
     uint256 public minimumCurationDeposit;
 
+    // Total tokens in held as reserves received from curators deposits
+    uint256 public totalTokens;
+
     // Mapping of subgraphDeploymentID => CurationPool
     // There is only one CurationPool per SubgraphDeploymentID
-    mapping(bytes32 => CurationPool) public pools;
+    mapping(bytes32 => ICuration.CurationPool) public pools;
 
     // -- Related contracts --
 
-    // Address of the staking contract that will distribute fees to reserves
-    IStaking public staking;
-
-    // Token used for staking
     IGraphToken public token;
+    IStaking public staking;
+    IRewardsManager public rewardsManager;
 }

contracts/curation/ICuration.sol

@@ -1,12 +1,24 @@
 pragma solidity ^0.6.4;
 
+import "./GraphSignalToken.sol";
+
 interface ICuration {
-    // -- Configuration --
+    // -- Pool --
 
-    function setDefaultReserveRatio(uint32 _defaultReserveRatio) external;
+    struct CurationPool {
+        uint256 tokens; // GRT Tokens stored as reserves for the subgraph deployment
+        uint32 reserveRatio; // Ratio for the bonding curve
+        GraphSignalToken gst; // Signal token contract for this curation pool
+    }
+
+    // -- Configuration --
 
     function setStaking(address _staking) external;
 
+    function setRewardsManager(address _rewardsManager) external;
+
+    function setDefaultReserveRatio(uint32 _defaultReserveRatio) external;
+
     function setMinimumCurationDeposit(uint256 _minimumCurationDeposit) external;
 
     function setWithdrawalFeePercentage(uint32 _percentage) external;
@@ -32,6 +44,8 @@ interface ICuration {
 
     function getCurationPoolSignal(bytes32 _subgraphDeploymentID) external view returns (uint256);
 
+    function getCurationPoolTokens(bytes32 _subgraphDeploymentID) external view returns (uint256);
+
     function tokensToSignal(bytes32 _subgraphDeploymentID, uint256 _tokens)
         external
         view

contracts/discovery/ServiceRegistry.sol

@@ -1,7 +1,6 @@
 pragma solidity ^0.6.4;
 pragma experimental ABIEncoderV2;
 
-
 /**
  * @title ServiceRegistry contract
  * @dev This contract supports the service discovery process by allowing indexers to

contracts/epochs/EpochManager.sol

@@ -11,7 +11,7 @@ import "./IEpochManager.sol";
 
 /**
  * @title EpochManager contract
- * @dev Tracks epochs based on its block duration to sync contracts in the protocol.
+ * @dev Produce epochs based on a number of blocks to coordinate contracts in the protocol.
  */
 contract EpochManager is EpochManagerV1Storage, GraphUpgradeable, IEpochManager, Governed {
     using SafeMath for uint256;

contracts/rewards/IRewardsManager.sol

@@ -0,0 +1,45 @@
+pragma solidity ^0.6.4;
+
+interface IRewardsManager {
+    // -- Params --
+
+    function setIssuanceRate(uint256 _issuanceRate) external;
+
+    // -- Denylist --
+
+    function setDenied(bytes32 _subgraphDeploymentID, bool _deny) external;
+
+    function isDenied(bytes32 _subgraphDeploymentID) external returns (bool);
+
+    // -- Getters --
+
+    function getNewRewardsPerSignal() external view returns (uint256);
+
+    function getAccRewardsPerSignal() external view returns (uint256);
+
+    function getAccRewardsForSubgraph(bytes32 _subgraphDeploymentID)
+        external
+        view
+        returns (uint256);
+
+    function getAccRewardsPerAllocatedToken(bytes32 _subgraphDeploymentID)
+        external
+        view
+        returns (uint256, uint256);
+
+    function getRewards(address _allocationID) external view returns (uint256);
+
+    // -- Updates --
+
+    function updateAccRewardsPerSignal() external returns (uint256);
+
+    function assignRewards(address _allocationID) external returns (uint256);
+
+    function claim(bool _restake) external returns (uint256);
+
+    // -- Hooks --
+
+    function onSubgraphSignalUpdate(bytes32 _subgraphDeploymentID) external returns (uint256);
+
+    function onSubgraphAllocationUpdate(bytes32 _subgraphDeploymentID) external returns (uint256);
+}