fix(bridge-history+rollup-relayer): update da-codec to prevent zstd deadlock (#1724)

Co-authored-by: yiweichi <yiweichi@users.noreply.github.com>
Co-authored-by: Péter Garamvölgyi <peter@scroll.io>

bridge-history-api/go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/pressly/goose/v3 v3.16.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
+	github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7

bridge-history-api/go.sum

@@ -309,8 +309,8 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 h1:EiLZgoRfGgF0QzZ1jGSlo60A6W7g9L/8XLWMhwwtKJ0=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 h1:u371VK8eOU2Z/0SVf5KDI3eJc8msHSpJbav4do/8n38=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

bridge-history-api/internal/config/config.go

@@ -38,6 +38,7 @@ type FetcherConfig struct {
 	BeaconNodeAPIEndpoint  string `json:"BeaconNodeAPIEndpoint"`
 	BlobScanAPIEndpoint    string `json:"BlobScanAPIEndpoint"`
 	BlockNativeAPIEndpoint string `json:"BlockNativeAPIEndpoint"`
+	AwsS3Endpoint          string `json:"AwsS3Endpoint"`
 }
 
 // RedisConfig redis config

bridge-history-api/internal/controller/fetcher/l1_fetcher.go

@@ -39,6 +39,9 @@ type L1MessageFetcher struct {
 // NewL1MessageFetcher creates a new L1MessageFetcher instance.
 func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) (*L1MessageFetcher, error) {
 	blobClient := blob_client.NewBlobClients()
+	if cfg.AwsS3Endpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewAwsS3Client(cfg.AwsS3Endpoint))
+	}
 	if cfg.BeaconNodeAPIEndpoint != "" {
 		beaconNodeClient, err := blob_client.NewBeaconNodeClient(cfg.BeaconNodeAPIEndpoint)
 		if err != nil {

common/go.mod

@@ -15,7 +15,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587
 	github.com/stretchr/testify v1.10.0
 	github.com/testcontainers/testcontainers-go v0.30.0
 	github.com/testcontainers/testcontainers-go/modules/compose v0.30.0
@@ -184,7 +184,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 // indirect
+	github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/secure-systems-lab/go-securesystemslib v0.4.0 // indirect
 	github.com/serialx/hashring v0.0.0-20190422032157-8b2912629002 // indirect

common/go.sum

@@ -636,10 +636,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 h1:EiLZgoRfGgF0QzZ1jGSlo60A6W7g9L/8XLWMhwwtKJ0=
-github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587 h1:wG1+gb+K4iLtxAHhiAreMdIjP5x9hB64duraN2+u1QU=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587/go.mod h1:YyfB2AyAtphlbIuDQgaxc2b9mo0zE4EBA1+qtXvzlmg=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.5.38"
+var tag = "v4.5.42"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/go.mod

@@ -9,7 +9,7 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
+	github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.10.0

coordinator/go.sum

@@ -253,8 +253,8 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 h1:EiLZgoRfGgF0QzZ1jGSlo60A6W7g9L/8XLWMhwwtKJ0=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

go.work.sum

@@ -1408,13 +1408,12 @@ github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd h1:NUol+dPt
 github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148 h1:cyK1ifU2fRoMl8YWR9LOsZK4RvJnlG3RODgakj5I8VY=
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
+github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240607130425-e2becce6a1a4/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240821074444-b3fa00861e5e/go.mod h1:swB5NSp8pKNDuYsTxfR08bHS6L56i119PBx8fxvV8Cs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20241010064814-3d88e870ae22/go.mod h1:r9FwtxCtybMkTbWYCyBuevT9TW3zHmOTHqD082Uh+Oo=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250206083728-ea43834c198f/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250225152658-bcfdb48dd939/go.mod h1:AgU8JJxC7+nfs7R7ma35AU7dMAGW7wCw3dRZRefIKyQ=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 h1:u371VK8eOU2Z/0SVf5KDI3eJc8msHSpJbav4do/8n38=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=

rollup/go.mod

@@ -15,7 +15,7 @@ require (
 	github.com/holiman/uint256 v1.3.2
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
+	github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0

rollup/go.sum

@@ -285,8 +285,8 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 h1:EiLZgoRfGgF0QzZ1jGSlo60A6W7g9L/8XLWMhwwtKJ0=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

rollup/internal/controller/relayer/l2_relayer.go

@@ -290,6 +290,12 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 		log.Info("Validium importGenesis", "calldata", common.Bytes2Hex(calldata))
 	} else {
 		// rollup mode: pass batchHeader and stateRoot
+
+		// Check state root is not zero
+		if stateRoot == (common.Hash{}) {
+			return fmt.Errorf("state root is zero")
+		}
+
 		calldata, packErr = r.l1RollupABI.Pack("importGenesisBatch", batchHeader, stateRoot)
 		if packErr != nil {
 			return fmt.Errorf("failed to pack rollup importGenesisBatch with batch header: %v and state root: %v. error: %v", common.Bytes2Hex(batchHeader), stateRoot, packErr)
@@ -388,8 +394,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		// return if not hitting target price
 		if skip {
 			log.Debug("Skipping batch submission", "first batch index", dbBatches[0].Index, "backlog count", backlogCount, "reason", err)
-			log.Debug("first batch index", dbBatches[0].Index)
-			log.Debug("backlog count", backlogCount)
 			return
 		}
 		if err != nil {
@@ -502,6 +506,11 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 				log.Error("failed to construct normal payload", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "err", err)
 				return
 			}
+
+			if err = r.sanityChecksCommitBatchCodecV7CalldataAndBlobs(calldata, blobs); err != nil {
+				log.Error("Sanity check failed for calldata and blobs", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "err", err)
+				return
+			}
 		}
 	default:
 		log.Error("unsupported codec version in ProcessPendingBatches", "codecVersion", codecVersion, "start index", firstBatch, "end index", lastBatch.Index)
@@ -999,6 +1008,18 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*db
 }
 
 func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithChunks) ([]byte, uint64, uint64, error) {
+	// Check state root is not zero
+	stateRoot := common.HexToHash(batch.Batch.StateRoot)
+	if stateRoot == (common.Hash{}) {
+		return nil, 0, 0, fmt.Errorf("batch %d state root is zero", batch.Batch.Index)
+	}
+
+	// Check parent batch hash is not zero
+	parentBatchHash := common.HexToHash(batch.Batch.ParentBatchHash)
+	if parentBatchHash == (common.Hash{}) {
+		return nil, 0, 0, fmt.Errorf("batch %d parent batch hash is zero", batch.Batch.Index)
+	}
+
 	// Calculate metrics
 	var maxBlockHeight uint64
 	var totalGasUsed uint64
@@ -1018,6 +1039,7 @@ func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithCh
 
 	lastChunk := batch.Chunks[len(batch.Chunks)-1]
 	commitment := common.HexToHash(lastChunk.EndBlockHash)
+
 	version := encoding.CodecVersion(batch.Batch.CodecVersion)
 	calldata, err := r.validiumABI.Pack("commitBatch", version, common.HexToHash(batch.Batch.ParentBatchHash), common.HexToHash(batch.Batch.StateRoot), common.HexToHash(batch.Batch.WithdrawRoot), commitment[:])
 	if err != nil {
@@ -1028,6 +1050,12 @@ func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithCh
 }
 
 func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch, endChunk *orm.Chunk, aggProof *message.OpenVMBundleProof) ([]byte, error) {
+	// Check state root is not zero
+	stateRoot := common.HexToHash(dbBatch.StateRoot)
+	if stateRoot == (common.Hash{}) {
+		return nil, fmt.Errorf("batch %d state root is zero", dbBatch.Index)
+	}
+
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
 			"finalizeBundlePostEuclidV2",

rollup/internal/controller/relayer/l2_relayer_sanity.go

@@ -0,0 +1,487 @@
+package relayer
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+
+	"scroll-tech/rollup/internal/orm"
+)
+
+// sanityChecksCommitBatchCodecV7CalldataAndBlobs performs comprehensive validation of the constructed
+// transaction data (calldata and blobs) by parsing them and comparing against database records.
+// This ensures the constructed transaction data is correct and consistent with the database state.
+func (r *Layer2Relayer) sanityChecksCommitBatchCodecV7CalldataAndBlobs(calldata []byte, blobs []*kzg4844.Blob) error {
+	if r.l1RollupABI == nil {
+		return fmt.Errorf("l1RollupABI is nil: cannot parse commitBatches calldata")
+	}
+	calldataInfo, err := parseCommitBatchesCalldata(r.l1RollupABI, calldata)
+	if err != nil {
+		return fmt.Errorf("failed to parse calldata: %w", err)
+	}
+
+	batchesToValidate, l1MessagesWithBlockNumbers, err := r.getBatchesFromCalldata(calldataInfo)
+	if err != nil {
+		return fmt.Errorf("failed to get batches from database: %w", err)
+	}
+
+	if err := r.validateCalldataAndBlobsAgainstDatabase(calldataInfo, blobs, batchesToValidate, l1MessagesWithBlockNumbers); err != nil {
+		return fmt.Errorf("calldata and blobs validation failed: %w", err)
+	}
+
+	if err := r.validateDatabaseConsistency(batchesToValidate); err != nil {
+		return fmt.Errorf("database consistency validation failed: %w", err)
+	}
+
+	return nil
+}
+
+// CalldataInfo holds parsed information from commitBatches calldata
+type CalldataInfo struct {
+	Version         uint8
+	ParentBatchHash common.Hash
+	LastBatchHash   common.Hash
+}
+
+// parseCommitBatchesCalldata parses the commitBatches calldata and extracts key information
+func parseCommitBatchesCalldata(abi *abi.ABI, calldata []byte) (*CalldataInfo, error) {
+	method := abi.Methods["commitBatches"]
+	decoded, err := method.Inputs.Unpack(calldata[4:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to unpack commitBatches calldata: %w", err)
+	}
+
+	if len(decoded) != 3 {
+		return nil, fmt.Errorf("unexpected number of decoded parameters: got %d, want 3", len(decoded))
+	}
+
+	version, ok := decoded[0].(uint8)
+	if !ok {
+		return nil, fmt.Errorf("failed to type assert version to uint8")
+	}
+
+	parentBatchHashB, ok := decoded[1].([32]uint8)
+	if !ok {
+		return nil, fmt.Errorf("failed to type assert parentBatchHash to [32]uint8")
+	}
+	parentBatchHash := common.BytesToHash(parentBatchHashB[:])
+
+	lastBatchHashB, ok := decoded[2].([32]uint8)
+	if !ok {
+		return nil, fmt.Errorf("failed to type assert lastBatchHash to [32]uint8")
+	}
+	lastBatchHash := common.BytesToHash(lastBatchHashB[:])
+
+	return &CalldataInfo{
+		Version:         version,
+		ParentBatchHash: parentBatchHash,
+		LastBatchHash:   lastBatchHash,
+	}, nil
+}
+
+// getBatchesFromCalldata retrieves the relevant batches from database based on calldata information
+func (r *Layer2Relayer) getBatchesFromCalldata(info *CalldataInfo) ([]*dbBatchWithChunks, map[uint64][]*types.TransactionData, error) {
+	// Get the parent batch to determine the starting point
+	parentBatch, err := r.batchOrm.GetBatchByHash(r.ctx, info.ParentBatchHash.Hex())
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get parent batch by hash %s: %w", info.ParentBatchHash.Hex(), err)
+	}
+
+	// Get the last batch to determine the ending point
+	lastBatch, err := r.batchOrm.GetBatchByHash(r.ctx, info.LastBatchHash.Hex())
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get last batch by hash %s: %w", info.LastBatchHash.Hex(), err)
+	}
+
+	// Get all batches in the range (parent+1 to last)
+	firstBatchIndex := parentBatch.Index + 1
+	lastBatchIndex := lastBatch.Index
+
+	// Check if the range is valid
+	if firstBatchIndex > lastBatchIndex {
+		return nil, nil, fmt.Errorf("no batches found in range: first index %d, last index %d", firstBatchIndex, lastBatchIndex)
+	}
+
+	var batchesToValidate []*dbBatchWithChunks
+	l1MessagesWithBlockNumbers := make(map[uint64][]*types.TransactionData)
+	for batchIndex := firstBatchIndex; batchIndex <= lastBatchIndex; batchIndex++ {
+		dbBatch, err := r.batchOrm.GetBatchByIndex(r.ctx, batchIndex)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to get batch by index %d: %w", batchIndex, err)
+		}
+
+		// Get chunks for this batch
+		dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to get chunks for batch %d: %w", batchIndex, err)
+		}
+
+		batchesToValidate = append(batchesToValidate, &dbBatchWithChunks{
+			Batch:  dbBatch,
+			Chunks: dbChunks,
+		})
+
+		// If there are L1 messages in this batch, retrieve L1 messages with block numbers
+		for _, chunk := range dbChunks {
+			if chunk.TotalL1MessagesPoppedInChunk > 0 {
+				blockWithL1Messages, err := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, chunk.StartBlockNumber, chunk.EndBlockNumber)
+				if err != nil {
+					return nil, nil, fmt.Errorf("failed to get L2 blocks for chunk %d: %w", chunk.Index, err)
+				}
+				var l1MessagesCount uint64
+				for _, block := range blockWithL1Messages {
+					bn := block.Header.Number.Uint64()
+					seenL2 := false
+					for _, tx := range block.Transactions {
+						if tx.Type == types.L1MessageTxType {
+							if seenL2 {
+								// Invariant violated: found an L1 message after an L2 transaction in the same block.
+								return nil, nil, fmt.Errorf("L1 message after L2 transaction in block %d", bn)
+							}
+							l1MessagesWithBlockNumbers[bn] = append(l1MessagesWithBlockNumbers[bn], tx)
+							l1MessagesCount++
+						} else {
+							seenL2 = true
+						}
+					}
+				}
+				if chunk.TotalL1MessagesPoppedInChunk != l1MessagesCount {
+					return nil, nil, fmt.Errorf("chunk %d has inconsistent L1 messages count: expected %d, got %d", chunk.Index, chunk.TotalL1MessagesPoppedInChunk, l1MessagesCount)
+				}
+			}
+		}
+	}
+	return batchesToValidate, l1MessagesWithBlockNumbers, nil
+}
+
+// validateDatabaseConsistency performs comprehensive validation of database records
+func (r *Layer2Relayer) validateDatabaseConsistency(batchesToValidate []*dbBatchWithChunks) error {
+	if len(batchesToValidate) == 0 {
+		return fmt.Errorf("no batches to validate")
+	}
+
+	// Get previous chunk for continuity check
+	firstChunk := batchesToValidate[0].Chunks[0]
+	if firstChunk.Index == 0 {
+		return fmt.Errorf("genesis chunk should not be in normal batch submission flow, chunk index: %d", firstChunk.Index)
+	}
+
+	prevChunk, err := r.chunkOrm.GetChunkByIndex(r.ctx, firstChunk.Index-1)
+	if err != nil {
+		return fmt.Errorf("failed to get previous chunk %d for continuity check: %w", firstChunk.Index-1, err)
+	}
+
+	firstBatchCodecVersion := batchesToValidate[0].Batch.CodecVersion
+	for i, batch := range batchesToValidate {
+		// Validate codec version consistency
+		if batch.Batch.CodecVersion != firstBatchCodecVersion {
+			return fmt.Errorf("batch %d has different codec version %d, expected %d", batch.Batch.Index, batch.Batch.CodecVersion, firstBatchCodecVersion)
+		}
+
+		// Validate individual batch
+		if err := r.validateSingleBatchConsistency(batch, i, batchesToValidate); err != nil {
+			return err
+		}
+
+		// Validate chunks in this batch
+		if err := r.validateBatchChunksConsistency(batch, prevChunk); err != nil {
+			return err
+		}
+
+		// Update prevChunk to the last chunk of this batch for next iteration
+		if len(batch.Chunks) == 0 {
+			return fmt.Errorf("batch %d has no chunks", batch.Batch.Index)
+		}
+		prevChunk = batch.Chunks[len(batch.Chunks)-1]
+	}
+
+	return nil
+}
+
+// validateSingleBatchConsistency validates a single batch's consistency
+func (r *Layer2Relayer) validateSingleBatchConsistency(batch *dbBatchWithChunks, i int, allBatches []*dbBatchWithChunks) error {
+	if batch == nil || batch.Batch == nil {
+		return fmt.Errorf("batch %d is nil", i)
+	}
+
+	if len(batch.Chunks) == 0 {
+		return fmt.Errorf("batch %d has no chunks", batch.Batch.Index)
+	}
+
+	// Validate essential batch fields
+	batchHash := common.HexToHash(batch.Batch.Hash)
+	if batchHash == (common.Hash{}) {
+		return fmt.Errorf("batch %d hash is zero", batch.Batch.Index)
+	}
+
+	if batch.Batch.Index == 0 {
+		return fmt.Errorf("batch %d has zero index (only genesis batch should have index 0)", i)
+	}
+
+	parentBatchHash := common.HexToHash(batch.Batch.ParentBatchHash)
+	if parentBatchHash == (common.Hash{}) {
+		return fmt.Errorf("batch %d parent batch hash is zero", batch.Batch.Index)
+	}
+
+	stateRoot := common.HexToHash(batch.Batch.StateRoot)
+	if stateRoot == (common.Hash{}) {
+		return fmt.Errorf("batch %d state root is zero", batch.Batch.Index)
+	}
+
+	// Check batch index continuity
+	if i > 0 {
+		prevBatch := allBatches[i-1]
+		if batch.Batch.Index != prevBatch.Batch.Index+1 {
+			return fmt.Errorf("batch index is not sequential: prev batch index %d, current batch index %d", prevBatch.Batch.Index, batch.Batch.Index)
+		}
+		if parentBatchHash != common.HexToHash(prevBatch.Batch.Hash) {
+			return fmt.Errorf("parent batch hash does not match previous batch hash: expected %s, got %s", prevBatch.Batch.Hash, batch.Batch.ParentBatchHash)
+		}
+	} else {
+		// For the first batch, verify continuity with parent batch from database
+		parentBatch, err := r.batchOrm.GetBatchByHash(r.ctx, batch.Batch.ParentBatchHash)
+		if err != nil {
+			return fmt.Errorf("failed to get parent batch %s for batch %d: %w", batch.Batch.ParentBatchHash, batch.Batch.Index, err)
+		}
+		if batch.Batch.Index != parentBatch.Index+1 {
+			return fmt.Errorf("first batch index is not sequential with parent: parent batch index %d, current batch index %d", parentBatch.Index, batch.Batch.Index)
+		}
+	}
+
+	// Validate L1 message queue consistency
+	if err := r.validateMessageQueueConsistency(batch.Batch.Index, batch.Chunks, common.HexToHash(batch.Batch.PrevL1MessageQueueHash), common.HexToHash(batch.Batch.PostL1MessageQueueHash)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// validateBatchChunksConsistency validates chunks within a batch
+func (r *Layer2Relayer) validateBatchChunksConsistency(batch *dbBatchWithChunks, prevChunk *orm.Chunk) error {
+	// Check codec version consistency between chunks and batch
+	for _, chunk := range batch.Chunks {
+		if chunk.CodecVersion != batch.Batch.CodecVersion {
+			return fmt.Errorf("batch %d chunk %d has different codec version %d, expected %d", batch.Batch.Index, chunk.Index, chunk.CodecVersion, batch.Batch.CodecVersion)
+		}
+	}
+
+	// Validate each chunk individually
+	currentPrevChunk := prevChunk
+	for j, chunk := range batch.Chunks {
+		if err := r.validateSingleChunkConsistency(chunk, currentPrevChunk); err != nil {
+			return fmt.Errorf("batch %d chunk %d: %w", batch.Batch.Index, j, err)
+		}
+		currentPrevChunk = chunk
+	}
+
+	return nil
+}
+
+// validateSingleChunkConsistency validates a single chunk
+func (r *Layer2Relayer) validateSingleChunkConsistency(chunk *orm.Chunk, prevChunk *orm.Chunk) error {
+	if chunk == nil {
+		return fmt.Errorf("chunk is nil")
+	}
+
+	chunkHash := common.HexToHash(chunk.Hash)
+	if chunkHash == (common.Hash{}) {
+		return fmt.Errorf("chunk %d hash is zero", chunk.Index)
+	}
+
+	// Check chunk index continuity
+	if chunk.Index != prevChunk.Index+1 {
+		return fmt.Errorf("chunk index is not sequential: prev chunk index %d, current chunk index %d", prevChunk.Index, chunk.Index)
+	}
+
+	// Validate block range
+	if chunk.StartBlockNumber == 0 && chunk.EndBlockNumber == 0 {
+		return fmt.Errorf("chunk %d has zero block range", chunk.Index)
+	}
+
+	if chunk.StartBlockNumber > chunk.EndBlockNumber {
+		return fmt.Errorf("chunk %d has invalid block range: start %d > end %d", chunk.Index, chunk.StartBlockNumber, chunk.EndBlockNumber)
+	}
+
+	// Check hash fields
+	startBlockHash := common.HexToHash(chunk.StartBlockHash)
+	if startBlockHash == (common.Hash{}) {
+		return fmt.Errorf("chunk %d start block hash is zero", chunk.Index)
+	}
+
+	endBlockHash := common.HexToHash(chunk.EndBlockHash)
+	if endBlockHash == (common.Hash{}) {
+		return fmt.Errorf("chunk %d end block hash is zero", chunk.Index)
+	}
+
+	// Check block continuity with previous chunk
+	if prevChunk.EndBlockNumber+1 != chunk.StartBlockNumber {
+		return fmt.Errorf("chunk is not continuous with previous chunk %d: prev end block %d, current start block %d", prevChunk.Index, prevChunk.EndBlockNumber, chunk.StartBlockNumber)
+	}
+
+	// Check L1 messages continuity
+	expectedPoppedBefore := prevChunk.TotalL1MessagesPoppedBefore + prevChunk.TotalL1MessagesPoppedInChunk
+	if chunk.TotalL1MessagesPoppedBefore != expectedPoppedBefore {
+		return fmt.Errorf("L1 messages popped before is incorrect: expected %d, got %d", expectedPoppedBefore, chunk.TotalL1MessagesPoppedBefore)
+	}
+
+	return nil
+}
+
+// validateCalldataAndBlobsAgainstDatabase validates calldata and blobs against database records
+func (r *Layer2Relayer) validateCalldataAndBlobsAgainstDatabase(calldataInfo *CalldataInfo, blobs []*kzg4844.Blob, batchesToValidate []*dbBatchWithChunks, l1MessagesWithBlockNumbers map[uint64][]*types.TransactionData) error {
+	// Validate blobs
+	if len(blobs) == 0 {
+		return fmt.Errorf("no blobs provided")
+	}
+
+	// Validate blob count
+	if len(blobs) != len(batchesToValidate) {
+		return fmt.Errorf("blob count mismatch: got %d blobs, expected %d batches", len(blobs), len(batchesToValidate))
+	}
+
+	// Get first and last batches for validation, length check is already done above
+	firstBatch := batchesToValidate[0].Batch
+	lastBatch := batchesToValidate[len(batchesToValidate)-1].Batch
+
+	// Validate codec version
+	if calldataInfo.Version != uint8(firstBatch.CodecVersion) {
+		return fmt.Errorf("version mismatch: calldata=%d, db=%d", calldataInfo.Version, firstBatch.CodecVersion)
+	}
+
+	// Validate parent batch hash
+	if calldataInfo.ParentBatchHash != common.HexToHash(firstBatch.ParentBatchHash) {
+		return fmt.Errorf("parentBatchHash mismatch: calldata=%s, db=%s", calldataInfo.ParentBatchHash.Hex(), firstBatch.ParentBatchHash)
+	}
+
+	// Validate last batch hash
+	if calldataInfo.LastBatchHash != common.HexToHash(lastBatch.Hash) {
+		return fmt.Errorf("lastBatchHash mismatch: calldata=%s, db=%s", calldataInfo.LastBatchHash.Hex(), lastBatch.Hash)
+	}
+
+	// Get codec for blob decoding
+	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(firstBatch.CodecVersion))
+	if err != nil {
+		return fmt.Errorf("failed to get codec: %w", err)
+	}
+
+	// Validate each blob against its corresponding batch
+	for i, blob := range blobs {
+		dbBatch := batchesToValidate[i].Batch
+		if err := r.validateSingleBlobAgainstBatch(blob, dbBatch, codec, l1MessagesWithBlockNumbers); err != nil {
+			return fmt.Errorf("blob validation failed for batch %d: %w", dbBatch.Index, err)
+		}
+	}
+
+	return nil
+}
+
+// validateSingleBlobAgainstBatch validates a single blob against its batch data
+func (r *Layer2Relayer) validateSingleBlobAgainstBatch(blob *kzg4844.Blob, dbBatch *orm.Batch, codec encoding.Codec, l1MessagesWithBlockNumbers map[uint64][]*types.TransactionData) error {
+	// Decode blob payload
+	payload, err := codec.DecodeBlob(blob)
+	if err != nil {
+		return fmt.Errorf("failed to decode blob: %w", err)
+	}
+
+	// Validate batch hash
+	daBatch, err := assembleDABatchFromPayload(payload, dbBatch, codec, l1MessagesWithBlockNumbers)
+	if err != nil {
+		return fmt.Errorf("failed to assemble batch from payload: %w", err)
+	}
+
+	if daBatch.Hash() != common.HexToHash(dbBatch.Hash) {
+		return fmt.Errorf("batch hash mismatch: decoded from blob=%s, db=%s", daBatch.Hash().Hex(), dbBatch.Hash)
+	}
+
+	return nil
+}
+
+// validateMessageQueueConsistency validates L1 message queue hash consistency
+func (r *Layer2Relayer) validateMessageQueueConsistency(batchIndex uint64, chunks []*orm.Chunk, prevL1MsgQueueHash common.Hash, postL1MsgQueueHash common.Hash) error {
+	if len(chunks) == 0 {
+		return fmt.Errorf("batch %d has no chunks for message queue validation", batchIndex)
+	}
+
+	firstChunk := chunks[0]
+	lastChunk := chunks[len(chunks)-1]
+
+	// Calculate total L1 messages in this batch
+	var totalL1MessagesInBatch uint64
+	for _, chunk := range chunks {
+		totalL1MessagesInBatch += chunk.TotalL1MessagesPoppedInChunk
+	}
+
+	// If there were L1 messages processed before this batch, prev hash should not be zero
+	if firstChunk.TotalL1MessagesPoppedBefore > 0 && prevL1MsgQueueHash == (common.Hash{}) {
+		return fmt.Errorf("batch %d prev L1 message queue hash is zero but %d L1 messages were processed before", batchIndex, firstChunk.TotalL1MessagesPoppedBefore)
+	}
+
+	// If there are any L1 messages processed up to this batch, post hash should not be zero
+	totalL1MessagesProcessed := lastChunk.TotalL1MessagesPoppedBefore + lastChunk.TotalL1MessagesPoppedInChunk
+	if totalL1MessagesProcessed > 0 && postL1MsgQueueHash == (common.Hash{}) {
+		return fmt.Errorf("batch %d post L1 message queue hash is zero but %d L1 messages were processed in total", batchIndex, totalL1MessagesProcessed)
+	}
+
+	// Prev and post queue hashes should be different if L1 messages were processed in this batch
+	if totalL1MessagesInBatch > 0 && prevL1MsgQueueHash == postL1MsgQueueHash {
+		return fmt.Errorf("batch %d has same prev and post L1 message queue hashes but processed %d L1 messages in this batch", batchIndex, totalL1MessagesInBatch)
+	}
+
+	return nil
+}
+
+func assembleDABatchFromPayload(payload encoding.DABlobPayload, dbBatch *orm.Batch, codec encoding.Codec, l1MessagesWithBlockNumbers map[uint64][]*types.TransactionData) (encoding.DABatch, error) {
+	blocks, err := assembleBlocksFromPayload(payload, l1MessagesWithBlockNumbers)
+	if err != nil {
+		return nil, fmt.Errorf("failed to assemble blocks from payload batch_index=%d codec_version=%d parent_batch_hash=%s: %w", dbBatch.Index, dbBatch.CodecVersion, dbBatch.ParentBatchHash, err)
+	}
+	batch := &encoding.Batch{
+		Index:                  dbBatch.Index,                             // The database provides only batch index, other fields are derived from blob payload
+		ParentBatchHash:        common.HexToHash(dbBatch.ParentBatchHash), // The first batch's parent hash is verified with calldata, subsequent batches are linked via dbBatch.ParentBatchHash and verified in database consistency checks
+		PrevL1MessageQueueHash: payload.PrevL1MessageQueueHash(),
+		PostL1MessageQueueHash: payload.PostL1MessageQueueHash(),
+		Blocks:                 blocks,
+		Chunks: []*encoding.Chunk{ // One chunk for this batch to pass sanity checks when building DABatch
+			{
+				Blocks:                 blocks,
+				PrevL1MessageQueueHash: payload.PrevL1MessageQueueHash(),
+				PostL1MessageQueueHash: payload.PostL1MessageQueueHash(),
+			},
+		},
+	}
+	daBatch, err := codec.NewDABatch(batch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build DABatch batch_index=%d codec_version=%d parent_batch_hash=%s: %w", dbBatch.Index, dbBatch.CodecVersion, dbBatch.ParentBatchHash, err)
+	}
+	return daBatch, nil
+}
+
+func assembleBlocksFromPayload(payload encoding.DABlobPayload, l1MessagesWithBlockNumbers map[uint64][]*types.TransactionData) ([]*encoding.Block, error) {
+	daBlocks := payload.Blocks()
+	txns := payload.Transactions()
+	if len(daBlocks) != len(txns) {
+		return nil, fmt.Errorf("mismatched number of blocks and transactions: %d blocks, %d transactions", len(daBlocks), len(txns))
+	}
+	blocks := make([]*encoding.Block, len(daBlocks))
+	for i := range daBlocks {
+		blocks[i] = &encoding.Block{
+			Header: &types.Header{
+				Number:   new(big.Int).SetUint64(daBlocks[i].Number()),
+				Time:     daBlocks[i].Timestamp(),
+				BaseFee:  daBlocks[i].BaseFee(),
+				GasLimit: daBlocks[i].GasLimit(),
+			},
+		}
+		// Ensure per-block ordering: [L1 messages][L2 transactions]. Prepend L1 messages (if any), then append L2 transactions.
+		if l1Messages, ok := l1MessagesWithBlockNumbers[daBlocks[i].Number()]; ok {
+			blocks[i].Transactions = l1Messages
+		}
+		blocks[i].Transactions = append(blocks[i].Transactions, encoding.TxsToTxsData(txns[i])...)
+	}
+	return blocks, nil
+}

rollup/internal/controller/relayer/l2_relayer_sanity_test.go

@@ -0,0 +1,131 @@
+package relayer
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common/hexutil"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+
+	bridgeabi "scroll-tech/rollup/abi"
+	"scroll-tech/rollup/internal/orm"
+)
+
+func TestAssembleDABatch(t *testing.T) {
+	calldataHex := "0x9bbaa2ba0000000000000000000000000000000000000000000000000000000000000008146793a7d71663cd87ec9713f72242a3798d5e801050130a3e16efaa09fb803e58af2593dadc8b9fff75a2d27199cb97ec115bade109b8d691a512608ef180eb"
+	blobsPath := filepath.Join("../../../testdata", "commit_batches_blobs.json")
+
+	calldata, err := hexutil.Decode(strings.TrimSpace(calldataHex))
+	assert.NoErrorf(t, err, "failed to decode calldata: %s", calldataHex)
+
+	blobs, err := loadBlobsFromJSON(blobsPath)
+	assert.NoErrorf(t, err, "failed to read blobs: %s", blobsPath)
+	assert.NotEmpty(t, blobs, "no blobs provided")
+
+	info, err := parseCommitBatchesCalldata(bridgeabi.ScrollChainABI, calldata)
+	assert.NoError(t, err)
+
+	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(info.Version))
+	assert.NoErrorf(t, err, "failed to get codec from version %d", info.Version)
+
+	parentBatchHash := info.ParentBatchHash
+	index := uint64(113571)
+
+	t.Logf("calldata parsed: version=%d parentBatchHash=%s lastBatchHash=%s blobs=%d", info.Version, info.ParentBatchHash.Hex(), info.LastBatchHash.Hex(), len(blobs))
+
+	fromAddr := common.HexToAddress("0x61d8d3e7f7c656493d1d76aaa1a836cedfcbc27b")
+	toAddr := common.HexToAddress("0xba50f5340fb9f3bd074bd638c9be13ecb36e603d")
+	l1MessagesWithBlockNumbers := map[uint64][]*types.TransactionData{
+		11488527: {
+			&types.TransactionData{
+				Type:  types.L1MessageTxType,
+				Nonce: 1072515,
+				Gas:   340000,
+				To:    &toAddr,
+				Value: (*hexutil.Big)(big.NewInt(0)),
+				Data:  "0x8ef1332e00000000000000000000000081f3843af1fbab046b771f0d440c04ebb2b7513f000000000000000000000000cec03800074d0ac0854bf1f34153cc4c8baeeb1e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000105d8300000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000084f03efa3700000000000000000000000000000000000000000000000000000000000024730000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000171bdb6e3062daaee1845ba4cb1902169feb5a9b9555a882d45637d3bd29eb83500000000000000000000000000000000000000000000000000000000",
+				From:  fromAddr,
+			},
+		},
+		11488622: {
+			&types.TransactionData{
+				Type:  types.L1MessageTxType,
+				Nonce: 1072516,
+				Gas:   340000,
+				To:    &toAddr,
+				Value: (*hexutil.Big)(big.NewInt(0)),
+				Data:  "0x8ef1332e00000000000000000000000081f3843af1fbab046b771f0d440c04ebb2b7513f000000000000000000000000cec03800074d0ac0854bf1f34153cc4c8baeeb1e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000105d8400000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000084f03efa370000000000000000000000000000000000000000000000000000000000002474000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000012aeb01535c1845b689bfce22e53029ec59ec75ea20f660d7c5fcd99f55b75b6900000000000000000000000000000000000000000000000000000000",
+				From:  fromAddr,
+			},
+		},
+		11489190: {
+			&types.TransactionData{
+				Type:  types.L1MessageTxType,
+				Nonce: 1072517,
+				Gas:   168000,
+				To:    &toAddr,
+				Value: (*hexutil.Big)(big.NewInt(0)),
+				Data:  "0x8ef1332e0000000000000000000000003b1399523f819ea4c4d3e76dddefaf4226c6ba570000000000000000000000003b1399523f819ea4c4d3e76dddefaf4226c6ba5700000000000000000000000000000000000000000000000000000000000027100000000000000000000000000000000000000000000000000000000000105d8500000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000",
+				From:  fromAddr,
+			},
+		},
+	}
+
+	for i, blob := range blobs {
+		payload, decErr := codec.DecodeBlob(blob)
+		assert.NoErrorf(t, decErr, "blob[%d] decode failed", i)
+		if decErr != nil {
+			continue
+		}
+
+		dbBatch := &orm.Batch{
+			Index:           index,
+			ParentBatchHash: parentBatchHash.Hex(),
+		}
+
+		daBatch, asmErr := assembleDABatchFromPayload(payload, dbBatch, codec, l1MessagesWithBlockNumbers)
+		assert.NoErrorf(t, asmErr, "blob[%d] assemble failed", i)
+		if asmErr == nil {
+			t.Logf("blob[%d] DABatch hash=%s", i, daBatch.Hash().Hex())
+		}
+
+		index += 1
+		parentBatchHash = daBatch.Hash()
+	}
+}
+
+func loadBlobsFromJSON(path string) ([]*kzg4844.Blob, error) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	var arr []hexutil.Bytes
+	if err := json.Unmarshal(raw, &arr); err != nil {
+		return nil, fmt.Errorf("invalid JSON; expect [\"0x...\"] array: %w", err)
+	}
+
+	out := make([]*kzg4844.Blob, 0, len(arr))
+	var empty kzg4844.Blob
+	want := len(empty)
+
+	for i, b := range arr {
+		if len(b) != want {
+			return nil, fmt.Errorf("blob[%d] length mismatch: got %d, want %d", i, len(b), want)
+		}
+		blob := new(kzg4844.Blob)
+		copy(blob[:], b)
+		out = append(out, blob)
+	}
+	return out, nil
+}

