add unit tests for UncompressedBatchBytesLimit

Author: colinlyguo

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -256,3 +256,102 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
 
 	assert.Equal(t, expectedChunkNum, dbBatch.EndChunkIndex)
 }
+
+func testBatchProposerUncompressedBatchBytesLimitCodecV8(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	// Add genesis batch
+	genesisBlock := &encoding.Block{
+		Header: &gethTypes.Header{
+			Number: big.NewInt(0),
+		},
+	}
+	genesisChunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{genesisBlock},
+	}
+	chunkOrm := orm.NewChunk(db)
+	_, err := chunkOrm.InsertChunk(context.Background(), genesisChunk, encoding.CodecV0, utils.ChunkMetrics{})
+	assert.NoError(t, err)
+
+	genesisBatch := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{genesisChunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	_, err = batchOrm.InsertBatch(context.Background(), genesisBatch, encoding.CodecV0, utils.BatchMetrics{})
+	assert.NoError(t, err)
+
+	// Create blocks with large calldata
+	block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+
+	// Create large calldata (3MB per block)
+	largeCalldata := make([]byte, 3*1024*1024) // 3MB calldata
+	for i := range largeCalldata {
+		largeCalldata[i] = byte(i % 256)
+	}
+
+	// Modify the block to have a transaction with large calldata
+	block.Transactions[0].Data = "0x" + common.Bytes2Hex(largeCalldata)
+
+	chainConfig := &params.ChainConfig{
+		LondonBlock:    big.NewInt(0),
+		BernoulliBlock: big.NewInt(0),
+		CurieBlock:     big.NewInt(0),
+		DarwinTime:     new(uint64),
+		DarwinV2Time:   new(uint64),
+		EuclidTime:     new(uint64),
+		EuclidV2Time:   new(uint64),
+		FeynmanTime:    new(uint64),
+	}
+
+	// Create chunk proposer with no uncompressed batch bytes limit for chunks
+	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:           1, // One block per chunk
+		MaxL2GasPerChunk:              math.MaxUint64,
+		ChunkTimeoutSec:               math.MaxUint32,
+		MaxUncompressedBatchBytesSize: math.MaxUint64,
+	}, encoding.CodecV8, chainConfig, db, nil)
+
+	// Insert 2 blocks with large calldata and create 2 chunks
+	l2BlockOrm := orm.NewL2Block(db)
+	for i := uint64(1); i <= 2; i++ {
+		blockCopy := *block
+		blockCopy.Header = &gethTypes.Header{}
+		*blockCopy.Header = *block.Header
+		blockCopy.Header.Number = new(big.Int).SetUint64(i)
+		blockCopy.Header.Time = i
+		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{&blockCopy})
+		assert.NoError(t, err)
+
+		cp.TryProposeChunk() // Each call creates one chunk with one block
+	}
+
+	// Create batch proposer with 4MB uncompressed batch bytes limit
+	// Each chunk is ~3MB, so 1 chunk (~3MB) should fit, but 2 chunks (~6MB) should exceed limit
+	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxChunksPerBatch:             math.MaxInt32,   // No chunk count limit
+		BatchTimeoutSec:               math.MaxUint32,  // No timeout limit
+		MaxUncompressedBatchBytesSize: 4 * 1024 * 1024, // 4MB limit
+	}, encoding.CodecV8, chainConfig, db, nil)
+
+	bp.TryProposeBatch()
+
+	// Check that a batch was created
+	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
+	assert.NoError(t, err)
+	assert.Len(t, batches, 2) // genesis batch + 1 new batch
+
+	// Verify that the batch contains only 1 chunk (not 2) due to uncompressed batch bytes limit
+	newBatch := batches[1] // Skip genesis batch
+	assert.Equal(t, uint64(1), newBatch.StartChunkIndex)
+	assert.Equal(t, uint64(1), newBatch.EndChunkIndex) // Should only include chunk 1
+
+	// Verify that the second chunk is still available for next batch
+	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 2, 0)
+	assert.NoError(t, err)
+	assert.Len(t, chunks, 1)                 // Second chunk should still be available
+	assert.Equal(t, "", chunks[0].BatchHash) // Should not be assigned to any batch yet
+}

rollup/internal/controller/watcher/chunk_proposer_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/common/math"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/params"
@@ -155,3 +156,76 @@ func testChunkProposerBlobSizeLimitCodecV7(t *testing.T) {
 		assert.Equal(t, expected, chunk.EndBlockNumber)
 	}
 }
