fix: enforce minimum delegation when receiving from L1

Author: pcarranzav

contracts/l2/staking/L2Staking.sol

@@ -19,6 +19,9 @@ contract L2Staking is Staking, IL2StakingBase {
     using SafeMath for uint256;
     using Stakes for Stakes.Indexer;
 
+    /// @dev Minimum delegation for the first delegator of an indexer
+    uint256 private constant MINIMUM_DELEGATION = 1e18;
+
     /**
      * @dev Emitted when `delegator` delegated `tokens` to the `indexer`, the delegator
      * gets `shares` for the delegation pool proportionally to the tokens staked.
@@ -122,7 +125,14 @@ contract L2Staking is Staking, IL2StakingBase {
         Delegation storage delegation = pool.delegators[_delegationData.delegator];
 
         // Calculate shares to issue (without applying any delegation tax)
-        uint256 shares = (pool.tokens == 0) ? _amount : _amount.mul(pool.shares).div(pool.tokens);
+        uint256 shares;
+        if (pool.tokens == 0) {
+            if (_amount >= MINIMUM_DELEGATION) {
+                shares = _amount;
+            }
+        } else {
+            shares = _amount.mul(pool.shares).div(pool.tokens);
+        }
 
         if (shares == 0) {
             // If no shares would be issued (probably a rounding issue or attack), return the tokens to the delegator

test/l2/l2Staking.test.ts

@@ -295,7 +295,8 @@ describe('L2Staking', () => {
         .setIssuancePerBlock(toGRT('114'))
 
       await staking.connect(me.signer).stake(tokens100k)
-      await staking.connect(me.signer).delegate(me.address, toBN(1)) // 1 weiGRT == 1 share
+      // Initialize the delegation pool to allow delegating less than 1 GRT
+      await staking.connect(me.signer).delegate(me.address, tokens10k)
 
       await staking.connect(me.signer).setDelegationParameters(1000, 1000, 1000)
       await grt.connect(me.signer).approve(fixtureContracts.curation.address, tokens10k)
@@ -336,6 +337,84 @@ describe('L2Staking', () => {
       const delegatorGRTBalanceAfter = await grt.balanceOf(other.address)
       expect(delegatorGRTBalanceAfter.sub(delegatorGRTBalanceBefore)).to.equal(toBN(1))
     })
+    it('returns delegation to the delegator if it initialize the pool with less than the minimum delegation', async function () {
+      await fixtureContracts.rewardsManager
+        .connect(governor.signer)
+        .setIssuancePerBlock(toGRT('114'))
+
+      await staking.connect(me.signer).stake(tokens100k)
+
+      await staking.connect(me.signer).setDelegationParameters(1000, 1000, 1000)
+      await grt.connect(me.signer).approve(fixtureContracts.curation.address, tokens10k)
+      await fixtureContracts.curation.connect(me.signer).mint(subgraphDeploymentID, tokens10k, 0)
+
+      await allocate(tokens100k)
+      await advanceToNextEpoch(fixtureContracts.epochManager)
+      await advanceToNextEpoch(fixtureContracts.epochManager)
+      await staking.connect(me.signer).closeAllocation(allocationID, randomHexBytes(32))
+      // Now there are some rewards sent to delegation pool, so 1 weiGRT is less than 1 share
+
+      const functionData = defaultAbiCoder.encode(
+        ['tuple(address,address)'],
+        [[me.address, other.address]],
+      )
+
+      const callhookData = defaultAbiCoder.encode(
+        ['uint8', 'bytes'],
+        [toBN(1), functionData], // code = 1 means RECEIVE_DELEGATION_CODE
+      )
+      const delegatorGRTBalanceBefore = await grt.balanceOf(other.address)
+      const tx = gatewayFinalizeTransfer(
+        mockL1Staking.address,
+        staking.address,
+        toGRT('0.1'), // Less than 1 GRT!
+        callhookData,
+      )
+
+      await expect(tx)
+        .emit(l2GraphTokenGateway, 'DepositFinalized')
+        .withArgs(mockL1GRT.address, mockL1Staking.address, staking.address, toGRT('0.1'))
+      const delegation = await staking.getDelegation(me.address, other.address)
+      await expect(tx)
+        .emit(staking, 'TransferredDelegationReturnedToDelegator')
+        .withArgs(me.address, other.address, toGRT('0.1'))
+
+      expect(delegation.shares).to.equal(0)
+      const delegatorGRTBalanceAfter = await grt.balanceOf(other.address)
+      expect(delegatorGRTBalanceAfter.sub(delegatorGRTBalanceBefore)).to.equal(toGRT('0.1'))
+    })
+    it('adds delegation under the minimum if the pool is initialized', async function () {
+      await staking.connect(me.signer).stake(tokens100k)
+
+      // Initialize the delegation pool to allow delegating less than 1 GRT
+      await staking.connect(me.signer).delegate(me.address, tokens10k)
+
+      const functionData = defaultAbiCoder.encode(
+        ['tuple(address,address)'],
+        [[me.address, other.address]],
+      )
+
+      const callhookData = defaultAbiCoder.encode(
+        ['uint8', 'bytes'],
+        [toBN(1), functionData], // code = 1 means RECEIVE_DELEGATION_CODE
+      )
+      const tx = gatewayFinalizeTransfer(
+        mockL1Staking.address,
+        staking.address,
+        toGRT('0.1'),
+        callhookData,
+      )
+
+      await expect(tx)
+        .emit(l2GraphTokenGateway, 'DepositFinalized')
+        .withArgs(mockL1GRT.address, mockL1Staking.address, staking.address, toGRT('0.1'))
+      const expectedShares = toGRT('0.1')
+      await expect(tx)
+        .emit(staking, 'StakeDelegated')
+        .withArgs(me.address, other.address, toGRT('0.1'), expectedShares)
+      const delegation = await staking.getDelegation(me.address, other.address)
+      expect(delegation.shares).to.equal(expectedShares)
+    })
   })
   describe('onTokenTransfer with invalid messages', function () {
     it('reverts if the code is invalid', async function () {