f: add createIndexingFeeDispute to DisputeManager

Author: matiasedgeandnode

IndexingPaymentsTodo.md

@@ -1,6 +1,7 @@
 ### Still pending
 
 * Make `agreementId` unique globally so that we don't need the full tuple (`payer`+`indexer`+`agreementId`) as key?
+* Reverse name of `SubgraphServiceIndexingAgreementAlreadyAllocated`?
 * Update `DisputeManager` and Arbitration Charter to support disputing Indexing Fees.
 * Support indexing agreement upgadeability, so that there is a mechanism to adjust the rates without having to cancel and start over.
 * Built-in upgrade path to indexing agreements v2. So that indexers can be paid per byte instead of per entity.

packages/subgraph-service/contracts/DisputeManager.sol

@@ -129,6 +129,19 @@ contract DisputeManager is
         return _createIndexingDisputeWithAllocation(msg.sender, disputeDeposit, allocationId, poi);
     }
 
+    /// @inheritdoc IDisputeManager
+    function createIndexingFeeDispute(
+        ISubgraphService.IndexingAgreementKey calldata agreementKey,
+        bytes32 poi,
+        uint256 entities
+    ) external override returns (bytes32) {
+        // Get funds from fisherman
+        _graphToken().pullTokens(msg.sender, disputeDeposit);
+
+        // Create a dispute
+        return _createIndexingFeeDisputeWithAgreement(msg.sender, disputeDeposit, agreementKey, poi, entities);
+    }
+
     /// @inheritdoc IDisputeManager
     function createQueryDispute(bytes calldata attestationData) external override returns (bytes32) {
         // Get funds from fisherman
@@ -450,6 +463,75 @@ contract DisputeManager is
         return disputeId;
     }
 
+    /**
+     * @notice Create indexing fee dispute internal function.
+     * @param _fisherman The fisherman creating the dispute
+     * @param _deposit Amount of tokens staked as deposit
+     * @param _key The indexing agreement key
+     * @param _poi The POI being disputed
+     * @param _entities The number of entities disputed
+     * @return The dispute id
+     */
+    function _createIndexingFeeDisputeWithAgreement(
+        address _fisherman,
+        uint256 _deposit,
+        ISubgraphService.IndexingAgreementKey calldata _key,
+        bytes32 _poi,
+        uint256 _entities
+    ) private returns (bytes32) {
+        // Create a disputeId
+        bytes32 disputeId = keccak256(
+            abi.encodePacked(
+                "IndexingFeeDisputeWithAgreement",
+                _key.agreementId,
+                _key.indexer,
+                _key.payer,
+                _poi,
+                _entities
+            )
+        );
+
+        // Only one dispute at a time
+        require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
+
+        // Agreement must have been collected on
+        ISubgraphService.IndexingAgreementData memory agreement = _getSubgraphService().getIndexingAgreement(_key);
+        require(agreement.lastCollectionAt > 0, DisputeManagerIndexingAgreementNotDisputable(_key));
+
+        // The indexer must be disputable
+        IHorizonStaking.Provision memory provision = _graphStaking().getProvision(
+            _key.indexer,
+            address(_getSubgraphService())
+        );
+        require(provision.tokens != 0, DisputeManagerZeroTokens());
+
+        uint256 stakeSnapshot = _getStakeSnapshot(_key.indexer, provision.tokens);
+        disputes[disputeId] = Dispute(
+            _key.indexer,
+            _fisherman,
+            _deposit,
+            0, // no related dispute,
+            DisputeType.IndexingFeeDispute,
+            IDisputeManager.DisputeStatus.Pending,
+            block.timestamp,
+            stakeSnapshot
+        );
+
+        emit IndexingFeeDisputeCreated(
+            disputeId,
+            _key.indexer,
+            _fisherman,
+            _deposit,
+            _key.payer,
+            _key.agreementId,
+            _poi,
+            _entities,
+            stakeSnapshot
+        );
+
+        return disputeId;
+    }
+
     /**
      * @notice Accept a dispute
      * @param _disputeId The id of the dispute

packages/subgraph-service/contracts/SubgraphService.sol

@@ -675,6 +675,12 @@ contract SubgraphService is
         emit IndexingAgreementCanceled(indexer, payer, agreementId, payer);
     }
 
+    function getIndexingAgreement(
+        IndexingAgreementKey memory key
+    ) external view returns (IndexingAgreementData memory) {
+        return indexingAgreements[key.indexer][key.payer][key.agreementId];
+    }
+
     /**
      * @notice Decodes the indexing agreement metadata.
      *

packages/subgraph-service/contracts/interfaces/IDisputeManager.sol

@@ -3,6 +3,7 @@
 pragma solidity 0.8.27;
 
 import { Attestation } from "../libraries/Attestation.sol";
+import { ISubgraphService } from "./ISubgraphService.sol";
 
 /**
  * @title IDisputeManager
@@ -15,7 +16,8 @@ interface IDisputeManager {
     enum DisputeType {
         Null,
         IndexingDispute,
-        QueryDispute
+        QueryDispute,
+        IndexingFeeDispute
     }
 
     /// @notice Status of a dispute
@@ -108,6 +110,31 @@ interface IDisputeManager {
         uint256 stakeSnapshot
     );
 
+    /**
+     * @dev Emitted when an indexing fee dispute is created for `agreementId` and `indexer`
+     * by `fisherman`.
+     * The event emits the amount of `tokens` deposited by the fisherman.
+     * @param disputeId The dispute id
+     * @param indexer The indexer address
+     * @param fisherman The fisherman address
+     * @param tokens The amount of tokens deposited by the fisherman
+     * @param agreementId The agreement id
+     * @param poi The POI disputed
+     * @param entities The entities disputed
+     * @param stakeSnapshot The stake snapshot of the indexer at the time of the dispute
+     */
+    event IndexingFeeDisputeCreated(
+        bytes32 indexed disputeId,
+        address indexed indexer,
+        address indexed fisherman,
+        uint256 tokens,
+        address payer,
+        bytes16 agreementId,
+        bytes32 poi,
+        uint256 entities,
+        uint256 stakeSnapshot
+    );
+
     /**
      * @dev Emitted when an indexing dispute is created for `allocationId` and `indexer`
      * by `fisherman`.
@@ -324,6 +351,11 @@ interface IDisputeManager {
      */
     error DisputeManagerSubgraphServiceNotSet();
 
