Merge pull request #6059 from ethereum-optimism/inphi/resolve-dispute

feat(ctb): Implement fault dispute game resolution

packages/contracts-bedrock/.gas-snapshot

@@ -32,19 +32,24 @@ DisputeGameFactory_SetImplementation_Test:test_setImplementation_notOwner_revert
 DisputeGameFactory_SetImplementation_Test:test_setImplementation_succeeds() (gas: 44243)
 DisputeGameFactory_TransferOwnership_Test:test_transferOwnership_notOwner_reverts() (gas: 15950)
 DisputeGameFactory_TransferOwnership_Test:test_transferOwnership_succeeds() (gas: 18642)
-FaultDisputeGame_Test:test_clockTimeExceeded_reverts() (gas: 26474)
-FaultDisputeGame_Test:test_defendRoot_reverts() (gas: 13258)
-FaultDisputeGame_Test:test_duplicateClaim_reverts() (gas: 103381)
+FaultDisputeGame_Test:test_clockTimeExceeded_reverts() (gas: 26496)
+FaultDisputeGame_Test:test_defendRoot_reverts() (gas: 13236)
+FaultDisputeGame_Test:test_duplicateClaim_reverts() (gas: 103425)
 FaultDisputeGame_Test:test_extraData_succeeds() (gas: 17478)
 FaultDisputeGame_Test:test_gameData_succeeds() (gas: 17859)
-FaultDisputeGame_Test:test_gameDepthExceeded_reverts() (gas: 5907275)
+FaultDisputeGame_Test:test_gameDepthExceeded_reverts() (gas: 5907231)
 FaultDisputeGame_Test:test_gameStart_succeeds() (gas: 10337)
-FaultDisputeGame_Test:test_gameType_succeeds() (gas: 8194)
-FaultDisputeGame_Test:test_initialRootClaimData_succeeds() (gas: 17580)
-FaultDisputeGame_Test:test_moveAgainstNonexistentParent_reverts() (gas: 24587)
+FaultDisputeGame_Test:test_gameType_succeeds() (gas: 8259)
+FaultDisputeGame_Test:test_initialRootClaimData_succeeds() (gas: 17624)
+FaultDisputeGame_Test:test_moveAgainstNonexistentParent_reverts() (gas: 24632)
 FaultDisputeGame_Test:test_move_gameNotInProgress_reverts() (gas: 10945)
-FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8191)
-FaultDisputeGame_Test:test_simpleAttack_succeeds() (gas: 107367)
+FaultDisputeGame_Test:test_resolve_challengeContested() (gas: 222383)
+FaultDisputeGame_Test:test_resolve_reverts() (gas: 27121)
+FaultDisputeGame_Test:test_resolve_rootContested() (gas: 107225)
+FaultDisputeGame_Test:test_resolve_rootUncontested() (gas: 24459)
+FaultDisputeGame_Test:test_resolve_teamDeathmatch() (gas: 393609)
+FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8169)
+FaultDisputeGame_Test:test_simpleAttack_succeeds() (gas: 107389)
 FaultDisputeGame_Test:test_version_succeeds() (gas: 9780)
 FeeVault_Test:test_constructor_succeeds() (gas: 18185)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 352135)

packages/contracts-bedrock/contracts/dispute/FaultDisputeGame.sol

