`LibPosition::rightIndex` update

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

@@ -154,7 +154,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
             }
 
             // Assert that the given prestate commits to the instruction at `gindex - 1`.
-            if (preStatePos.rightIndex(MAX_GAME_DEPTH) != Position.unwrap(stepPos) - 1) {
+            if (Position.unwrap(preStatePos.rightIndex(MAX_GAME_DEPTH)) != Position.unwrap(stepPos) - 1) {
                 revert InvalidPrestate();
             }
         }
@@ -304,7 +304,7 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
         // 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 = claimData[leftMostIndex].position.rightIndex(MAX_GAME_DEPTH);
+        Position leftMostTraceIndex = claimData[leftMostIndex].position.rightIndex(MAX_GAME_DEPTH);
         for (uint256 i = leftMostIndex; i < type(uint64).max; ) {
             // Fetch the claim at the current index.
             ClaimData storage claim = claimData[i];
@@ -325,8 +325,8 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone {
             // 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 = claimPos.rightIndex(MAX_GAME_DEPTH);
-            if (traceIndex < leftMostTraceIndex) {
+            Position traceIndex = claimPos.rightIndex(MAX_GAME_DEPTH);
+            if (Position.unwrap(traceIndex) < Position.unwrap(leftMostTraceIndex)) {
                 leftMostTraceIndex = traceIndex;
                 leftMostIndex = i + 1;
             }

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

@@ -99,7 +99,7 @@ library LibPosition {
     function rightIndex(
         Position _position,
         uint256 _maxDepth
-    ) internal pure returns (uint64 rightIndex_) {
+    ) internal pure returns (Position rightIndex_) {
         uint256 msb = depth(_position);
         assembly {
             switch eq(msb, _maxDepth)

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

@@ -105,15 +105,14 @@ contract LibPosition_Test is Test {
         _indexAtDepth = boundIndexAtDepth(_depth, _indexAtDepth);
 
         Position position = LibPosition.wrap(_depth, _indexAtDepth);
-        uint64 rightIndex = position.rightIndex(_maxDepth);
+        Position rightIndex = position.rightIndex(_maxDepth);
 
         // Find the deepest, rightmost index in Solidity rather than Yul
         for (uint256 i = _depth; i < _maxDepth; ++i) {
             position = position.right();
         }
-        uint64 _rightIndex = position.indexAtDepth();
 
-        assertEq(rightIndex, _rightIndex);
+        assertEq(Position.unwrap(rightIndex), Position.unwrap(position));
     }
 
     /**