+    /**
+     * @notice Thrown when the Indexing Agreement is not disputable
+     */
+    error DisputeManagerIndexingAgreementNotDisputable(ISubgraphService.IndexingAgreementKey agreementKey);
+
     /**
      * @notice Initialize this contract.
      * @param owner The owner of the contract
@@ -436,6 +468,27 @@ interface IDisputeManager {
      */
     function createIndexingDispute(address allocationId, bytes32 poi) external returns (bytes32);
 
+    /**
+     * @notice Create an indexing fee dispute for the arbitrator to resolve.
+     * The disputes are created in reference to an indexing agreement and specifically
+     * a POI and entities provided when collecting that agreement.
+     * This function is called by a fisherman and it will pull `disputeDeposit` GRT tokens.
+     *
+     * Requirements:
+     * - fisherman must have previously approved this contract to pull `disputeDeposit` amount
+     *   of tokens from their balance.
+     *
+     * @param agreementKey The indexing agreement key to dispute
+     * @param poi The Proof of Indexing (POI) being disputed
+     * @param entities The number of entities disputed
+     * @return The dispute id
+     */
+    function createIndexingFeeDispute(
+        ISubgraphService.IndexingAgreementKey calldata agreementKey,
+        bytes32 poi,
+        uint256 entities
+    ) external returns (bytes32);
+
     // -- Arbitrator --
 
     /**

packages/subgraph-service/contracts/interfaces/ISubgraphService.sol

@@ -455,4 +455,6 @@ interface ISubgraphService is IDataServiceFees {
      * @notice Cancel an indexing agreement by payer / signer.
      */
     function cancelIndexingAgreementByPayer(address indexer, address payer, bytes16 agreementId) external;
+
+    function getIndexingAgreement(IndexingAgreementKey memory key) external view returns (IndexingAgreementData memory);
 }

packages/subgraph-service/test/subgraphService/indexing-agreement/integration.t.sol

@@ -48,6 +48,7 @@ contract SubgraphServiceIndexingAgreementCancelTest is SubgraphServiceIndexingAg
         TestIndexerParams memory params = _setupIndexer(fuzzyParams, expectedTokensLocked);
 
         uint256 signerPrivateKey = boundKey(unboundedSignerPrivateKey);
+        vm.assume(fuzzyRCV.payer != address(0));
         _setupPayerWithEscrow(fuzzyRCV.payer, signerPrivateKey, params.indexer, expectedTotalTokensCollected);
 
         uint256 agreementTokensPerSecond = 1;