feat: use poi to create dispute

Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

packages/subgraph-service/contracts/DisputeManager.sol

@@ -119,18 +119,24 @@ contract DisputeManager is
 
     /**
      * @notice Create an indexing dispute for the arbitrator to resolve.
-     * The disputes are created in reference to an allocationId
+     * The disputes are created in reference to an allocationId and specifically
+     * a POI for that allocation.
      * This function is called by a challenger that will need to `_deposit` at
      * least `minimumDeposit` GRT tokens.
      * @param allocationId The allocation to dispute
+     * @param poi The Proof of Indexing (POI) being disputed
      * @param deposit Amount of tokens staked as deposit
      */
-    function createIndexingDispute(address allocationId, uint256 deposit) external override returns (bytes32) {
+    function createIndexingDispute(
+        address allocationId,
+        bytes32 poi,
+        uint256 deposit
+    ) external override returns (bytes32) {
         // Get funds from submitter
         _pullSubmitterDeposit(deposit);
 
         // Create a dispute
-        return _createIndexingDisputeWithAllocation(msg.sender, deposit, allocationId);
+        return _createIndexingDisputeWithAllocation(msg.sender, deposit, allocationId, poi);
     }
 
     /**
@@ -486,14 +492,16 @@ contract DisputeManager is
      * @param _fisherman The challenger creating the dispute
      * @param _deposit Amount of tokens staked as deposit
      * @param _allocationId Allocation disputed
+     * @param _poi The POI being disputed
      */
     function _createIndexingDisputeWithAllocation(
         address _fisherman,
         uint256 _deposit,
-        address _allocationId
+        address _allocationId,
+        bytes32 _poi
     ) private returns (bytes32) {
         // Create a disputeId
-        bytes32 disputeId = keccak256(abi.encodePacked(_allocationId));
+        bytes32 disputeId = keccak256(abi.encodePacked(_allocationId, _poi));
 
         // Only one dispute for an allocationId at a time
         require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
@@ -518,7 +526,7 @@ contract DisputeManager is
             block.timestamp
         );
 
-        emit IndexingDisputeCreated(disputeId, alloc.indexer, _fisherman, _deposit, _allocationId);
+        emit IndexingDisputeCreated(disputeId, alloc.indexer, _fisherman, _deposit, _allocationId, _poi);
 
         return disputeId;
     }

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

@@ -100,7 +100,8 @@ interface IDisputeManager {
         address indexed indexer,
         address indexed fisherman,
         uint256 tokens,
-        address allocationId
+        address allocationId,
+        bytes32 poi
     );
 
     /**
@@ -193,7 +194,7 @@ interface IDisputeManager {
         bytes calldata attestationData2
     ) external returns (bytes32, bytes32);
 
-    function createIndexingDispute(address allocationId, uint256 deposit) external returns (bytes32);
+    function createIndexingDispute(address allocationId, bytes32 poi, uint256 deposit) external returns (bytes32);
 
     function acceptDispute(bytes32 disputeId, uint256 tokensSlash) external;
 

packages/subgraph-service/package.json

@@ -10,7 +10,7 @@
     "lint": "yarn lint:ts && yarn lint:sol",
     "clean": "rm -rf build cache typechain-types",
     "build": "forge build && hardhat compile",
-    "test": "FOUNDRY_PROFILE=lite forge test -vvv && hardhat test"
+    "test": "FOUNDRY_PROFILE=lite forge test -vvvv && hardhat test"
   },
   "devDependencies": {
     "@graphprotocol/contracts": "workspace:^7.0.0",

packages/subgraph-service/test/DisputeManager.t.sol

@@ -6,6 +6,7 @@ import "forge-std/Test.sol";
 import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
 import { Controller } from "@graphprotocol/contracts/contracts/governance/Controller.sol";
+import { UnsafeUpgrades } from "openzeppelin-foundry-upgrades/Upgrades.sol";
 
 import { DisputeManager } from "../contracts/DisputeManager.sol";
 import { IDisputeManager } from "../contracts/interfaces/IDisputeManager.sol";
@@ -72,16 +73,24 @@ contract DisputeManagerTest is Test {
         controller.setContractProxy(keccak256("GraphToken"), address(graphToken));
         controller.setContractProxy(keccak256("Staking"), address(staking));
         controller.setContractProxy(keccak256("RewardsManager"), address(rewardsManager));
+        controller.setContractProxy(keccak256("GraphPayments"), address(0x100));
+        controller.setContractProxy(keccak256("PaymentsEscrow"), address(0x101));
+        controller.setContractProxy(keccak256("EpochManager"), address(0x102));
+        controller.setContractProxy(keccak256("GraphTokenGateway"), address(0x103));
+        controller.setContractProxy(keccak256("GraphProxyAdmin"), address(0x104));
+        controller.setContractProxy(keccak256("Curation"), address(0x105));
         vm.stopPrank();
 
-        disputeManager = new DisputeManager(address(controller));
-        disputeManager.initialize(
-            arbitrator,
-            disputePeriod,
-            minimumDeposit,
-            fishermanRewardPercentage,
-            maxSlashingPercentage
+        address disputeManagerImplementation = address(new DisputeManager(address(controller)));
+        address disputeManagerProxy = UnsafeUpgrades.deployTransparentProxy(
+            disputeManagerImplementation,
+            governor,
+            abi.encodeCall(
+                DisputeManager.initialize,
+                (arbitrator, disputePeriod, minimumDeposit, fishermanRewardPercentage, maxSlashingPercentage)
+            )
         );
+        disputeManager = DisputeManager(disputeManagerProxy);
 
         subgraphService = new SubgraphService(address(controller), address(disputeManager), tapVerifier, curation);
         subgraphService.initialize(1000 ether, 16);
@@ -110,7 +119,7 @@ contract DisputeManagerTest is Test {
         vm.startPrank(fisherman);
         graphToken.mint(fisherman, tokens);
         graphToken.approve(address(disputeManager), tokens);
-        bytes32 _disputeID = disputeManager.createIndexingDispute(_allocationID, tokens);
+        bytes32 _disputeID = disputeManager.createIndexingDispute(_allocationID, bytes32("POI1234"), tokens);
         vm.stopPrank();
         return _disputeID;
     }
@@ -218,7 +227,7 @@ contract DisputeManagerTest is Test {
         graphToken.approve(address(disputeManager), tokens);
         bytes memory expectedError = abi.encodeWithSignature("DisputeManagerDisputeAlreadyCreated(bytes32)", disputeID);
         vm.expectRevert(expectedError);
-        disputeManager.createIndexingDispute(allocationID, tokens);
+        disputeManager.createIndexingDispute(allocationID, bytes32("POI1234"), tokens);
         vm.stopPrank();
     }
 
@@ -232,7 +241,7 @@ contract DisputeManagerTest is Test {
             100 ether
         );
         vm.expectRevert(expectedError);
-        disputeManager.createIndexingDispute(allocationID, 50 ether);
+        disputeManager.createIndexingDispute(allocationID, bytes32("POI1234"), 50 ether);
         vm.stopPrank();
     }
 
@@ -244,7 +253,7 @@ contract DisputeManagerTest is Test {
         graphToken.approve(address(disputeManager), tokens);
         bytes memory expectedError = abi.encodeWithSignature("DisputeManagerIndexerNotFound(address)", allocationID);
         vm.expectRevert(expectedError);
-        disputeManager.createIndexingDispute(allocationID, tokens);
+        disputeManager.createIndexingDispute(allocationID, bytes32("POI1234"), tokens);
         vm.stopPrank();
     }