fix: consider delegation when deciding if an indexer is disputable

Signed-off-by: Tomás Migone <tomas@edgeandnode.com>

Author: tmigone

packages/subgraph-service/contracts/DisputeManager.sol

@@ -344,11 +344,7 @@ contract DisputeManager is
 
     /// @inheritdoc IDisputeManager
     function getStakeSnapshot(address indexer) external view override returns (uint256) {
-        IHorizonStaking.Provision memory provision = _graphStaking().getProvision(
-            indexer,
-            address(_getSubgraphService())
-        );
-        return _getStakeSnapshot(indexer, provision.tokens);
+        return _getStakeSnapshot(indexer);
     }
 
     /// @inheritdoc IDisputeManager
@@ -398,13 +394,6 @@ contract DisputeManager is
         // Get the indexer that signed the attestation
         address indexer = getAttestationIndexer(_attestation);
 
-        // The indexer is disputable
-        IHorizonStaking.Provision memory provision = _graphStaking().getProvision(
-            indexer,
-            address(_getSubgraphService())
-        );
-        require(provision.tokens != 0, DisputeManagerZeroTokens());
-
         // Create a disputeId
         bytes32 disputeId = keccak256(
             abi.encodePacked(
@@ -419,8 +408,11 @@ contract DisputeManager is
         // Only one dispute at a time
         require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
 
+        // The indexer is disputable
+        uint256 stakeSnapshot = _getStakeSnapshot(indexer);
+        require(stakeSnapshot != 0, DisputeManagerZeroTokens());
+
         // Store dispute
-        uint256 stakeSnapshot = _getStakeSnapshot(indexer, provision.tokens);
         uint256 cancellableAt = block.timestamp + disputePeriod;
         disputes[disputeId] = Dispute(
             indexer,
@@ -477,11 +469,10 @@ contract DisputeManager is
         require(indexer != address(0), DisputeManagerIndexerNotFound(_allocationId));
 
         // The indexer must be disputable
-        IHorizonStaking.Provision memory provision = _graphStaking().getProvision(indexer, address(subgraphService_));
-        require(provision.tokens != 0, DisputeManagerZeroTokens());
+        uint256 stakeSnapshot = _getStakeSnapshot(indexer);
+        require(stakeSnapshot != 0, DisputeManagerZeroTokens());
 
         // Store dispute
-        uint256 stakeSnapshot = _getStakeSnapshot(indexer, provision.tokens);
         uint256 cancellableAt = block.timestamp + disputePeriod;
         disputes[disputeId] = Dispute(
             alloc.indexer,
@@ -691,18 +682,19 @@ contract DisputeManager is
      * @dev A few considerations:
      * - We include both indexer and delegators stake.
      * - Thawing stake is not excluded from the snapshot.
-     * - Delegators stake is capped at the delegation ratio to prevent delegators from inflating the snapshot
-     *   to increase the indexer slash amount.
      *
      * Note that the snapshot can be inflated by delegators front-running the dispute creation with a delegation
      * to the indexer. Given the snapshot is a cap, the dispute outcome is uncertain and considering the cost of capital
      * and slashing risk, this is not a concern.
      * @param _indexer Indexer address
-     * @param _indexerStake Indexer's stake
      * @return Total stake snapshot
      */
-    function _getStakeSnapshot(address _indexer, uint256 _indexerStake) private view returns (uint256) {
-        uint256 delegatorsStake = _graphStaking().getDelegationPool(_indexer, address(_getSubgraphService())).tokens;
-        return _indexerStake + delegatorsStake;
+    function _getStakeSnapshot(address _indexer) private view returns (uint256) {
+        address subgraphService = address(_getSubgraphService());
+
+        IHorizonStaking.Provision memory provision = _graphStaking().getProvision(_indexer, subgraphService);
+        uint256 delegatorsStake = _graphStaking().getDelegationPool(_indexer, subgraphService).tokens;
+
+        return provision.tokens + delegatorsStake;
     }
 }

packages/subgraph-service/test/unit/disputeManager/disputes/indexing/create.t.sol

@@ -157,4 +157,24 @@ contract DisputeManagerIndexingCreateDisputeTest is DisputeManagerTest {
         vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerZeroTokens.selector));
         disputeManager.createIndexingDispute(allocationID, bytes32("POI1"), block.number);
     }
+
+    function test_Indexing_Create_DontRevertIf_IndexerIsBelowStake_WithDelegation(uint256 tokens, uint256 delegationTokens) public useIndexer useAllocation(tokens) {
+        // Close allocation
+        bytes memory data = abi.encode(allocationID);
+        _stopService(users.indexer, data);
+        // Thaw, deprovision and unstake
+        address subgraphDataServiceAddress = address(subgraphService);
+        _thawDeprovisionAndUnstake(users.indexer, subgraphDataServiceAddress, tokens);
+
+        delegationTokens = bound(delegationTokens, 1 ether, 100_000_000 ether);
+
+        resetPrank(users.delegator);
+        token.approve(address(staking), delegationTokens);
+        staking.delegate(users.indexer, address(subgraphService), delegationTokens, 0);
+
+        // create dispute
+        resetPrank(users.fisherman);
+        token.approve(address(disputeManager), tokens);
+        _createIndexingDispute(allocationID, bytes32("POI1"), block.number);
+    }
 }

packages/subgraph-service/test/unit/disputeManager/disputes/query/create.t.sol

@@ -155,4 +155,27 @@ contract DisputeManagerQueryCreateDisputeTest is DisputeManagerTest {
         vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerZeroTokens.selector));
         disputeManager.createQueryDispute(attestationData);
     }
+
+    function test_Query_Create_DontRevertIf_IndexerIsBelowStake_WithDelegation(uint256 tokens, uint256 delegationTokens) public useIndexer useAllocation(tokens) {
+        // Close allocation
+        bytes memory data = abi.encode(allocationID);
+        _stopService(users.indexer, data);
+        // Thaw, deprovision and unstake
+        address subgraphDataServiceAddress = address(subgraphService);
+        _thawDeprovisionAndUnstake(users.indexer, subgraphDataServiceAddress, tokens);
+
+        delegationTokens = bound(delegationTokens, 1 ether, 100_000_000 ether);
+
+        resetPrank(users.delegator);
+        token.approve(address(staking), delegationTokens);
+        staking.delegate(users.indexer, address(subgraphService), delegationTokens, 0);
+
+        // create dispute
+        resetPrank(users.fisherman);
+        token.approve(address(disputeManager), tokens);
+
+        Attestation.Receipt memory receipt = _createAttestationReceipt(requestCID, responseCID, subgraphDeploymentId);
+        bytes memory attestationData = _createAtestationData(receipt, allocationIDPrivateKey);
+        _createQueryDispute(attestationData);
+    }
 }