Bug fixes, actor tests.

packages/contracts-bedrock/.gas-snapshot

@@ -32,25 +32,28 @@ 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: 26385)
-FaultDisputeGame_Test:test_defendRoot_reverts() (gas: 13236)
-FaultDisputeGame_Test:test_duplicateClaim_reverts() (gas: 103271)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 491297)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot:test_resolvesCorrectly_succeeds() (gas: 484572)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 488105)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot:test_resolvesCorrectly_succeeds() (gas: 481380)
+FaultDisputeGame_Test:test_clockTimeExceeded_reverts() (gas: 26444)
+FaultDisputeGame_Test:test_defendRoot_reverts() (gas: 13258)
+FaultDisputeGame_Test:test_duplicateClaim_reverts() (gas: 103343)
 FaultDisputeGame_Test:test_extraData_succeeds() (gas: 17478)
 FaultDisputeGame_Test:test_gameData_succeeds() (gas: 17881)
-FaultDisputeGame_Test:test_gameDepthExceeded_reverts() (gas: 5904481)
+FaultDisputeGame_Test:test_gameDepthExceeded_reverts() (gas: 407234)
 FaultDisputeGame_Test:test_gameStart_succeeds() (gas: 10359)
 FaultDisputeGame_Test:test_gameType_succeeds() (gas: 8216)
-FaultDisputeGame_Test:test_initialRootClaimData_succeeds() (gas: 17691)
+FaultDisputeGame_Test:test_initialRootClaimData_succeeds() (gas: 17669)
 FaultDisputeGame_Test:test_moveAgainstNonexistentParent_reverts() (gas: 24610)
 FaultDisputeGame_Test:test_move_gameNotInProgress_reverts() (gas: 10901)
-FaultDisputeGame_Test:test_resolve_challengeContested() (gas: 221762)
-FaultDisputeGame_Test:test_resolve_reverts() (gas: 26950)
-FaultDisputeGame_Test:test_resolve_rootContested() (gas: 106796)
-FaultDisputeGame_Test:test_resolve_rootUncontested() (gas: 24266)
-FaultDisputeGame_Test:test_resolve_teamDeathmatch() (gas: 392574)
-FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8203)
-FaultDisputeGame_Test:test_simpleAttack_succeeds() (gas: 107435)
-FaultDisputeGame_Test:test_step_absolute_succeeds() (gas: 5943009)
+FaultDisputeGame_Test:test_resolve_challengeContested() (gas: 221594)
+FaultDisputeGame_Test:test_resolve_notInProgress_reverts() (gas: 9657)
+FaultDisputeGame_Test:test_resolve_rootContested() (gas: 106539)
+FaultDisputeGame_Test:test_resolve_rootUncontested() (gas: 20173)
+FaultDisputeGame_Test:test_resolve_teamDeathmatch() (gas: 392370)
+FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8225)
+FaultDisputeGame_Test:test_simpleAttack_succeeds() (gas: 107438)
 FaultDisputeGame_Test:test_version_succeeds() (gas: 9802)
 FeeVault_Test:test_constructor_succeeds() (gas: 18185)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 352135)

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

@@ -27,12 +27,12 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
     /**
      * @notice The current Semver of the FaultDisputeGame implementation.
      */
-    string internal constant VERSION = "0.0.1";
+    string internal constant VERSION = "0.0.2";
 
     /**
      * @notice The max depth of the game.
      */
-    uint256 internal constant MAX_GAME_DEPTH = 63;
+    uint256 internal constant MAX_GAME_DEPTH = 4;
 
     /**
      * @notice The duration of the game.
@@ -124,8 +124,8 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // Determine the position of the step.
         Position stepPos = _isAttack ? parentPos.attack() : parentPos.defend();
 
-        // Ensure that the step position is at the maximum game depth.
-        if (stepPos.depth() != MAX_GAME_DEPTH) {
+        // Ensure that the step position is 1 deeper than the maximum game depth.
+        if (stepPos.depth() != MAX_GAME_DEPTH + 1) {
             revert InvalidParent();
         }
 
@@ -136,14 +136,14 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
             // If the step position's index at depth is 0, the prestate is the absolute prestate
             // and the post state is the parent claim.
             preStateClaim = ABSOLUTE_PRESTATE;
-            postStateClaim = claimData[_stateIndex].claim;
+            postStateClaim = claimData[_parentIndex].claim;
         } else {
             Position preStatePos;
             if (_isAttack) {
                 // If the step is an attack, the prestate exists elsewhere in the game state,
                 // and the parent claim is the expected post-state.
                 preStatePos = claimData[_stateIndex].position;
-                preStateClaim = claimData[_parentIndex].claim;
+                preStateClaim = claimData[_stateIndex].claim;
                 postStateClaim = parent.claim;
             } else {
                 // If the step is a defense, the poststate exists elsewhere in the game state,
@@ -156,7 +156,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
             // Assert that the given prestate commits to the instruction at `gindex - 1`.
             if (
                 Position.unwrap(preStatePos.rightIndex(MAX_GAME_DEPTH)) !=
-                Position.unwrap(stepPos) - 1
+                Position.unwrap(parentPos) - 1
             ) {
                 revert InvalidPrestate();
             }
@@ -215,7 +215,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // At the leaf nodes of the game, the only option is to run a step to prove or disprove
         // the above claim. At this depth, the parent claim commits to the state after a single
         // instruction step.
-        if (nextPosition.depth() >= MAX_GAME_DEPTH) {
+        if (nextPosition.depth() > MAX_GAME_DEPTH) {
             revert GameDepthExceeded();
         }
 
@@ -300,14 +300,23 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
      * @inheritdoc IDisputeGame
      */
     function resolve() external returns (GameStatus status_) {
+        // TODO: Do not allow resolution before clocks run out.
+
         if (status != GameStatus.IN_PROGRESS) {
+            // If the game is not in progress, it cannot be resolved.
             revert GameNotInProgress();
+        } else if (!claimData[0].countered) {
+            // If the root claim has never been countered, it implicitly wins.
+            status_ = GameStatus.DEFENDER_WINS;
+            status = status_;
+            emit Resolved(status_);
+            return status_;
         }
 
         // 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;
-        Position leftMostTraceIndex = claimData[leftMostIndex].position.rightIndex(MAX_GAME_DEPTH);
+        Position leftMostTraceIndex = Position.wrap(type(uint128).max);
         for (uint256 i = leftMostIndex; i < type(uint64).max; ) {
             // Fetch the claim at the current index.
             ClaimData storage claim = claimData[i];
@@ -338,7 +347,10 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // 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 (claimData[leftMostIndex].position.depth() % 2 == 0) {
+        if (
+            claimData[leftMostIndex].position.depth() % 2 == 0 &&
+            Position.unwrap(leftMostTraceIndex) != type(uint128).max
+        ) {
             status_ = GameStatus.DEFENDER_WINS;
         } else {
             status_ = GameStatus.CHALLENGER_WINS;