Revert when not enough precision to assign a delegation share

Author: abarmat

contracts/staking/Staking.sol

@@ -186,7 +186,7 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
     /**
      * @dev Check if the caller is the slasher.
      */
-    modifier onlySlasher {
+    modifier onlySlasher() {
         require(slashers[msg.sender] == true, "!slasher");
         _;
     }
@@ -976,10 +976,10 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
 
             // -- Collect protocol tax --
             // If the Allocation is not active or closed we are going to charge a 100% protocol tax
-            uint256 usedProtocolPercentage =
-                (allocState == AllocationState.Active || allocState == AllocationState.Closed)
-                    ? protocolPercentage
-                    : MAX_PPM;
+            uint256 usedProtocolPercentage = (allocState == AllocationState.Active ||
+                allocState == AllocationState.Closed)
+                ? protocolPercentage
+                : MAX_PPM;
             uint256 protocolTax = _collectTax(graphToken, queryFees, usedProtocolPercentage);
             queryFees = queryFees.sub(protocolTax);
 
@@ -1114,17 +1114,16 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
         // Creates an allocation
         // Allocation identifiers are not reused
         // The assetHolder address can send collected funds to the allocation
-        Allocation memory alloc =
-            Allocation(
-                _indexer,
-                _subgraphDeploymentID,
-                _tokens, // Tokens allocated
-                epochManager().currentEpoch(), // createdAtEpoch
-                0, // closedAtEpoch
-                0, // Initialize collected fees
-                0, // Initialize effective allocation
-                _updateRewards(_subgraphDeploymentID) // Initialize accumulated rewards per stake allocated
-            );
+        Allocation memory alloc = Allocation(
+            _indexer,
+            _subgraphDeploymentID,
+            _tokens, // Tokens allocated
+            epochManager().currentEpoch(), // createdAtEpoch
+            0, // closedAtEpoch
+            0, // Initialize collected fees
+            0, // Initialize effective allocation
+            _updateRewards(_subgraphDeploymentID) // Initialize accumulated rewards per stake allocated
+        );
         allocations[_allocationID] = alloc;
 
         // Mark allocated tokens as used
@@ -1134,8 +1133,7 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
         // Used for rewards calculations
         subgraphAllocations[alloc.subgraphDeploymentID] = subgraphAllocations[
             alloc.subgraphDeploymentID
-        ]
-            .add(alloc.tokens);
+        ].add(alloc.tokens);
 
         emit AllocationCreated(
             _indexer,
@@ -1207,8 +1205,7 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
         // Used for rewards calculations
         subgraphAllocations[alloc.subgraphDeploymentID] = subgraphAllocations[
             alloc.subgraphDeploymentID
-        ]
-            .sub(alloc.tokens);
+        ].sub(alloc.tokens);
 
         emit AllocationClosed(
             alloc.indexer,
@@ -1310,16 +1307,16 @@ contract Staking is StakingV2Storage, GraphUpgradeable, IStaking {
         uint256 delegatedTokens = _tokens.sub(delegationTax);
 
         // Calculate shares to issue
-        uint256 shares =
-            (pool.tokens == 0)
-                ? delegatedTokens
-                : delegatedTokens.mul(pool.shares).div(pool.tokens);
+        uint256 shares = (pool.tokens == 0)
+            ? delegatedTokens
+            : delegatedTokens.mul(pool.shares).div(pool.tokens);
+        require(shares > 0, "!shares");
 
         // Update the delegation pool
         pool.tokens = pool.tokens.add(delegatedTokens);
         pool.shares = pool.shares.add(shares);
 
-        // Update the delegation
+        // Update the individual delegation
         delegation.shares = delegation.shares.add(shares);
 
         emit StakeDelegated(_indexer, _delegator, delegatedTokens, shares);

test/staking/delegation.test.ts

@@ -400,7 +400,7 @@ describe('Staking::Delegation', () => {
         await shouldDelegate(delegator2, toGRT('5000'))
       })
 
-      it('should delegate a high number of tokens', async function () {
+      it('should delegate a high amount of tokens', async function () {
         await shouldDelegate(delegator, toGRT('100'))
         await shouldDelegate(delegator, toGRT('1000000000000000000'))
       })
@@ -416,9 +416,10 @@ describe('Staking::Delegation', () => {
           await shouldDelegate(delegator, toGRT('10000000'))
         })
 
-        it('should delegate and burn delegation deposit tax (100%)', async function () {
+        it('reject delegate with delegation deposit tax (100%)', async function () {
           await staking.setDelegationTaxPercentage(1000000)
-          await shouldDelegate(delegator, toGRT('10000000'))
+          const tx = staking.connect(delegator.signer).delegate(indexer.address, toGRT('10000000'))
+          await expect(tx).revertedWith('!shares')
         })
       })
     })
@@ -649,5 +650,25 @@ describe('Staking::Delegation', () => {
       const afterDelegationPool = await staking.delegationPools(indexer.address)
       expect(afterDelegationPool.tokens).eq(beforeDelegationPool.tokens.add(delegationFees))
     })
+
+    it('revert if it cannot assign the smallest amount of shares', async function () {
+      // Init the delegation pool
+      await shouldDelegate(delegator, tokensToDelegate)
+
+      // Collect funds thru full allocation cycle
+      await staking.connect(governor.signer).setDelegationRatio(10)
+      await staking.connect(indexer.signer).setDelegationParameters(0, 0, 0)
+      await setupAllocation(tokensToAllocate)
+      await staking.connect(assetHolder.signer).collect(tokensToCollect, allocationID)
+      await advanceToNextEpoch(epochManager)
+      await staking.connect(indexer.signer).closeAllocation(allocationID, poi)
+      await advanceToNextEpoch(epochManager)
+      await staking.connect(indexer.signer).claim(allocationID, true)
+
+      // Delegate with such small amount of tokens (1 wei) that we do not have enough precision
+      // to even assign 1 wei of shares
+      const tx = staking.connect(delegator.signer).delegate(indexer.address, toBN(1))
+      await expect(tx).revertedWith('!shares')
+    })
   })
 })