fix(test): wait for game of required type, not just any game

The previous fix waited for any game to exist, but the system may have
a pre-existing permissioned game (type 0) from initialization. The FP
proposer creates games of type 1 (respected game type), so the test
needs to wait specifically for a game of that type before calling Prove.

Add WaitForGameOfType helper that polls DGF for a game matching the
specified type, and use it in the withdrawal test.

Author: fakedev9999

tests/e2e/faultproof/withdrawal/withdrawal_finalized_test.go

@@ -36,7 +36,8 @@ func TestFaultProofProposer_WithdrawalFinalized(gt *testing.T) {
 	l2User.VerifyBalanceExact(depositAmount)
 
 	// Log respected game type for debugging
-	logger.Info("Using respected game type", "gameType", bridge.RespectedGameType())
+	respectedGameType := bridge.RespectedGameType()
+	logger.Info("Using respected game type", "gameType", respectedGameType)
 
 	// Phase 1: Initiate withdrawal on L2
 	logger.Info("Phase 1: Initiating withdrawal on L2")
@@ -47,13 +48,14 @@ func TestFaultProofProposer_WithdrawalFinalized(gt *testing.T) {
 	expectedL2UserBalance := depositAmount.Sub(withdrawAmount).Sub(withdrawal.InitiateGasCost())
 	l2User.VerifyBalanceExact(expectedL2UserBalance)
 
-	// Wait for at least one game to be created before proving
-	// The FP proposer needs time to batch L2 blocks and create games
+	// Wait for a game of the required type to be created before proving.
+	// The system may have games of other types (e.g., permissioned type 0),
+	// but the FP proposer creates games of the respected type.
 	dgf := sys.DgfClient(t)
 	ctx, cancel := context.WithTimeout(t.Ctx(), utils.ShortTimeout())
 	defer cancel()
-	logger.Info("Waiting for dispute game creation")
-	utils.WaitForGameCount(ctx, t, dgf, 1)
+	logger.Info("Waiting for game of required type")
+	utils.WaitForGameOfType(ctx, t, dgf, respectedGameType)
 
 	// Phase 2: Prove withdrawal on L1
 	logger.Info("Phase 2: Proving withdrawal on L1")

tests/utils/adapters.go

@@ -185,6 +185,37 @@ func WaitForGameCount(ctx context.Context, t devtest.T, dgf *DgfClient, min uint
 	}
 }
 
+// WaitForGameOfType waits until a dispute game of the specified type exists.
+// This is needed because the system may have games of other types (e.g., permissioned type 0)
+// while the FP proposer creates games of type 1.
+func WaitForGameOfType(ctx context.Context, t devtest.T, dgf *DgfClient, gameType uint32) {
+	for {
+		gameCount, err := dgf.GameCount(ctx)
+		require.NoError(t, err, "failed to get game count from factory")
+
+		// Check all games (newest first) for matching type
+		for i := int64(gameCount) - 1; i >= 0; i-- {
+			game, err := dgf.GameAtIndex(ctx, uint64(i))
+			if err != nil {
+				continue
+			}
+			if game.GameType == gameType {
+				t.Logger().Info("Found game of required type", "index", i, "gameType", gameType)
+				return
+			}
+		}
+
+		t.Logger().Info("Waiting for game of required type...", "gameType", gameType, "totalGames", gameCount)
+
+		select {
+		case <-ctx.Done():
+			t.Errorf("timeout waiting for game of type %d", gameType)
+			t.FailNow()
+		case <-time.After(time.Second):
+		}
+	}
+}
+
 // -------------------------------------------------------------
 // Fault Dispute Game Client
 // -------------------------------------------------------------