+
+func testChunkProposerUncompressedBatchBytesLimitCodecV8(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	// Create a block with very large calldata to test uncompressed batch bytes limit
+	block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+
+	// Create a transaction with large calldata (around 3MB)
+	largeCalldata := make([]byte, 3*1024*1024) // 3MB calldata
+	for i := range largeCalldata {
+		largeCalldata[i] = byte(i % 256)
+	}
+
+	// Modify the block to have a transaction with large calldata
+	block.Transactions[0].Data = "0x" + common.Bytes2Hex(largeCalldata)
+
+	// Insert two identical blocks with large calldata
+	l2BlockOrm := orm.NewL2Block(db)
+	for i := uint64(0); i < 2; i++ {
+		blockCopy := *block
+		blockCopy.Header = &gethTypes.Header{}
+		*blockCopy.Header = *block.Header
+		blockCopy.Header.Number = new(big.Int).SetUint64(i + 1)
+		blockCopy.Header.Time = i + 1
+		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{&blockCopy})
+		assert.NoError(t, err)
+	}
+
+	// Add genesis chunk
+	chunkOrm := orm.NewChunk(db)
+	_, err := chunkOrm.InsertChunk(context.Background(), &encoding.Chunk{Blocks: []*encoding.Block{{Header: &gethTypes.Header{Number: big.NewInt(0)}}}}, encoding.CodecV0, utils.ChunkMetrics{})
+	assert.NoError(t, err)
+
+	chainConfig := &params.ChainConfig{
+		LondonBlock:    big.NewInt(0),
+		BernoulliBlock: big.NewInt(0),
+		CurieBlock:     big.NewInt(0),
+		DarwinTime:     new(uint64),
+		DarwinV2Time:   new(uint64),
+		EuclidTime:     new(uint64),
+		EuclidV2Time:   new(uint64),
+		FeynmanTime:    new(uint64),
+	}
+
+	// Set max_uncompressed_batch_bytes_size to 4MB (4 * 1024 * 1024)
+	// One block (~3MB) should fit, but two blocks (~6MB) should exceed the limit
+	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:           math.MaxUint64,  // No block number limit
+		MaxL2GasPerChunk:              math.MaxUint64,  // No gas limit
+		ChunkTimeoutSec:               math.MaxUint32,  // No timeout limit
+		MaxUncompressedBatchBytesSize: 4 * 1024 * 1024, // 4MB limit
+	}, encoding.CodecV8, chainConfig, db, nil)
+
+	// Try to propose chunk
+	cp.TryProposeChunk()
+
+	// Check that a chunk was created
+	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 1, 0)
+	assert.NoError(t, err)
+	assert.Len(t, chunks, 1)
+
+	// Verify that the chunk contains only 1 block (not 2) due to uncompressed batch bytes limit
+	chunk := chunks[0]
+	assert.Equal(t, uint64(1), chunk.StartBlockNumber)
+	assert.Equal(t, uint64(1), chunk.EndBlockNumber)
+
+	// Verify that the second block is still available for next chunk
+	blockOrm := orm.NewL2Block(db)
+	blocks, err := blockOrm.GetL2BlocksGEHeight(context.Background(), 2, 0)
+	assert.NoError(t, err)
+	assert.Len(t, blocks, 1) // Second block should still be available
+}

rollup/internal/controller/watcher/watcher_test.go

@@ -103,11 +103,13 @@ func TestFunction(t *testing.T) {
 	// Run chunk proposer test cases.
 	t.Run("TestChunkProposerLimitsCodecV7", testChunkProposerLimitsCodecV7)
 	t.Run("TestChunkProposerBlobSizeLimitCodecV7", testChunkProposerBlobSizeLimitCodecV7)
+	t.Run("TestChunkProposerUncompressedBatchBytesLimitCodecV8", testChunkProposerUncompressedBatchBytesLimitCodecV8)
 
 	// Run batch proposer test cases.
 	t.Run("TestBatchProposerLimitsCodecV7", testBatchProposerLimitsCodecV7)
 	t.Run("TestBatchProposerBlobSizeLimitCodecV7", testBatchProposerBlobSizeLimitCodecV7)
 	t.Run("TestBatchProposerMaxChunkNumPerBatchLimitCodecV7", testBatchProposerMaxChunkNumPerBatchLimitCodecV7)
+	t.Run("TestBatchProposerUncompressedBatchBytesLimitCodecV8", testBatchProposerUncompressedBatchBytesLimitCodecV8)
 
 	// Run bundle proposer test cases.
 	t.Run("TestBundleProposerLimitsCodecV7", testBundleProposerLimitsCodecV7)