Merge branch 'update-20251114115614' into develop

Author: nebojsa94

core/rawdb/accessors_rollup_event.go

@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/scroll-tech/da-codec/encoding"
-
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/ethdb"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rlp"

da-codec/encoding/bitmap.go

@@ -0,0 +1,92 @@
+package encoding
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/scroll-tech/go-ethereum/core/types"
+)
+
+// constructSkippedBitmap constructs skipped L1 message bitmap of the batch.
+func constructSkippedBitmap(batchIndex uint64, chunks []*Chunk, totalL1MessagePoppedBefore uint64) ([]byte, uint64, error) {
+	// skipped L1 message bitmap, an array of 256-bit bitmaps
+	var skippedBitmap []*big.Int
+
+	// the first queue index that belongs to this batch
+	baseIndex := totalL1MessagePoppedBefore
+
+	// the next queue index that we need to process
+	nextIndex := totalL1MessagePoppedBefore
+
+	for chunkID, chunk := range chunks {
+		for blockID, block := range chunk.Blocks {
+			for _, tx := range block.Transactions {
+				if tx.Type != types.L1MessageTxType {
+					continue
+				}
+
+				currentIndex := tx.Nonce
+
+				if currentIndex < nextIndex {
+					return nil, 0, fmt.Errorf("unexpected batch payload, expected queue index: %d, got: %d. Batch index: %d, chunk index in batch: %d, block index in chunk: %d, block hash: %v, transaction hash: %v", nextIndex, currentIndex, batchIndex, chunkID, blockID, block.Header.Hash(), tx.TxHash)
+				}
+
+				// mark skipped messages
+				for skippedIndex := nextIndex; skippedIndex < currentIndex; skippedIndex++ {
+					quo := int((skippedIndex - baseIndex) / 256)
+					rem := int((skippedIndex - baseIndex) % 256)
+					for len(skippedBitmap) <= quo {
+						bitmap := big.NewInt(0)
+						skippedBitmap = append(skippedBitmap, bitmap)
+					}
+					skippedBitmap[quo].SetBit(skippedBitmap[quo], rem, 1)
+				}
+
+				// process included message
+				quo := int((currentIndex - baseIndex) / 256)
+				for len(skippedBitmap) <= quo {
+					bitmap := big.NewInt(0)
+					skippedBitmap = append(skippedBitmap, bitmap)
+				}
+
+				nextIndex = currentIndex + 1
+			}
+		}
+	}
+
+	skippedL1MessageBitmap := make([]byte, len(skippedBitmap)*skippedL1MessageBitmapByteSize)
+	for ii, num := range skippedBitmap {
+		bytes := num.Bytes()
+		padding := skippedL1MessageBitmapByteSize - len(bytes)
+		copy(skippedL1MessageBitmap[skippedL1MessageBitmapByteSize*ii+padding:], bytes)
+	}
+
+	return skippedL1MessageBitmap, nextIndex, nil
+}
+
+// DecodeBitmap decodes skipped L1 message bitmap of the batch from bytes to big.Int's.
+func DecodeBitmap(skippedL1MessageBitmap []byte, totalL1MessagePopped int) ([]*big.Int, error) {
+	length := len(skippedL1MessageBitmap)
+	if length%skippedL1MessageBitmapByteSize != 0 {
+		return nil, fmt.Errorf("skippedL1MessageBitmap length doesn't match, skippedL1MessageBitmap length should be equal 0 modulo %v, length of skippedL1MessageBitmap: %v", skippedL1MessageBitmapByteSize, length)
+	}
+	if length*8 < totalL1MessagePopped {
+		return nil, fmt.Errorf("skippedL1MessageBitmap length is too small, skippedL1MessageBitmap length should be at least %v, length of skippedL1MessageBitmap: %v", (totalL1MessagePopped+7)/8, length)
+	}
+	var skippedBitmap []*big.Int
+	for index := 0; index < length/skippedL1MessageBitmapByteSize; index++ {
+		bitmap := big.NewInt(0).SetBytes(skippedL1MessageBitmap[index*skippedL1MessageBitmapByteSize : index*skippedL1MessageBitmapByteSize+skippedL1MessageBitmapByteSize])
+		skippedBitmap = append(skippedBitmap, bitmap)
+	}
+	return skippedBitmap, nil
+}
+
+// IsL1MessageSkipped checks if the L1 message at the given index is skipped.
+func IsL1MessageSkipped(skippedBitmap []*big.Int, index uint64) bool {
+	if index >= uint64(len(skippedBitmap))*256 {
+		return false
+	}
+	quo := index / 256
+	rem := index % 256
+	return skippedBitmap[quo].Bit(int(rem)) == 1
+}

da-codec/encoding/bitmap_test.go

@@ -0,0 +1,34 @@
+package encoding
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDecodeBitmap(t *testing.T) {
+	bitmapHex := "0000000000000000000000000000000000000000000000000000001ffffffbff"
+	skippedL1MessageBitmap, err := hex.DecodeString(bitmapHex)
+	assert.NoError(t, err)
+
+	decodedBitmap, err := DecodeBitmap(skippedL1MessageBitmap, 42)
+	assert.NoError(t, err)
+
+	assert.True(t, IsL1MessageSkipped(decodedBitmap, 0))
+	assert.True(t, IsL1MessageSkipped(decodedBitmap, 9))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 10))
+	assert.True(t, IsL1MessageSkipped(decodedBitmap, 11))
+	assert.True(t, IsL1MessageSkipped(decodedBitmap, 36))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 37))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 38))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 39))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 40))
+	assert.False(t, IsL1MessageSkipped(decodedBitmap, 41))
+
+	_, err = DecodeBitmap([]byte{0x00}, 8)
+	assert.Error(t, err)
+
+	_, err = DecodeBitmap([]byte{0x00, 0x00, 0x00, 0x00}, 33)
+	assert.Error(t, err)
+}