Merge branch 'develop' into fix-row-estimation

core/blockchain_test.go

@@ -3353,6 +3353,8 @@ func TestL1MessageValidationFailure(t *testing.T) {
 	// initialize genesis
 	config := params.AllEthashProtocolChanges
 	config.Scroll.L1Config.NumL1MessagesPerBlock = 1
+	maxPayload := 1024
+	config.Scroll.MaxTxPayloadBytesPerBlock = &maxPayload
 
 	genspec := &Genesis{
 		Config: config,
@@ -3365,7 +3367,10 @@ func TestL1MessageValidationFailure(t *testing.T) {
 
 	// initialize L1 message DB
 	msgs := []types.L1MessageTx{
-		{QueueIndex: 0, Gas: 21016, To: &common.Address{1}, Data: []byte{0x01}, Sender: common.Address{2}},
+		// large L1 message, should not count against block payload limit
+		{QueueIndex: 0, Gas: 25100, To: &common.Address{1}, Data: make([]byte, 1025), Sender: common.Address{2}},
+
+		// normal L1 messages
 		{QueueIndex: 1, Gas: 21016, To: &common.Address{1}, Data: []byte{0x01}, Sender: common.Address{2}},
 		{QueueIndex: 2, Gas: 21016, To: &common.Address{1}, Data: []byte{0x01}, Sender: common.Address{2}},
 	}

core/types/block.go

@@ -335,7 +335,9 @@ func (b *Block) PayloadSize() common.StorageSize {
 	// add up all txs sizes
 	var totalSize common.StorageSize
 	for _, tx := range b.transactions {
-		totalSize += tx.Size()
+		if !tx.IsL1MessageTx() {
+			totalSize += tx.Size()
+		}
 	}
 	return totalSize
 }

miner/worker.go

@@ -970,11 +970,6 @@ loop:
 			}
 			return atomic.LoadInt32(interrupt) == commitInterruptNewHead, circuitCapacityReached
 		}
-		// If we have collected enough transactions then we're done
-		if !w.chainConfig.Scroll.IsValidL2TxCount(w.current.tcount - w.current.l1TxCount + 1) {
-			log.Trace("Transaction count limit reached", "have", w.current.tcount-w.current.l1TxCount, "want", w.chainConfig.Scroll.MaxTxPerBlock)
-			break
-		}
 		// If we don't have enough gas for any further transactions then we're done
 		if w.current.gasPool.Gas() < params.TxGas {
 			log.Trace("Not enough gas for further transactions", "have", w.current.gasPool, "want", params.TxGas)
@@ -985,6 +980,15 @@ loop:
 		if tx == nil {
 			break
 		}
+		// If we have collected enough transactions then we're done
+		l2TxCount := w.current.tcount - w.current.l1TxCount
+		if !tx.IsL1MessageTx() { // If the next tx is not L1MessageTx type then +1.
+			l2TxCount++
+		}
+		if !w.chainConfig.Scroll.IsValidL2TxCount(l2TxCount) {
+			log.Trace("Transaction count limit reached", "have", w.current.tcount-w.current.l1TxCount, "want", w.chainConfig.Scroll.MaxTxPerBlock)
+			break
+		}
 		if tx.IsL1MessageTx() && tx.AsL1MessageTx().QueueIndex != w.current.nextL1MsgIndex {
 			log.Error(
 				"Unexpected L1 message queue index in worker",
@@ -999,7 +1003,7 @@ loop:
 			continue
 		}
 		// Error may be ignored here. The error has already been checked
-		// during transaction acceptance is the transaction pool.
+		// during transaction acceptance in the transaction pool.
 		//
 		// We use the eip155 signer regardless of the current hf.
 		from, _ := types.Sender(w.current.signer, tx)
@@ -1046,15 +1050,18 @@ loop:
 		case errors.Is(err, nil):
 			// Everything ok, collect the logs and shift in the next transaction from the same account
 			coalescedLogs = append(coalescedLogs, logs...)
+			w.current.tcount++
+			txs.Shift()
+
 			if tx.IsL1MessageTx() {
 				queueIndex := tx.AsL1MessageTx().QueueIndex
 				log.Debug("Including L1 message", "queueIndex", queueIndex, "tx", tx.Hash().String())
 				w.current.l1TxCount++
 				w.current.nextL1MsgIndex = queueIndex + 1
+			} else {
+				// only consider block size limit for L2 transactions
+				w.current.blockSize += tx.Size()
 			}
-			w.current.tcount++
-			w.current.blockSize += tx.Size()
-			txs.Shift()
 
 		case errors.Is(err, core.ErrTxTypeNotSupported):
 			// Pop the unsupported transaction without shifting in the next from the account

miner/worker_test.go

@@ -895,13 +895,13 @@ func TestLargeL1MessageSkipPayloadCheck(t *testing.T) {
 		{QueueIndex: 2, Gas: 21016, To: &common.Address{1}, Data: []byte{0x01}, Sender: common.Address{3}}, // different sender
 	}
 
-	l1MessageTest(t, msgs, false, func(blockNum int, block *types.Block, db ethdb.Database, w *worker) bool {
+	l1MessageTest(t, msgs, true, func(blockNum int, block *types.Block, db ethdb.Database, w *worker) bool {
 		switch blockNum {
 		case 0:
 			return false
 		case 1:
-			// include #0, #1 and #2
-			assert.Equal(3, len(block.Transactions()))
+			// include #0, #1 and #2 + one L2 tx
+			assert.Equal(4, len(block.Transactions()))
 
 			assert.True(block.Transactions()[0].IsL1MessageTx())
 			assert.Equal(uint64(0), block.Transactions()[0].AsL1MessageTx().QueueIndex)
@@ -910,6 +910,10 @@ func TestLargeL1MessageSkipPayloadCheck(t *testing.T) {
 			assert.True(block.Transactions()[2].IsL1MessageTx())
 			assert.Equal(uint64(2), block.Transactions()[2].AsL1MessageTx().QueueIndex)
 
+			// since L1 messages do not count against the block size limit,
+			// we can include additional L2 transaction
+			assert.False(block.Transactions()[3].IsL1MessageTx())
+
 			// db is updated correctly
 			queueIndex := rawdb.ReadFirstQueueIndexNotInL2Block(db, block.Hash())
 			assert.NotNil(queueIndex)

params/version.go

@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 4         // Major version component of the current release
 	VersionMinor = 3         // Minor version component of the current release
-	VersionPatch = 46        // Patch version component of the current release
+	VersionPatch = 48        // Patch version component of the current release
 	VersionMeta  = "sepolia" // Version metadata to append to the version string
 )