Address review comments on batch resizing test

The test for ErrMessageTooLarge batch resizing had several issues
identified in code review. This commit addresses them to make the test
more robust and better verify the intended behavior.

Key changes:
- Enable fallback (DisableDapFallbackStoreDataOnChain = false) instead
  of disabling it, so the test proves the batch poster *chooses* not to
  fall back when receiving ErrMessageTooLarge, rather than being unable to
- Replace manual L1 block advancement loops with AdvanceL1 helper
- Use WaitForTx to properly verify follower sync instead of just checking
  BlockNumber (which only confirms the node is responding)
- Add follower sync verification to Phase 2 (was missing)
- Fail immediately on any non-CustomDA batch type instead of only
  tracking brotli batches
- Allow one oversized batch in Phase 2 to handle the race condition
  between changing the max size limit and batches already in flight

Author: Tristan-Wilson

system_tests/multi_writer_fallback_test.go

@@ -1070,8 +1070,9 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 	// Disable AnyTrust
 	builder.nodeConfig.DA.AnyTrust.Enable = false
 
-	// Disable fallback to on-chain to ensure we're testing resize, not fallback
-	builder.nodeConfig.BatchPoster.DisableDapFallbackStoreDataOnChain = true
+	// Enable fallback to on-chain - this proves the batch poster *chooses* not to fall back
+	// when receiving ErrMessageTooLarge (it resizes instead), rather than being unable to fall back
+	builder.nodeConfig.BatchPoster.DisableDapFallbackStoreDataOnChain = false
 
 	// Configure batch posting to use size-based triggers
 	builder.nodeConfig.BatchPoster.MaxDelay = 60 * time.Second
@@ -1107,27 +1108,28 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 	Require(t, err)
 
 	// Generate enough transactions to create a ~10KB batch
+	var phase1LastTxHash common.Hash
 	for i := 0; i < 250; i++ {
 		tx := builder.L2Info.PrepareTx("Owner", "User2",
 			builder.L2Info.TransferGas, big.NewInt(1e12), nil)
 		err := builder.L2.Client.SendTransaction(ctx, tx)
 		Require(t, err)
+		phase1LastTxHash = tx.Hash()
 	}
 
 	t.Log("Phase 1: Generated 250 transactions")
 
 	// Create L1 blocks to trigger batch posting
-	for i := 0; i < 30; i++ {
-		SendWaitTestTransactions(t, ctx, builder.L1.Client, []*types.Transaction{
-			builder.L1Info.PrepareTx("Faucet", "User", 30000, big.NewInt(1e12), nil),
-		})
-	}
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 30)
 
-	// Wait for batch to post
-	time.Sleep(time.Second * 2)
+	// Give batch poster time to post the batch
+	time.Sleep(time.Second * 3)
 
-	// Verify follower synced
-	_, err = l2B.Client.BlockNumber(ctx)
+	// Create more L1 blocks for follower to read and process
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 10)
+
+	// Verify follower synced by waiting for the last transaction
+	_, err = WaitForTx(ctx, l2B.Client, phase1LastTxHash, time.Second*60)
 	Require(t, err)
 
 	l1BlockAfterPhase1, err := builder.L1.Client.BlockNumber(ctx)
@@ -1167,6 +1169,8 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 			if payloadSize < 8_000 || payloadSize > 12_000 {
 				t.Errorf("Phase 1: CustomDA payload size %d outside expected range 8KB-12KB", payloadSize)
 			}
+		} else {
+			t.Fatalf("Phase 1: Expected CustomDA batch but found unexpected batch type (header=0x%02x)", headerByte)
 		}
 	}
 
@@ -1187,25 +1191,31 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 	Require(t, err)
 
 	// Generate more transactions to create another large batch