rollup/internal/controller/relayer/l2_relayer_test.go

@@ -70,15 +70,18 @@ func testL2RelayerProcessPendingBatches(t *testing.T) {
 	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV7, rutils.ChunkMetrics{})
 	assert.NoError(t, err)
 
+	batchOrm := orm.NewBatch(db)
+	genesisBatch, err := batchOrm.GetBatchByIndex(context.Background(), 0)
+	assert.NoError(t, err)
+
 	batch := &encoding.Batch{
 		Index:                      1,
 		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
+		ParentBatchHash:            common.HexToHash(genesisBatch.Hash),
 		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		Blocks:                     []*encoding.Block{block1, block2},
 	}
 
-	batchOrm := orm.NewBatch(db)
 	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV7, rutils.BatchMetrics{})
 	assert.NoError(t, err)
 

rollup/internal/controller/relayer/relayer_test.go

@@ -81,6 +81,7 @@ func setupEnv(t *testing.T) {
 	block1 = &encoding.Block{}
 	err = json.Unmarshal(templateBlockTrace1, block1)
 	assert.NoError(t, err)
+	block1.Header.Number = big.NewInt(1)
 	chunk1 = &encoding.Chunk{Blocks: []*encoding.Block{block1}}
 	codec, err := encoding.CodecFromVersion(encoding.CodecV0)
 	assert.NoError(t, err)
@@ -94,6 +95,7 @@ func setupEnv(t *testing.T) {
 	block2 = &encoding.Block{}
 	err = json.Unmarshal(templateBlockTrace2, block2)
 	assert.NoError(t, err)
+	block2.Header.Number = big.NewInt(2)
 	chunk2 = &encoding.Chunk{Blocks: []*encoding.Block{block2}}
 	daChunk2, err := codec.NewDAChunk(chunk2, chunk1.NumL1Messages(0))
 	assert.NoError(t, err)

rollup/internal/orm/batch.go

@@ -266,6 +266,19 @@ func (o *Batch) GetBatchByIndex(ctx context.Context, index uint64) (*Batch, erro
 	return &batch, nil
 }
 
+// GetBatchByHash retrieves the batch by the given hash.
+func (o *Batch) GetBatchByHash(ctx context.Context, hash string) (*Batch, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("hash = ?", hash)
+
+	var batch Batch
+	if err := db.First(&batch).Error; err != nil {
+		return nil, fmt.Errorf("Batch.GetBatchByHash error: %w, batch hash: %v", err, hash)
+	}
+	return &batch, nil
+}
+
 // InsertBatch inserts a new batch into the database.
 func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVersion encoding.CodecVersion, metrics rutils.BatchMetrics, dbTX ...*gorm.DB) (*Batch, error) {
 	if batch == nil {

tests/integration-test/go.mod

@@ -5,8 +5,8 @@ go 1.22
 toolchain go1.22.2
 
 require (
-	github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435
+	github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587
 	github.com/stretchr/testify v1.10.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )

tests/integration-test/go.sum

@@ -93,10 +93,10 @@ github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeC
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
-github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435 h1:X9fkvjrYBY79lGgKEPpUhuiJ4vWpWwzOVw4H8CU8L54=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6 h1:EiLZgoRfGgF0QzZ1jGSlo60A6W7g9L/8XLWMhwwtKJ0=
-github.com/scroll-tech/da-codec v0.1.3-0.20250310095435-012aaee6b435/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587 h1:wG1+gb+K4iLtxAHhiAreMdIjP5x9hB64duraN2+u1QU=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250625112225-a67863c65587/go.mod h1:YyfB2AyAtphlbIuDQgaxc2b9mo0zE4EBA1+qtXvzlmg=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=