@@ -219,9 +219,56 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
      * @inheritdoc IDisputeGame
      */
     function resolve() external returns (GameStatus status_) {
-        // TODO - Resolve the game
-        status = GameStatus.IN_PROGRESS;
-        status_ = status;
+        if (status != GameStatus.IN_PROGRESS) {
+            revert GameNotInProgress();
+        }
+
+        // Search for the left-most dangling non-bottom node
+        // The most recent claim is always a dangling, non-bottom node so we start with that
+        uint256 leftMostIndex = claimData.length - 1;
+        uint256 leftMostTraceIndex = LibPosition.rightIndex(
+            claimData[leftMostIndex].position,
+            MAX_GAME_DEPTH
+        );
+        for (uint256 i = leftMostIndex; i < type(uint64).max; ) {
+            // Fetch the claim at the current index.
+            ClaimData storage claim = claimData[i];
+
+            // Decrement the loop counter; If it underflows, we've reached the root
+            // claim and can stop searching.
+            unchecked {
+                --i;
+            }
+
+            // If the claim is not a dangling node above the bottom of the tree,
+            // we can skip over it. These nodes are not relevant to the game resolution.
+            Position claimPos = claim.position;
+            if (LibPosition.depth(claimPos) == MAX_GAME_DEPTH || claim.countered) {
+                continue;
+            }
+
+            // If the claim is a dangling node, we can check if it is the left-most
+            // dangling node we've come across so far. If it is, we can update the
+            // left-most trace index.
+            uint256 traceIndex = LibPosition.rightIndex(claimPos, MAX_GAME_DEPTH);
+            if (traceIndex < leftMostTraceIndex) {
+                leftMostTraceIndex = traceIndex;
+                leftMostIndex = i + 1;
+            }
+        }
+
+        // If the left-most dangling node is at an even depth, the defender wins.
+        // Otherwise, the challenger wins and the root claim is deemed invalid.
+        // slither-disable-next-line weak-prng
+        if (LibPosition.depth(claimData[leftMostIndex].position) % 2 == 0) {
+            status_ = GameStatus.DEFENDER_WINS;
+        } else {
+            status_ = GameStatus.CHALLENGER_WINS;
+        }
+
+        // Update the game status
+        status = status_;
+        emit Resolved(status_);
     }
 
     /**

packages/contracts-bedrock/contracts/test/FaultDisputeGame.t.sol

@@ -268,6 +268,61 @@ contract FaultDisputeGame_Test is DisputeGameFactory_Init {
             )
         );
     }
+
+    /**
+     * @dev Static unit test for the correctness an uncontested root resolution.
+     */
+    function test_resolve_rootUncontested() public {
+        GameStatus status = gameProxy.resolve();
+        assertEq(uint8(status), uint8(GameStatus.DEFENDER_WINS));
+        assertEq(uint8(gameProxy.status()), uint8(GameStatus.DEFENDER_WINS));
+    }
+
+    /**
+     * @dev Static unit test asserting that resolve reverts when the game is not in progress.
+     */
+    function test_resolve_reverts() public {
+        gameProxy.resolve();
+        vm.expectRevert(GameNotInProgress.selector);
+        gameProxy.resolve();
+    }
+
+    /**
+     * @dev Static unit test for the correctness of resolving a single attack game state.
+     */
+    function test_resolve_rootContested() public {
+        gameProxy.attack(0, Claim.wrap(bytes32(uint256(5))));
+
+        GameStatus status = gameProxy.resolve();
+        assertEq(uint8(status), uint8(GameStatus.CHALLENGER_WINS));
+        assertEq(uint8(gameProxy.status()), uint8(GameStatus.CHALLENGER_WINS));
+    }
+
+    /**
+     * @dev Static unit test for the correctness of resolving a game with a contested challenge claim.
+     */
+    function test_resolve_challengeContested() public {
+        gameProxy.attack(0, Claim.wrap(bytes32(uint256(5))));
+        gameProxy.defend(1, Claim.wrap(bytes32(uint256(6))));
+
+        GameStatus status = gameProxy.resolve();
+        assertEq(uint8(status), uint8(GameStatus.DEFENDER_WINS));
+        assertEq(uint8(gameProxy.status()), uint8(GameStatus.DEFENDER_WINS));
+    }
+
+    /**
+     * @dev Static unit test for the correctness of resolving a game with multiplayer moves.
+     */
+    function test_resolve_teamDeathmatch() public {
+        gameProxy.attack(0, Claim.wrap(bytes32(uint256(5))));
+        gameProxy.attack(0, Claim.wrap(bytes32(uint256(4))));
+        gameProxy.defend(1, Claim.wrap(bytes32(uint256(6))));
+        gameProxy.defend(1, Claim.wrap(bytes32(uint256(7))));
+
+        GameStatus status = gameProxy.resolve();
+        assertEq(uint8(status), uint8(GameStatus.CHALLENGER_WINS));
+        assertEq(uint8(gameProxy.status()), uint8(GameStatus.CHALLENGER_WINS));
+    }
 }
 
 /**