staking: burn protocol fee when collecting query fees (#241)

Author: abarmat

contracts/IStaking.sol

@@ -46,7 +46,9 @@ interface IStaking {
 
     function setCuration(address _curation) external;
 
-    function setCurationPercentage(uint256 _percentage) external;
+    function setCurationPercentage(uint32 _percentage) external;
+
+    function setProtocolPercentage(uint32 _percentage) external;
 
     function setChannelDisputeEpochs(uint256 _channelDisputeEpochs) external;
 

contracts/Staking.sol

@@ -30,7 +30,11 @@ contract Staking is IStaking, Governed {
 
     // Percentage of fees going to curators
     // Parts per million. (Allows for 4 decimal points, 999,999 = 99.9999%)
-    uint256 public curationPercentage;
+    uint32 public curationPercentage;
+
+    // Percentage of fees burned as protocol fee
+    // Parts per million. (Allows for 4 decimal points, 999,999 = 99.9999%)
+    uint32 public protocolPercentage;
 
     // Need to pass this period for channel to be finalized
     uint256 public channelDisputeEpochs;
@@ -223,16 +227,27 @@ contract Staking is IStaking, Governed {
     }
 
     /**
-     * @dev Set the curation percentage of indexer fees sent to curators.
-     * @param _percentage Percentage of indexer fees sent to curators
+     * @dev Set the curation percentage of query fees sent to curators.
+     * @param _percentage Percentage of query fees sent to curators
      */
-    function setCurationPercentage(uint256 _percentage) external override onlyGovernor {
+    function setCurationPercentage(uint32 _percentage) external override onlyGovernor {
         // Must be within 0% to 100% (inclusive)
         require(_percentage <= MAX_PPM, "Curation percentage must be below or equal to MAX_PPM");
         curationPercentage = _percentage;
         emit ParameterUpdated("curationPercentage");
     }
 
+    /**
+     * @dev Set a protocol percentage to burn when collecting query fees.
+     * @param _percentage Percentage of query fees to burn as protocol fee
+     */
+    function setProtocolPercentage(uint32 _percentage) external override onlyGovernor {
+        // Must be within 0% to 100% (inclusive)
+        require(_percentage <= MAX_PPM, "Protocol percentage must be below or equal to MAX_PPM");
+        protocolPercentage = _percentage;
+        emit ParameterUpdated("protocolPercentage");
+    }
+
     /**
      * @dev Set the period in epochs that need to pass before fees in rebate pool can be claimed.
      * @param _channelDisputeEpochs Period in epochs
@@ -867,6 +882,8 @@ contract Staking is IStaking, Governed {
         address _from,
         uint256 _tokens
     ) private {
+        uint256 rebateFees = _tokens;
+
         // Get allocation related to the channel identifier
         Allocation storage alloc = allocations[_channelID];
         AllocationState allocState = _getAllocationState(_channelID);
@@ -877,11 +894,13 @@ contract Staking is IStaking, Governed {
             "Collect: channel must be active or settled"
         );
 
-        // Calculate curation fees only if the subgraph deployment is curated
-        uint256 curationFees = _collectCurationFees(alloc.subgraphDeploymentID, _tokens);
+        // Collect protocol fees to be burned
+        uint256 protocolFees = _collectProtocolFees(rebateFees);
+        rebateFees = rebateFees.sub(protocolFees);
 
-        // Calculate rebate fees
-        uint256 rebateFees = _tokens.sub(curationFees);
+        // Calculate curation fees only if the subgraph deployment is curated
+        uint256 curationFees = _collectCurationFees(alloc.subgraphDeploymentID, rebateFees);
+        rebateFees = rebateFees.sub(curationFees);
 
         // Collect funds in the allocated channel
         alloc.collectedFees = alloc.collectedFees.add(rebateFees);
@@ -1013,11 +1032,27 @@ contract Staking is IStaking, Governed {
     {
         bool isCurationEnabled = curationPercentage > 0 && address(curation) != address(0);
         if (isCurationEnabled && curation.isCurated(_subgraphDeploymentID)) {
-            return curationPercentage.mul(_tokens).div(MAX_PPM);
+            return uint256(curationPercentage).mul(_tokens).div(MAX_PPM);
         }
         return 0;
     }
 
+    /**
+     * @dev Collect and burn the protocol fees for an amount of tokens.
+     * @param _tokens Total tokens received used to calculate the amount of fees to collect
+     * @return Amount of protocol fees
+     */
+    function _collectProtocolFees(uint256 _tokens) private returns (uint256) {
+        if (protocolPercentage == 0) {
+            return 0;
+        }
+        uint256 protocolFees = uint256(protocolPercentage).mul(_tokens).div(MAX_PPM);
+        if (protocolFees > 0) {
+            token.burn(protocolFees);
+        }
+        return protocolFees;
+    }
+
     /**
      * @dev Return the current state of an allocation
      * @param _channelID Address used as the allocation channel identifier

test/staking/allocation.test.ts

@@ -165,16 +165,22 @@ describe('Staking:Allocation', () => {
     // This function tests collect with state updates
     const shouldCollect = async (tokensToCollect: BigNumber) => {
       // Before state
+      const beforeTokenSupply = await grt.totalSupply()
       const beforePool = await curation.pools(subgraphDeploymentID)
       const beforeAlloc = await staking.getAllocation(channelID)
 
       // Advance blocks to get the channel in epoch where it can be settled
       await advanceToNextEpoch(epochManager)
 
-      // Calculate expected results
+      // Collect fees and calculate expected results
+      let rebateFees = tokensToCollect
+      const protocolPercentage = await staking.protocolPercentage()
+      const protocolFees = rebateFees.mul(protocolPercentage).div(MAX_PPM)
+      rebateFees = rebateFees.sub(protocolFees)
+
       const curationPercentage = await staking.curationPercentage()
-      const curationFees = tokensToCollect.mul(curationPercentage).div(MAX_PPM)
-      const rebateFees = tokensToCollect.sub(curationFees) // calculate expected fees
+      const curationFees = rebateFees.mul(curationPercentage).div(MAX_PPM)
+      rebateFees = rebateFees.sub(curationFees)
 
       // Collect tokens from channel
       const tx = staking.connect(channelProxy).collect(tokensToCollect, channelID)
@@ -192,9 +198,12 @@ describe('Staking:Allocation', () => {
         )
 
       // After state
+      const afterTokenSupply = await grt.totalSupply()
       const afterPool = await curation.pools(subgraphDeploymentID)
       const afterAlloc = await staking.getAllocation(channelID)
 
+      // Check that protocol fees are burnt
+      expect(afterTokenSupply).eq(beforeTokenSupply.sub(protocolFees))
       // Check that curation reserves increased for the SubgraphDeployment
       expect(afterPool.tokens).eq(beforePool.tokens.add(curationFees))
       // Verify allocation is updated and channel closed
@@ -253,6 +262,25 @@ describe('Staking:Allocation', () => {
       await shouldCollect(tokensToCollect)
     })
 
+    it('should collect funds from channel + protocol fee + curation fees', async function () {
+      // Curate the subgraph from where we collect fees to get curation fees distributed
+      const tokensToSignal = toGRT('100')
+      await grt.connect(governor).mint(me.address, tokensToSignal)
+      await grt.connect(me).approve(curation.address, tokensToSignal)
+      await curation.connect(me).stake(subgraphDeploymentID, tokensToSignal)
+
+      // Set a protocol fee percentage
+      const protocolPercentage = toBN('100000') // 10%
+      await staking.connect(governor).setProtocolPercentage(protocolPercentage)
+
+      // Set a curation fee percentage
+      const curationPercentage = toBN('200000') // 20%
+      await staking.connect(governor).setCurationPercentage(curationPercentage)
+
+      // Collect
+      await shouldCollect(tokensToCollect)
+    })
+
     it('should collect zero tokens', async function () {
       await shouldCollect(toGRT('0'))
     })

test/staking/configuration.test.ts

@@ -97,6 +97,26 @@ describe('Staking:Config', () => {
     })
   })
 
+  describe('protocolPercentage', function () {
+    it('should set `protocolPercentage`', async function () {
+      for (const newValue of [toBN('0'), toBN('5'), MAX_PPM]) {
+        await staking.connect(governor).setProtocolPercentage(newValue)
+        expect(await staking.protocolPercentage()).eq(newValue)
+      }
+    })
+
+    it('reject set `protocolPercentage` if out of bounds', async function () {
+      const newValue = MAX_PPM.add(toBN('1'))
+      const tx = staking.connect(governor).setProtocolPercentage(newValue)
+      await expect(tx).revertedWith('Protocol percentage must be below or equal to MAX_PPM')
+    })
+
+    it('reject set `protocolPercentage` if not allowed', async function () {
+      const tx = staking.connect(other).setProtocolPercentage(50)
+      await expect(tx).revertedWith('Only Governor can call')
+    })
+  })
+
   describe('maxAllocationEpochs', function () {
     it('should set `maxAllocationEpochs`', async function () {
       const newValue = toBN('5')