+	var phase2LastTxHash common.Hash
 	for i := 0; i < 250; i++ {
 		tx := builder.L2Info.PrepareTx("Owner", "User2",
 			builder.L2Info.TransferGas, big.NewInt(1e12), nil)
 		err := builder.L2.Client.SendTransaction(ctx, tx)
 		Require(t, err)
+		phase2LastTxHash = tx.Hash()
 	}
 
 	t.Log("Phase 2: Generated 250 transactions")
 
 	// Create L1 blocks to trigger batch posting attempts
 	// The batch poster will initially try to build a ~10KB batch (based on previous max size),
 	// hit ErrMessageTooLarge, then query GetMaxMessageSize again (getting 5KB), and rebuild smaller batches
-	for i := 0; i < 40; i++ {
-		SendWaitTestTransactions(t, ctx, builder.L1.Client, []*types.Transaction{
-			builder.L1Info.PrepareTx("Faucet", "User", 30000, big.NewInt(1e12), nil),
-		})
-	}
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 40)
 
-	time.Sleep(time.Second * 3)
+	// Give batch poster time to post the batches (may need multiple retries due to resize)
+	time.Sleep(time.Second * 5)
+
+	// Create more L1 blocks for follower to read and process
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 10)
+
+	// Verify follower synced by waiting for the last transaction
+	_, err = WaitForTx(ctx, l2B.Client, phase2LastTxHash, time.Second*60)
+	Require(t, err)
 
 	l1BlockAfterPhase2, err := builder.L1.Client.BlockNumber(ctx)
 	Require(t, err)
@@ -1216,7 +1226,7 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 	Require(t, err)
 
 	phase2CustomDABatches := 0
-	phase2CalldataBatches := 0
+	phase2OversizedBatches := 0
 	var phase2MaxPayloadSize int
 	for _, batch := range phase2Batches {
 		serializedBatch, err := batch.Serialize(ctx, builder.L1.Client)
@@ -1238,19 +1248,26 @@ func TestBatchResizingWithoutFallback_MessageTooLarge(t *testing.T) {
 				phase2MaxPayloadSize = payloadSize
 			}
 
-			// Verify batch is approximately 5KB (3KB-6KB range)
+			// Track batches exceeding the new limit
+			// The first batch may exceed the limit due to race condition (built before limit change)
 			if payloadSize > 6_000 {
-				t.Errorf("Phase 2: CustomDA payload size %d exceeds expected max ~5KB", payloadSize)
+				phase2OversizedBatches++
+				t.Logf("Phase 2: Batch %d exceeds 6KB limit (expected for first batch due to race)", phase2CustomDABatches)
 			}
-		} else if daprovider.IsBrotliMessageHeaderByte(headerByte) {
-			phase2CalldataBatches++
-			t.Logf("Phase 2: Found Calldata batch (header=0x%02x) - unexpected!", headerByte)
+		} else {
+			t.Fatalf("Phase 2: Expected CustomDA batch but found unexpected batch type (header=0x%02x)", headerByte)
 		}
 	}
 
-	// Verify no fallback to calldata occurred
-	if phase2CalldataBatches > 0 {
-		t.Fatalf("Phase 2: Expected no fallback to calldata, but found %d calldata batches", phase2CalldataBatches)
+	// Allow at most 1 oversized batch due to a race condition between changing the max size
+	// and the batch poster's existing work. The batch poster doesn't constantly re-query
+	// GetMaxMessageSize - it queries once, builds batches up to that limit, and only
+	// re-queries after receiving ErrMessageTooLarge. So when we change the limit from 10KB
+	// to 5KB, there may be a batch already built with the old limit. That batch gets posted,
+	// triggers ErrMessageTooLarge, and then the batch poster queries the new limit and
+	// rebuilds subsequent batches to fit within 5KB.
+	if phase2OversizedBatches > 1 {
+		t.Errorf("Phase 2: Expected at most 1 oversized batch (race condition), but found %d", phase2OversizedBatches)
 	}
 
 	if phase2CustomDABatches == 0 {