staking: fix edge rebate when all allocations collected zero fees

Author: abarmat

contracts/staking/libs/Rebates.sol

@@ -81,22 +81,25 @@ library Rebates {
         uint256 _indexerFees,
         uint256 _indexerEffectiveAllocatedStake
     ) internal returns (uint256) {
+        uint256 rebateReward = 0;
+
         // Calculate the rebate rewards for the indexer
-        uint256 totalRewards = pool.fees;
-        uint256 rebateReward = LibCobbDouglas.cobbDouglas(
-            totalRewards,
-            _indexerFees,
-            pool.fees,
-            _indexerEffectiveAllocatedStake,
-            pool.effectiveAllocatedStake,
-            pool.alphaNumerator,
-            pool.alphaDenominator
-        );
+        if (pool.fees > 0) {
+            rebateReward = LibCobbDouglas.cobbDouglas(
+                pool.fees, // totalRewards
+                _indexerFees,
+                pool.fees,
+                _indexerEffectiveAllocatedStake,
+                pool.effectiveAllocatedStake,
+                pool.alphaNumerator,
+                pool.alphaDenominator
+            );
 
-        // Under NO circumstance we will reward more than total fees in the pool
-        uint256 _unclaimedFees = pool.fees.sub(pool.claimedRewards);
-        if (rebateReward > _unclaimedFees) {
-            rebateReward = _unclaimedFees;
+            // Under NO circumstance we will reward more than total fees in the pool
+            uint256 _unclaimedFees = pool.fees.sub(pool.claimedRewards);
+            if (rebateReward > _unclaimedFees) {
+                rebateReward = _unclaimedFees;
+            }
         }
 
         // Update pool state

contracts/tests/RebatePoolMock.sol

@@ -46,6 +46,10 @@ contract RebatePoolMock {
         uint32 _alphaNumerator,
         uint32 _alphaDenominator
     ) external pure returns (uint256) {
+        if (_totalFees == 0) {
+            return 0;
+        }
+
         return
             LibCobbDouglas.cobbDouglas(
                 _totalRewards,

test/staking/rebate.test.ts

@@ -37,6 +37,14 @@ describe('Staking:Rebate', () => {
     { totalRewards: 1400, fees: 0, totalFees: 1400, stake: 1200, totalStake: 7300 },
   ]
 
+  // Edge case #1 - No closed allocations any query fees
+  const edgeCases1: RebateTestCase[] = [
+    { totalRewards: 0, fees: 0, totalFees: 0, stake: 5000, totalStake: 7300 },
+    { totalRewards: 0, fees: 0, totalFees: 0, stake: 600, totalStake: 7300 },
+    { totalRewards: 0, fees: 0, totalFees: 0, stake: 500, totalStake: 7300 },
+    { totalRewards: 0, fees: 0, totalFees: 0, stake: 1200, totalStake: 7300 },
+  ]
+
   // This function calculates the Cobb-Douglas formula in Typescript so we can compare against
   // the Solidity implementation
   // TODO: consider using bignumber.js to get extra precision
@@ -49,6 +57,9 @@ describe('Staking:Rebate', () => {
     alphaNumerator: number,
     alphaDenominator: number,
   ) {
+    if (totalFees === 0) {
+      return 0
+    }
     const feeRatio = fees / totalFees
     const stakeRatio = stake / totalStake
     const alpha = alphaNumerator / alphaDenominator
@@ -143,107 +154,73 @@ describe('Staking:Rebate', () => {
     return rx.events[0].args[0]
   }
 
-  beforeEach(async function () {
-    ;[deployer, other] = await getAccounts()
-    rebatePoolMock = ((await deployContract(
-      'RebatePoolMock',
-      deployer.signer,
-    )) as unknown) as RebatePoolMock
-  })
-
-  describe('should match cobb-douglas Solidity implementation', function () {
+  async function testAlphas(fn, testCases) {
     // Typical alpha
     it('alpha 0.90', async function () {
       const alpha: RebateRatio = [90, 100]
-      await shouldMatchFormulas(testCases, alpha)
+      await fn(testCases, alpha)
     })
 
     // Typical alpha
     it('alpha 0.25', async function () {
       const alpha: RebateRatio = [1, 4]
-      await shouldMatchFormulas(testCases, alpha)
+      await fn(testCases, alpha)
     })
 
     // Periodic alpha
     it('alpha 0.33~', async function () {
       const alpha: RebateRatio = [1, 3]
-      await shouldMatchFormulas(testCases, alpha)
+      await fn(testCases, alpha)
     })
 
     // Small alpha
     it('alpha 0.005', async function () {
       const alpha: RebateRatio = [1, 200]
-      await shouldMatchFormulas(testCases, alpha)
+      await fn(testCases, alpha)
     })
 
     // Edge alpha
     it('alpha 1', async function () {
       const alpha: RebateRatio = [1, 1]
-      await shouldMatchFormulas(testCases, alpha)
+      await fn(testCases, alpha)
     })
-  })
+  }
 
-  describe('should match rewards out from rebates', function () {
-    // Typical alpha
-    it('alpha 0.90', async function () {
-      const alpha: RebateRatio = [90, 100]
-      await shouldMatchOut(testCases, alpha)
-    })
+  beforeEach(async function () {
+    ;[deployer, other] = await getAccounts()
+    rebatePoolMock = ((await deployContract(
+      'RebatePoolMock',
+      deployer.signer,
+    )) as unknown) as RebatePoolMock
+  })
 
-    // Typical alpha
-    it('alpha 0.25', async function () {
-      const alpha: RebateRatio = [1, 4]
-      await shouldMatchOut(testCases, alpha)
+  describe('should match cobb-douglas Solidity implementation', function () {
+    describe('normal test case', function () {
+      testAlphas(shouldMatchFormulas, testCases)
     })
 
-    // Periodic alpha
-    it('alpha 0.33~', async function () {
-      const alpha: RebateRatio = [1, 3]
-      await shouldMatchOut(testCases, alpha)
+    describe('edge #1 test case', function () {
+      testAlphas(shouldMatchFormulas, edgeCases1)
     })
+  })
 
-    // Small alpha
-    it('alpha 0.005', async function () {
-      const alpha: RebateRatio = [1, 200]
-      await shouldMatchOut(testCases, alpha)
+  describe('should match rewards out from rebates', function () {
+    describe('normal test case', function () {
+      testAlphas(shouldMatchOut, testCases)
     })
 
-    // Edge alpha
-    it('alpha 1', async function () {
-      const alpha: RebateRatio = [1, 1]
-      await shouldMatchOut(testCases, alpha)
+    describe('edge #1 test case', function () {
+      testAlphas(shouldMatchOut, edgeCases1)
     })
   })
 
   describe('should always be that sum of rebate rewards obtained <= to total rewards', function () {
-    // Typical alpha
-    it('alpha 0.90', async function () {
-      const alpha: RebateRatio = [90, 100]
-      await shouldConserveBalances(testCases, alpha)
+    describe('normal test case', function () {
+      testAlphas(shouldConserveBalances, testCases)
     })
 
-    // Typical alpha
-    it('alpha 0.25', async function () {
-      const alpha: RebateRatio = [1, 4]
-      await shouldConserveBalances(testCases, alpha)
-    })
-
-    // Periodic alpha
-    it('alpha 0.33~', async function () {
-      const alpha: RebateRatio = [1, 3]
-      await shouldConserveBalances(testCases, alpha)
-    })
-
-    // Small alpha
-    it('alpha 0.005', async function () {
-      const alpha: RebateRatio = [1, 200]
-      await shouldConserveBalances(testCases, alpha)
-    })
-
-    // Edge alpha
-    it('alpha 1', async function () {
-      const alpha: RebateRatio = [1, 1]
-      await shouldConserveBalances(testCases, alpha)
+    describe('edge #1 test case', function () {
+      testAlphas(shouldConserveBalances, edgeCases1)
     })
   })
 })