fix: prevent legacy slash from breaking provision accounting (OZ H-01)

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

Author: tmigone

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

@@ -195,6 +195,14 @@ contract DisputeManagerTest is SubgraphServiceSharedTest {
         return _disputeID;
     }
 
+    struct Balances {
+        uint256 indexer;
+        uint256 fisherman;
+        uint256 arbitrator;
+        uint256 disputeManager;
+        uint256 staking;
+    }
+
     function _createLegacyDispute(
         address _allocationId,
         address _fisherman,
@@ -204,40 +212,62 @@ contract DisputeManagerTest is SubgraphServiceSharedTest {
         (, address arbitrator, ) = vm.readCallers();
         address indexer = staking.getAllocation(_allocationId).indexer;
 
-        bytes32 expectedDisputeId = keccak256(abi.encodePacked(_allocationId, "legacy"));
-        uint256 disputeDeposit = 0;
-
-        uint256 beforeIndexerBalance = token.balanceOf(indexer);
-        uint256 beforeFishermanBalance = token.balanceOf(_fisherman);
-        uint256 beforeArbitratorBalance = token.balanceOf(arbitrator);
+        Balances memory beforeBalances = Balances({
+            indexer: token.balanceOf(indexer),
+            fisherman: token.balanceOf(_fisherman),
+            arbitrator: token.balanceOf(arbitrator),
+            disputeManager: token.balanceOf(address(disputeManager)),
+            staking: token.balanceOf(address(staking))
+        });
 
         vm.expectEmit(address(disputeManager));
         emit IDisputeManager.LegacyDisputeCreated(
-            expectedDisputeId,
+            keccak256(abi.encodePacked(_allocationId, "legacy")),
             indexer,
             _fisherman,
             _allocationId,
             _tokensSlash,
             _tokensRewards
         );
         vm.expectEmit(address(disputeManager));
-        emit IDisputeManager.DisputeAccepted(expectedDisputeId, indexer, _fisherman, _tokensRewards);
+        emit IDisputeManager.DisputeAccepted(
+            keccak256(abi.encodePacked(_allocationId, "legacy")),
+            indexer,
+            _fisherman,
+            _tokensRewards
+        );
         bytes32 _disputeId = disputeManager.createLegacyDispute(
             _allocationId,
             _fisherman,
             _tokensSlash,
             _tokensRewards
         );
 
-        uint256 afterIndexerBalance = token.balanceOf(indexer);
-        uint256 afterFishermanBalance = token.balanceOf(_fisherman);
-        uint256 afterArbitratorBalance = token.balanceOf(arbitrator);
+        Balances memory afterBalances = Balances({
+            indexer: token.balanceOf(indexer),
+            fisherman: token.balanceOf(_fisherman),
+            arbitrator: token.balanceOf(arbitrator),
+            disputeManager: token.balanceOf(address(disputeManager)),
+            staking: token.balanceOf(address(staking))
+        });
+
+        assertEq(afterBalances.indexer, beforeBalances.indexer);
+        assertEq(afterBalances.fisherman, beforeBalances.fisherman + _tokensRewards);
+        assertEq(afterBalances.arbitrator, beforeBalances.arbitrator);
+        assertEq(afterBalances.disputeManager, beforeBalances.disputeManager);
+        assertEq(afterBalances.staking, beforeBalances.staking - _tokensSlash);
 
-        assertEq(afterIndexerBalance, beforeIndexerBalance - _tokensSlash);
-        assertEq(afterFishermanBalance, beforeFishermanBalance + _tokensRewards);
-        assertEq(afterArbitratorBalance, beforeArbitratorBalance);
-        assertTrue(disputeManager.isDisputeCreated(_disputeId));
-        assertEq(expectedDisputeId, _disputeId);
+        IDisputeManager.Dispute memory dispute = _getDispute(_disputeId);
+        assertEq(dispute.indexer, indexer);
+        assertEq(dispute.fisherman, _fisherman);
+        assertEq(dispute.deposit, 0);
+        assertEq(dispute.relatedDisputeId, bytes32(0));
+        assertEq(uint8(dispute.disputeType), uint8(IDisputeManager.DisputeType.LegacyDispute));
+        assertEq(uint8(dispute.status), uint8(IDisputeManager.DisputeStatus.Accepted));
+        assertEq(dispute.createdAt, block.timestamp);
+        assertEq(dispute.stakeSnapshot, 0);
+
+        return _disputeId;
     }
 
     struct BeforeValues_CreateQueryDisputeConflict {

packages/subgraph-service/test/disputeManager/disputes/legacy.t.sol

@@ -19,7 +19,7 @@ contract DisputeManagerLegacyDisputeTest is DisputeManagerTest {
      * TESTS
      */
 
-    function test_LegacyDisputeONly(
+    function test_LegacyDispute(
         uint256 tokensStaked,
         uint256 tokensProvisioned,
         uint256 tokensSlash,
@@ -29,7 +29,7 @@ contract DisputeManagerLegacyDisputeTest is DisputeManagerTest {
         vm.assume(tokensStaked >= minimumProvisionTokens);
         tokensProvisioned = bound(tokensProvisioned, minimumProvisionTokens, tokensStaked);
         tokensSlash = bound(tokensSlash, 2, tokensProvisioned);
-        tokensRewards = bound(tokensRewards, 1, uint256(maxSlashingPercentage).mulPPM(tokensSlash));
+        tokensRewards = bound(tokensRewards, 1, tokensSlash.mulPPM(maxSlashingPercentage));
 
         // setup indexer state
         resetPrank(users.indexer);
@@ -45,4 +45,10 @@ contract DisputeManagerLegacyDisputeTest is DisputeManagerTest {
         vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerNotArbitrator.selector));
         disputeManager.createLegacyDispute(allocationID, users.fisherman, 0, 0);
     }
+
+    function test_LegacyDispute_RevertIf_AllocationNotFound() public useIndexer {
+        resetPrank(users.arbitrator);
+        vm.expectRevert(abi.encodeWithSelector(IDisputeManager.DisputeManagerIndexerNotFound.selector, address(0)));
+        disputeManager.createLegacyDispute(address(0), users.fisherman, 0, 0);
+    }
 }