rm: `attack` / `defend`; add: `move`

gas snapshot

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

@@ -123,7 +123,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // Pull the parent position out of storage.
         Position parentPos = parent.position;
         // Determine the position of the step.
-        Position stepPos = _isAttack ? parentPos.attack() : parentPos.defend();
+        Position stepPos = parentPos.move(_isAttack);
 
         // Ensure that the step position is 1 deeper than the maximum game depth.
         if (stepPos.depth() != MAX_GAME_DEPTH + 1) {
@@ -214,7 +214,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // Compute the position that the claim commits to. Because the parent's position is already
         // known, we can compute the next position by moving left or right depending on whether
         // or not the move is an attack or defense.
-        Position nextPosition = _isAttack ? parent.position.attack() : parent.position.defend();
+        Position nextPosition = parent.position.move(_isAttack);
 
         // 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

packages/contracts-bedrock/contracts/dispute/lib/LibPosition.sol

@@ -126,29 +126,16 @@ library LibPosition {
     }
 
     /**
-     * @notice Get the attack position relative to `position`. The attack position is the next
-     *         logical point of bisection if the parent claim is disagreed with, which is the
-     *         midway point of the trace that the attacked node commits to.
-     * @param _position The position to get the relative attack position of.
-     * @return attack_ The attack position relative to `position`.
+     * @notice Get the move position of `_position`, which is the left child of:
+     *         1. `_position + 1` if `_isAttack` is true.
+     *         1. `_position` if `_isAttack` is false.
+     * @param _position The position to get the relative attack/defense position of.
+     * @param _isAttack Whether or not the move is a defense move.
+     * @return move_ The move position relative to `position`.
      */
-    function attack(Position _position) internal pure returns (Position attack_) {
-        // Move: Left
-        return left(_position);
-    }
-
-    /**
-     * @notice Get the defense position relative to `position`. The defense position is the next
-     *         logical point of bisection if the parent claim and the grandparent claim are agreed
-     *         with, which is at the midway point of the trace that the defended node's right
-     *         sibling commits to.
-     * @param _position The position to get the relative defense position of.
-     * @return defense_ The defense position relative to `position`.
-     */
-    function defend(Position _position) internal pure returns (Position defense_) {
+    function move(Position _position, bool _isAttack) internal pure returns (Position move_) {
         assembly {
-            // Move: Parent -> Right -> Left
-            defense_ := shl(1, or(1, _position))
+            move_ := shl(1, or(iszero(_isAttack), _position))
         }
     }
 }

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

@@ -250,7 +250,7 @@ contract FaultDisputeGame_Test is FaultDisputeGame_Init {
         assertEq(parentIndex, 0);
         assertEq(countered, false);
         assertEq(Claim.unwrap(claim), Claim.unwrap(counter));
-        assertEq(Position.unwrap(position), Position.unwrap(Position.wrap(1).attack()));
+        assertEq(Position.unwrap(position), Position.unwrap(Position.wrap(1).move(true)));
         assertEq(
             Clock.unwrap(clock),
             Clock.unwrap(LibClock.wrap(Duration.wrap(5), Timestamp.wrap(uint64(block.timestamp))))

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

@@ -126,7 +126,7 @@ contract LibPosition_Test is Test {
         _indexAtDepth = boundIndexAtDepth(_depth, _indexAtDepth);
 
         Position position = LibPosition.wrap(_depth, _indexAtDepth);
-        Position attack = position.attack();
+        Position attack = position.move(true);
 
         assertEq(attack.depth(), _depth + 1);
         assertEq(attack.indexAtDepth(), _indexAtDepth * 2);
@@ -144,7 +144,7 @@ contract LibPosition_Test is Test {
         _indexAtDepth = boundIndexAtDepth(_depth, _indexAtDepth);
 
         Position position = LibPosition.wrap(_depth, _indexAtDepth);
-        Position defend = position.defend();
+        Position defend = position.move(false);
 
         assertEq(defend.depth(), _depth + 1);
         assertEq(defend.indexAtDepth(), ((_indexAtDepth / 2) * 2 + 1) * 2);