feat(bridge-history): add puffer gateways (#1252)

Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>

bridge-history-api/go.mod

@@ -8,7 +8,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.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	golang.org/x/sync v0.6.0
@@ -60,6 +60,7 @@ require (
 	github.com/holiman/uint256 v1.2.4 // indirect
 	github.com/huin/goupnp v1.3.0 // indirect
 	github.com/iden3/go-iden3-crypto v0.0.15 // indirect
+	github.com/jackc/pgx/v5 v5.5.4 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect

bridge-history-api/go.sum

@@ -184,8 +184,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.5.0 h1:NxstgwndsTRy7eq9/kqYc/BZh5w2hHJV86wjvO+1xPw=
-github.com/jackc/pgx/v5 v5.5.0/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
+github.com/jackc/pgx/v5 v5.5.4 h1:Xp2aQS8uXButQdnCMWNmvx6UysWQQC+u1EoizjguY+8=
+github.com/jackc/pgx/v5 v5.5.4/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
@@ -311,8 +311,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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

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

@@ -23,6 +23,7 @@ type FetcherConfig struct {
 	DAIGatewayAddr           string `json:"DAIGatewayAddr"`
 	USDCGatewayAddr          string `json:"USDCGatewayAddr"`
 	LIDOGatewayAddr          string `json:"LIDOGatewayAddr"`
+	PufferGatewayAddr        string `json:"PufferGatewayAddr"`
 	ERC721GatewayAddr        string `json:"ERC721GatewayAddr"`
 	ERC1155GatewayAddr       string `json:"ERC1155GatewayAddr"`
 	ScrollChainAddr          string `json:"ScrollChainAddr"`

bridge-history-api/internal/logic/l1_fetcher.go

@@ -93,6 +93,11 @@ func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 		gatewayList = append(gatewayList, common.HexToAddress(cfg.LIDOGatewayAddr))
 	}
 
+	if common.HexToAddress(cfg.PufferGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.PufferGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.PufferGatewayAddr))
+	}
+
 	log.Info("L1 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
 
 	f := &L1FetcherLogic{

bridge-history-api/internal/logic/l2_fetcher.go

@@ -85,7 +85,12 @@ func NewL2FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient
 
 	if common.HexToAddress(cfg.LIDOGatewayAddr) != (common.Address{}) {
 		addressList = append(addressList, common.HexToAddress(cfg.LIDOGatewayAddr))
-		gatewayList = append(gatewayList, common.HexToAddress(cfg.USDCGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.LIDOGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.PufferGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.PufferGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.PufferGatewayAddr))
 	}
 
 	log.Info("L2 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)

common/database/db_test.go

@@ -1,62 +1,27 @@
-package database
+package database_test
 
 import (
-	"context"
-	"errors"
-	"io"
-	"os"
 	"testing"
-	"time"
 
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/common/docker"
+	"scroll-tech/common/database"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/version"
 )
 
-func TestGormLogger(t *testing.T) {
-	output := io.Writer(os.Stderr)
-	usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
-	if usecolor {
-		output = colorable.NewColorableStderr()
-	}
-	ostream := log.StreamHandler(output, log.TerminalFormat(usecolor))
-	glogger := log.NewGlogHandler(ostream)
-	// Set log level
-	glogger.Verbosity(log.LvlTrace)
-	log.Root().SetHandler(glogger)
-
-	var gl gormLogger
-	gl.gethLogger = log.Root()
-
-	gl.Error(context.Background(), "test %s error:%v", "testError", errors.New("test error"))
-	gl.Warn(context.Background(), "test %s warn:%v", "testWarn", errors.New("test warn"))
-	gl.Info(context.Background(), "test %s warn:%v", "testInfo", errors.New("test info"))
-	gl.Trace(context.Background(), time.Now(), func() (string, int64) { return "test trace", 1 }, nil)
-}
-
 func TestDB(t *testing.T) {
 	version.Version = "v4.1.98-aaa-bbb-ccc"
-	base := docker.NewDockerApp()
-	base.RunDBImage(t)
 
-	dbCfg := &Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+	testApps := testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
 
-	var err error
-	db, err := InitDB(dbCfg)
+	db, err := testApps.GetGormDBClient()
 	assert.NoError(t, err)
 
-	sqlDB, err := Ping(db)
+	sqlDB, err := database.Ping(db)
 	assert.NoError(t, err)
 	assert.NotNil(t, sqlDB)
 
-	assert.NoError(t, CloseDB(db))
+	assert.NoError(t, database.CloseDB(db))
 }

common/database/logger_test.go

@@ -0,0 +1,35 @@
+package database
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+	"github.com/scroll-tech/go-ethereum/log"
+)
+
+func TestGormLogger(t *testing.T) {
+	output := io.Writer(os.Stderr)
+	usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
+	if usecolor {
+		output = colorable.NewColorableStderr()
+	}
+	ostream := log.StreamHandler(output, log.TerminalFormat(usecolor))
+	glogger := log.NewGlogHandler(ostream)
+	// Set log level
+	glogger.Verbosity(log.LvlTrace)
+	log.Root().SetHandler(glogger)
+
+	var gl gormLogger
+	gl.gethLogger = log.Root()
+
+	gl.Error(context.Background(), "test %s error:%v", "testError", errors.New("test error"))
+	gl.Warn(context.Background(), "test %s warn:%v", "testWarn", errors.New("test warn"))
+	gl.Info(context.Background(), "test %s warn:%v", "testInfo", errors.New("test info"))
+	gl.Trace(context.Background(), time.Now(), func() (string, int64) { return "test trace", 1 }, nil)
+}

common/docker-compose/l1/consensus/config.yml

@@ -19,7 +19,7 @@ CAPELLA_FORK_VERSION: 0x20000092
 MAX_WITHDRAWALS_PER_PAYLOAD: 16
 
 # Deneb
-DENEB_FORK_EPOCH: 1
+DENEB_FORK_EPOCH: 0
 DENEB_FORK_VERSION: 0x20000093
 
 # Time parameters

common/docker-compose/l1/docker-compose.yml

@@ -19,7 +19,7 @@ services:
     command:
       - testnet
       - generate-genesis
-      - --fork=capella
+      - --fork=deneb
       - --num-validators=64
       - --genesis-time-delay=3
       - --output-ssz=/data/consensus/genesis.ssz

common/docker/docker_app.go

@@ -1,196 +0,0 @@
-package docker
-
-import (
-	"crypto/rand"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"math/big"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jmoiron/sqlx"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/database"
-
-	"scroll-tech/common/utils"
-)
-
-var (
-	l1StartPort = 10000
-	l2StartPort = 20000
-	dbStartPort = 30000
-)
-
-// AppAPI app interface.
-type AppAPI interface {
-	IsRunning() bool
-	WaitResult(t *testing.T, timeout time.Duration, keyword string) bool
-	RunApp(waitResult func() bool)
-	WaitExit()
-	ExpectWithTimeout(t *testing.T, parallel bool, timeout time.Duration, keyword string)
-}
-
-// App is collection struct of runtime docker images
-type App struct {
-	L1gethImg GethImgInstance
-	L2gethImg GethImgInstance
-	DBImg     ImgInstance
-
-	dbClient     *sql.DB
-	DBConfig     *database.DBConfig
-	DBConfigFile string
-
-	// common time stamp.
-	Timestamp int
-}
-
-// NewDockerApp returns new instance of dockerApp struct
-func NewDockerApp() *App {
-	timestamp := time.Now().Nanosecond()
-	app := &App{
-		Timestamp:    timestamp,
-		L1gethImg:    newTestL1Docker(),
-		L2gethImg:    newTestL2Docker(),
-		DBImg:        newTestDBDocker("postgres"),
-		DBConfigFile: fmt.Sprintf("/tmp/%d_db-config.json", timestamp),
-	}
-	if err := app.mockDBConfig(); err != nil {
-		panic(err)
-	}
-	return app
-}
-
-// RunImages runs all images togather
-func (b *App) RunImages(t *testing.T) {
-	b.RunDBImage(t)
-	b.RunL1Geth(t)
-	b.RunL2Geth(t)
-}
-
-// RunDBImage starts postgres docker container.
-func (b *App) RunDBImage(t *testing.T) {
-	if b.DBImg.IsRunning() {
-		return
-	}
-	assert.NoError(t, b.DBImg.Start())
-
-	// try 5 times until the db is ready.
-	ok := utils.TryTimes(10, func() bool {
-		db, err := sqlx.Open("postgres", b.DBImg.Endpoint())
-		return err == nil && db != nil && db.Ping() == nil
-	})
-	assert.True(t, ok)
-}
-
-// Free clear all running images, double check and recycle docker container.
-func (b *App) Free() {
-	if b.L1gethImg.IsRunning() {
-		_ = b.L1gethImg.Stop()
-	}
-	if b.L2gethImg.IsRunning() {
-		_ = b.L2gethImg.Stop()
-	}
-	if b.DBImg.IsRunning() {
-		_ = b.DBImg.Stop()
-		_ = os.Remove(b.DBConfigFile)
-		if !utils.IsNil(b.dbClient) {
-			_ = b.dbClient.Close()
-			b.dbClient = nil
-		}
-	}
-}
-
-// RunL1Geth starts l1geth docker container.
-func (b *App) RunL1Geth(t *testing.T) {
-	if b.L1gethImg.IsRunning() {
-		return
-	}
-	assert.NoError(t, b.L1gethImg.Start())
-}
-
-// L1Client returns a ethclient by dialing running l1geth
-func (b *App) L1Client() (*ethclient.Client, error) {
-	if utils.IsNil(b.L1gethImg) {
-		return nil, fmt.Errorf("l1 geth is not running")
-	}
-	client, err := ethclient.Dial(b.L1gethImg.Endpoint())
-	if err != nil {
-		return nil, err
-	}
-	return client, nil
-}
-
-// RunL2Geth starts l2geth docker container.
-func (b *App) RunL2Geth(t *testing.T) {
-	if b.L2gethImg.IsRunning() {
-		return
-	}
-	assert.NoError(t, b.L2gethImg.Start())
-}
-
-// L2Client returns a ethclient by dialing running l2geth
-func (b *App) L2Client() (*ethclient.Client, error) {
-	if utils.IsNil(b.L2gethImg) {
-		return nil, fmt.Errorf("l2 geth is not running")
-	}
-	client, err := ethclient.Dial(b.L2gethImg.Endpoint())
-	if err != nil {
-		return nil, err
-	}
-	return client, nil
-}
-
-// DBClient create and return *sql.DB instance.
-func (b *App) DBClient(t *testing.T) *sql.DB {
-	if !utils.IsNil(b.dbClient) {
-		return b.dbClient
-	}
-	var (
-		cfg = b.DBConfig
-		err error
-	)
-	b.dbClient, err = sql.Open(cfg.DriverName, cfg.DSN)
-	assert.NoError(t, err)
-	b.dbClient.SetMaxOpenConns(cfg.MaxOpenNum)
-	b.dbClient.SetMaxIdleConns(cfg.MaxIdleNum)
-	assert.NoError(t, b.dbClient.Ping())
-	return b.dbClient
-}
-
-func (b *App) mockDBConfig() error {
-	b.DBConfig = &database.DBConfig{
-		DSN:        "",
-		DriverName: "postgres",
-		MaxOpenNum: 200,
-		MaxIdleNum: 20,
-	}
-
-	if b.DBImg != nil {
-		b.DBConfig.DSN = b.DBImg.Endpoint()
-	}
-	data, err := json.Marshal(b.DBConfig)
-	if err != nil {
-		return err
-	}
-
-	return os.WriteFile(b.DBConfigFile, data, 0644) //nolint:gosec
-}
-
-func newTestL1Docker() GethImgInstance {
-	id, _ := rand.Int(rand.Reader, big.NewInt(2000))
-	return NewImgGeth("scroll_l1geth", "", "", 0, l1StartPort+int(id.Int64()))
-}
-
-func newTestL2Docker() GethImgInstance {
-	id, _ := rand.Int(rand.Reader, big.NewInt(2000))
-	return NewImgGeth("scroll_l2geth", "", "", 0, l2StartPort+int(id.Int64()))
-}
-
-func newTestDBDocker(driverName string) ImgInstance {
-	id, _ := rand.Int(rand.Reader, big.NewInt(2000))
-	return NewImgDB(driverName, "123456", "test_db", dbStartPort+int(id.Int64()))
-}

common/docker/docker_db.go

@@ -1,131 +0,0 @@
-package docker
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/docker/docker/api/types/container"
-
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/utils"
-)
-
-// ImgDB the postgres image manager.
-type ImgDB struct {
-	image string
-	name  string
-	id    string
-
-	dbName   string
-	port     int
-	password string
-
-	running bool
-	cmd     *cmd.Cmd
-}
-
-// NewImgDB return postgres db img instance.
-func NewImgDB(image, password, dbName string, port int) ImgInstance {
-	img := &ImgDB{
-		image:    image,
-		name:     fmt.Sprintf("%s-%s_%d", image, dbName, port),
-		password: password,
-		dbName:   dbName,
-		port:     port,
-	}
-	img.cmd = cmd.NewCmd("docker", img.prepare()...)
-	return img
-}
-
-// Start postgres db container.
-func (i *ImgDB) Start() error {
-	id := GetContainerID(i.name)
-	if id != "" {
-		return fmt.Errorf("container already exist, name: %s", i.name)
-	}
-	i.running = i.isOk()
-	if !i.running {
-		_ = i.Stop()
-		return fmt.Errorf("failed to start image: %s", i.image)
-	}
-	return nil
-}
-
-// Stop the container.
-func (i *ImgDB) Stop() error {
-	if !i.running {
-		return nil
-	}
-	i.running = false
-
-	ctx := context.Background()
-	// stop the running container.
-	if i.id == "" {
-		i.id = GetContainerID(i.name)
-	}
-
-	timeoutSec := 3
-	timeout := container.StopOptions{
-		Timeout: &timeoutSec,
-	}
-	if err := cli.ContainerStop(ctx, i.id, timeout); err != nil {
-		return err
-	}
-	// remove the stopped container.
-	return cli.ContainerRemove(ctx, i.id, container.RemoveOptions{})
-}
-
-// Endpoint return the dsn.
-func (i *ImgDB) Endpoint() string {
-	return fmt.Sprintf("postgres://postgres:%s@localhost:%d/%s?sslmode=disable", i.password, i.port, i.dbName)
-}
-
-// IsRunning returns docker container's running status.
-func (i *ImgDB) IsRunning() bool {
-	return i.running
-}
-
-func (i *ImgDB) prepare() []string {
-	cmd := []string{"run", "--rm", "--name", i.name, "-p", fmt.Sprintf("%d:5432", i.port)}
-	envs := []string{
-		"-e", "POSTGRES_PASSWORD=" + i.password,
-		"-e", fmt.Sprintf("POSTGRES_DB=%s", i.dbName),
-	}
-
-	cmd = append(cmd, envs...)
-	return append(cmd, i.image)
-}
-
-func (i *ImgDB) isOk() bool {
-	keyword := "database system is ready to accept connections"
-	okCh := make(chan struct{}, 1)
-	i.cmd.RegistFunc(keyword, func(buf string) {
-		if strings.Contains(buf, keyword) {
-			select {
-			case okCh <- struct{}{}:
-			default:
-				return
-			}
-		}
-	})
-	defer i.cmd.UnRegistFunc(keyword)
-	// Start cmd in parallel.
-	i.cmd.RunCmd(true)
-
-	select {
-	case <-okCh:
-		utils.TryTimes(20, func() bool {
-			i.id = GetContainerID(i.name)
-			return i.id != ""
-		})
-	case err := <-i.cmd.ErrChan:
-		if err != nil {
-			fmt.Printf("failed to start %s, err: %v\n", i.name, err)
-		}
-	case <-time.After(time.Second * 20):
-		return false
-	}
-	return i.id != ""
-}

common/docker/docker_geth.go

@@ -1,174 +0,0 @@
-package docker
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/utils"
-)
-
-// ImgGeth the geth image manager include l1geth and l2geth.
-type ImgGeth struct {
-	image string
-	name  string
-	id    string
-
-	volume   string
-	ipcPath  string
-	httpPort int
-	wsPort   int
-	chainID  *big.Int
-
-	running bool
-	cmd     *cmd.Cmd
-}
-
-// NewImgGeth return geth img instance.
-func NewImgGeth(image, volume, ipc string, hPort, wPort int) GethImgInstance {
-	img := &ImgGeth{
-		image:    image,
-		name:     fmt.Sprintf("%s-%d", image, time.Now().Nanosecond()),
-		volume:   volume,
-		ipcPath:  ipc,
-		httpPort: hPort,
-		wsPort:   wPort,
-	}
-	img.cmd = cmd.NewCmd("docker", img.params()...)
-	return img
-}
-
-// Start run image and check if it is running healthily.
-func (i *ImgGeth) Start() error {
-	id := GetContainerID(i.name)
-	if id != "" {
-		return fmt.Errorf("container already exist, name: %s", i.name)
-	}
-	i.running = i.isOk()
-	if !i.running {
-		_ = i.Stop()
-		return fmt.Errorf("failed to start image: %s", i.image)
-	}
-
-	// try 10 times to get chainID until is ok.
-	utils.TryTimes(10, func() bool {
-		client, err := ethclient.Dial(i.Endpoint())
-		if err == nil && client != nil {
-			i.chainID, err = client.ChainID(context.Background())
-			return err == nil && i.chainID != nil
-		}
-		return false
-	})
-
-	return nil
-}
-
-// IsRunning returns docker container's running status.
-func (i *ImgGeth) IsRunning() bool {
-	return i.running
-}
-
-// Endpoint return the connection endpoint.
-func (i *ImgGeth) Endpoint() string {
-	switch true {
-	case i.httpPort != 0:
-		return fmt.Sprintf("http://127.0.0.1:%d", i.httpPort)
-	case i.wsPort != 0:
-		return fmt.Sprintf("ws://127.0.0.1:%d", i.wsPort)
-	default:
-		return i.ipcPath
-	}
-}
-
-// ChainID return chainID.
-func (i *ImgGeth) ChainID() *big.Int {
-	return i.chainID
-}
-
-func (i *ImgGeth) isOk() bool {
-	keyword := "WebSocket enabled"
-	okCh := make(chan struct{}, 1)
-	i.cmd.RegistFunc(keyword, func(buf string) {
-		if strings.Contains(buf, keyword) {
-			select {
-			case okCh <- struct{}{}:
-			default:
-				return
-			}
-		}
-	})
-	defer i.cmd.UnRegistFunc(keyword)
-	// Start cmd in parallel.
-	i.cmd.RunCmd(true)
-
-	select {
-	case <-okCh:
-		utils.TryTimes(20, func() bool {
-			i.id = GetContainerID(i.name)
-			return i.id != ""
-		})
-	case err := <-i.cmd.ErrChan:
-		if err != nil {
-			fmt.Printf("failed to start %s, err: %v\n", i.name, err)
-		}
-	case <-time.After(time.Second * 10):
-		return false
-	}
-	return i.id != ""
-}
-
-// Stop the docker container.
-func (i *ImgGeth) Stop() error {
-	if !i.running {
-		return nil
-	}
-	i.running = false
-
-	ctx := context.Background()
-	// check if container is running, stop the running container.
-	id := GetContainerID(i.name)
-	if id != "" {
-		timeoutSec := 3
-		timeout := container.StopOptions{
-			Timeout: &timeoutSec,
-		}
-		if err := cli.ContainerStop(ctx, id, timeout); err != nil {
-			return err
-		}
-		i.id = id
-	}
-	// remove the stopped container.
-	return cli.ContainerRemove(ctx, i.id, container.RemoveOptions{})
-}
-
-func (i *ImgGeth) params() []string {
-	cmds := []string{"run", "--rm", "--name", i.name}
-	var ports []string
-	if i.httpPort != 0 {
-		ports = append(ports, []string{"-p", strconv.Itoa(i.httpPort) + ":8545"}...)
-	}
-	if i.wsPort != 0 {
-		ports = append(ports, []string{"-p", strconv.Itoa(i.wsPort) + ":8546"}...)
-	}
-
-	var envs []string
-	if i.ipcPath != "" {
-		envs = append(envs, []string{"-e", fmt.Sprintf("IPC_PATH=%s", i.ipcPath)}...)
-	}
-
-	if i.volume != "" {
-		cmds = append(cmds, []string{"-v", fmt.Sprintf("%s:%s", i.volume, i.volume)}...)
-	}
-
-	cmds = append(cmds, ports...)
-	cmds = append(cmds, envs...)
-
-	return append(cmds, i.image)
-}

common/docker/docker_test.go

@@ -1,54 +0,0 @@
-package docker_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/jmoiron/sqlx"
-	_ "github.com/lib/pq" //nolint:golint
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/docker"
-)
-
-var (
-	base *docker.App
-)
-
-func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-
-	m.Run()
-
-	base.Free()
-}
-
-func TestDB(t *testing.T) {
-	base.RunDBImage(t)
-
-	db, err := sqlx.Open("postgres", base.DBImg.Endpoint())
-	assert.NoError(t, err)
-	assert.NoError(t, db.Ping())
-}
-
-func TestL1Geth(t *testing.T) {
-	base.RunL1Geth(t)
-
-	client, err := base.L1Client()
-	assert.NoError(t, err)
-
-	chainID, err := client.ChainID(context.Background())
-	assert.NoError(t, err)
-	t.Logf("chainId: %s", chainID.String())
-}
-
-func TestL2Geth(t *testing.T) {
-	base.RunL2Geth(t)
-
-	client, err := base.L2Client()
-	assert.NoError(t, err)
-
-	chainID, err := client.ChainID(context.Background())
-	assert.NoError(t, err)
-	t.Logf("chainId: %s", chainID.String())
-}

common/docker/l2geth/genesis.json

@@ -15,7 +15,7 @@
     "archimedesBlock": 0,
     "shanghaiBlock": 0,
     "clique": {
-      "period": 3,
+      "period": 1,
       "epoch": 30000
     },
     "scroll": {

common/forks/forks.go

@@ -33,7 +33,8 @@ func CollectSortedForkHeights(config *params.ChainConfig) ([]uint64, map[uint64]
 		{name: "arrowGlacier", block: config.ArrowGlacierBlock},
 		{name: "archimedes", block: config.ArchimedesBlock},
 		{name: "shanghai", block: config.ShanghaiBlock},
-		{name: "banach", block: config.BanachBlock},
+		{name: "bernoulli", block: config.BernoulliBlock},
+		{name: "curie", block: config.CurieBlock},
 	} {
 		if fork.block == nil {
 			continue

common/forks/forks_test.go

@@ -11,10 +11,10 @@ import (
 
 func TestCollectSortedForkBlocks(t *testing.T) {
 	l, m, n := CollectSortedForkHeights(&params.ChainConfig{
-		EIP155Block:         big.NewInt(4),
-		EIP158Block:         big.NewInt(3),
-		ByzantiumBlock:      big.NewInt(3),
-		ConstantinopleBlock: big.NewInt(0),
+		ArchimedesBlock: big.NewInt(0),
+		ShanghaiBlock:   big.NewInt(3),
+		BernoulliBlock:  big.NewInt(3),
+		CurieBlock:      big.NewInt(4),
 	})
 	require.Equal(t, l, []uint64{
 		0,
@@ -27,9 +27,9 @@ func TestCollectSortedForkBlocks(t *testing.T) {
 		0: true,
 	}, m)
 	require.Equal(t, map[string]uint64{
-		"eip155":         4,
-		"byzantium":      3,
-		"constantinople": 0,
+		"archimedes": 0,
+		"bernoulli":  3,
+		"curie":      4,
 	}, n)
 }
 

common/go.mod

@@ -9,17 +9,16 @@ require (
 	github.com/docker/docker v25.0.3+incompatible
 	github.com/gin-contrib/pprof v1.4.0
 	github.com/gin-gonic/gin v1.9.1
-	github.com/jmoiron/sqlx v1.3.5
-	github.com/lib/pq v1.10.9
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.20
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
-	github.com/testcontainers/testcontainers-go v0.29.1
-	github.com/testcontainers/testcontainers-go/modules/compose v0.29.1
+	github.com/testcontainers/testcontainers-go v0.28.0
+	github.com/testcontainers/testcontainers-go/modules/compose v0.28.0
+	github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0
 	github.com/urfave/cli/v2 v2.25.7
 	gorm.io/driver/postgres v1.5.0
 	gorm.io/gorm v1.25.5
@@ -127,7 +126,7 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.5.0 // indirect
+	github.com/jackc/pgx/v5 v5.5.4 // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
@@ -144,7 +143,6 @@ require (
 	github.com/mailru/easyjson v0.7.6 // indirect
 	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/mattn/go-shellwords v1.0.12 // indirect
-	github.com/mattn/go-sqlite3 v1.14.16 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect

common/go.sum

@@ -268,7 +268,6 @@ github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXS
 github.com/go-playground/validator/v10 v10.15.5 h1:LEBecTWb/1j5TNY1YYG2RcOUN3R7NLylN+x8TTueE24=
 github.com/go-playground/validator/v10 v10.15.5/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-sql-driver/mysql v1.3.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
-github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
@@ -382,8 +381,8 @@ github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5ey
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
 github.com/jackc/pgx/v5 v5.3.0/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
-github.com/jackc/pgx/v5 v5.5.0 h1:NxstgwndsTRy7eq9/kqYc/BZh5w2hHJV86wjvO+1xPw=
-github.com/jackc/pgx/v5 v5.5.0/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
+github.com/jackc/pgx/v5 v5.5.4 h1:Xp2aQS8uXButQdnCMWNmvx6UysWQQC+u1EoizjguY+8=
+github.com/jackc/pgx/v5 v5.5.4/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
 github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
@@ -400,8 +399,6 @@ github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
-github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
-github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
 github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4=
 github.com/jonboulle/clockwork v0.4.0/go.mod h1:xgRqUGwRcjKCO1vbZUEtSLrqKoPSsUpK7fnezOII0kc=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
@@ -443,7 +440,6 @@ github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ic
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/lib/pq v0.0.0-20150723085316-0dad96c0b94f/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
@@ -469,9 +465,6 @@ github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh
 github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
 github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
 github.com/mattn/go-sqlite3 v1.6.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
-github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
@@ -614,8 +607,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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=
@@ -678,10 +671,12 @@ github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2 h1:wh1wzwAhZ
 github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/testcontainers/testcontainers-go v0.29.1 h1:z8kxdFlovA2y97RWx98v/TQ+tR+SXZm6p35M+xB92zk=
-github.com/testcontainers/testcontainers-go v0.29.1/go.mod h1:SnKnKQav8UcgtKqjp/AD8bE1MqZm+3TDb/B8crE3XnI=
-github.com/testcontainers/testcontainers-go/modules/compose v0.29.1 h1:47ipPM+s+ltCDOP3Sa1j95AkNb+z+WGiHLDbLU8ixuc=
-github.com/testcontainers/testcontainers-go/modules/compose v0.29.1/go.mod h1:Sqh+Ef2ESdbJQjTJl57UOkEHkOc7gXvQLg1b5xh6f1Y=
+github.com/testcontainers/testcontainers-go v0.28.0 h1:1HLm9qm+J5VikzFDYhOd+Zw12NtOl+8drH2E8nTY1r8=
+github.com/testcontainers/testcontainers-go v0.28.0/go.mod h1:COlDpUXbwW3owtpMkEB1zo9gwb1CoKVKlyrVPejF4AU=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0 h1:QOCeTYZIYixg796Ik60MOaeMgpAKPbQd5pJOdTrftyg=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0/go.mod h1:lShXm8oldlLck3ltA5u+ShSvUnZ+wiNxwpp8wAQGZ1Y=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0 h1:ff0s4JdYIdNAVSi/SrpN2Pdt1f+IjIw3AKjbHau8Un4=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0/go.mod h1:fXgcYpbyrduNdiz2qRZuYkmvqLnEqsjbQiBNYH1ystI=
 github.com/theupdateframework/notary v0.7.0 h1:QyagRZ7wlSpjT5N2qQAh/pN+DVqgekv4DzbAiAiEL3c=
 github.com/theupdateframework/notary v0.7.0/go.mod h1:c9DRxcmhHmVLDay4/2fUYdISnHqbFDGRSlXPO0AhYWw=
 github.com/tilt-dev/fsnotify v1.4.8-0.20220602155310-fff9c274a375 h1:QB54BJwA6x8QU9nHY3xJSZR2kX9bgpZekRKGkLTmEXA=

common/libzkp/impl/Cargo.toml

@@ -8,26 +8,29 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [patch.crates-io]
+gobuild = { git = "https://github.com/scroll-tech/gobuild.git" }
+halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0.1.0" }
 ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+#ethers-etherscan = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+#ethers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1"  }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
-poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "scroll-dev-0220" }
-[patch."https://github.com/privacy-scaling-explorations/halo2wrong.git"]
-halo2wrong = { git = "https://github.com/scroll-tech/halo2wrong.git", branch = "halo2-ecc-snark-verifier-0323" }
-maingate = { git = "https://github.com/scroll-tech/halo2wrong", branch = "halo2-ecc-snark-verifier-0323" }
-[patch."https://github.com/privacy-scaling-explorations/halo2curves.git"]
-halo2curves = { git = "https://github.com/scroll-tech/halo2curves.git", branch = "0.3.1-derive-serde" }
+poseidon = { git = "https://github.com/scroll-tech/poseidon.git", branch = "main" }
+[patch."https://github.com/privacy-scaling-explorations/bls12_381"]
+bls12_381 = { git = "https://github.com/scroll-tech/bls12_381", branch = "feat/impl_scalar_field" }
 
 [dependencies]
-halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
-prover = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.9.9", default-features = false, features = ["parallel_syn", "scroll", "shanghai", "strict-ccc"] }
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
+prover = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.10.0rc3", default-features = false, features = ["parallel_syn", "scroll", "shanghai"] }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"
 libc = "0.2"
 log = "0.4"
-once_cell = "1.8.0"
+once_cell = "1.19"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0.66"

common/libzkp/impl/rust-toolchain

@@ -1 +1 @@
-nightly-2022-12-10
+nightly-2023-12-03

common/libzkp/impl/src/batch.rs

@@ -119,7 +119,7 @@ pub unsafe extern "C" fn gen_batch_proof(
 
         let chunk_hashes_proofs = chunk_hashes
             .into_iter()
-            .zip(chunk_proofs.into_iter())
+            .zip(chunk_proofs)
             .collect();
 
         let proof = PROVER

common/libzkp/impl/src/lib.rs

@@ -1,5 +1,3 @@
-#![feature(once_cell)]
-
 mod batch;
 mod chunk;
 mod types;

common/testcontainers/testcontainers.go

@@ -0,0 +1,194 @@
+package testcontainers
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/modules/postgres"
+	"github.com/testcontainers/testcontainers-go/wait"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/database"
+)
+
+// TestcontainerApps testcontainers struct
+type TestcontainerApps struct {
+	postgresContainer *postgres.PostgresContainer
+	l1GethContainer   *testcontainers.DockerContainer
+	l2GethContainer   *testcontainers.DockerContainer
+
+	// common time stamp in nanoseconds.
+	Timestamp int
+}
+
+// NewTestcontainerApps returns new instance of TestcontainerApps struct
+func NewTestcontainerApps() *TestcontainerApps {
+	timestamp := time.Now().Nanosecond()
+	return &TestcontainerApps{
+		Timestamp: timestamp,
+	}
+}
+
+// StartPostgresContainer starts a postgres container
+func (t *TestcontainerApps) StartPostgresContainer() error {
+	if t.postgresContainer != nil && t.postgresContainer.IsRunning() {
+		return nil
+	}
+	postgresContainer, err := postgres.RunContainer(context.Background(),
+		testcontainers.WithImage("postgres"),
+		postgres.WithDatabase("test_db"),
+		postgres.WithPassword("123456"),
+		testcontainers.WithWaitStrategy(
+			wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5*time.Second)),
+	)
+	if err != nil {
+		log.Printf("failed to start postgres container: %s", err)
+		return err
+	}
+	t.postgresContainer = postgresContainer
+	return nil
+}
+
+// StartL1GethContainer starts a L1Geth container
+func (t *TestcontainerApps) StartL1GethContainer() error {
+	if t.l1GethContainer != nil && t.l1GethContainer.IsRunning() {
+		return nil
+	}
+	req := testcontainers.ContainerRequest{
+		Image:        "scroll_l1geth",
+		ExposedPorts: []string{"8546/tcp", "8545/tcp"},
+		WaitingFor:   wait.ForHTTP("/").WithPort("8545").WithStartupTimeout(100 * time.Second),
+		Cmd:          []string{"--log.debug", "ANY"},
+	}
+	genericContainerReq := testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	}
+	container, err := testcontainers.GenericContainer(context.Background(), genericContainerReq)
+	if err != nil {
+		log.Printf("failed to start scroll_l1geth container: %s", err)
+		return err
+	}
+	t.l1GethContainer, _ = container.(*testcontainers.DockerContainer)
+	return nil
+}
+
+// StartL2GethContainer starts a L2Geth container
+func (t *TestcontainerApps) StartL2GethContainer() error {
+	if t.l2GethContainer != nil && t.l2GethContainer.IsRunning() {
+		return nil
+	}
+	req := testcontainers.ContainerRequest{
+		Image:        "scroll_l2geth",
+		ExposedPorts: []string{"8546/tcp", "8545/tcp"},
+		WaitingFor:   wait.ForHTTP("/").WithPort("8545").WithStartupTimeout(100 * time.Second),
+	}
+	genericContainerReq := testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	}
+	container, err := testcontainers.GenericContainer(context.Background(), genericContainerReq)
+	if err != nil {
+		log.Printf("failed to start scroll_l2geth container: %s", err)
+		return err
+	}
+	t.l2GethContainer, _ = container.(*testcontainers.DockerContainer)
+	return nil
+}
+
+// GetDBEndPoint returns the endpoint of the running postgres container
+func (t *TestcontainerApps) GetDBEndPoint() (string, error) {
+	if t.postgresContainer == nil || !t.postgresContainer.IsRunning() {
+		return "", fmt.Errorf("postgres is not running")
+	}
+	return t.postgresContainer.ConnectionString(context.Background(), "sslmode=disable")
+}
+
+// GetL1GethEndPoint returns the endpoint of the running L1Geth container
+func (t *TestcontainerApps) GetL1GethEndPoint() (string, error) {
+	if t.l1GethContainer == nil || !t.l1GethContainer.IsRunning() {
+		return "", fmt.Errorf("l1 geth is not running")
+	}
+	endpoint, err := t.l1GethContainer.PortEndpoint(context.Background(), "8546/tcp", "ws")
+	if err != nil {
+		return "", err
+	}
+	return endpoint, nil
+}
+
+// GetL2GethEndPoint returns the endpoint of the running L2Geth container
+func (t *TestcontainerApps) GetL2GethEndPoint() (string, error) {
+	if t.l2GethContainer == nil || !t.l2GethContainer.IsRunning() {
+		return "", fmt.Errorf("l2 geth is not running")
+	}
+	endpoint, err := t.l2GethContainer.PortEndpoint(context.Background(), "8546/tcp", "ws")
+	if err != nil {
+		return "", err
+	}
+	return endpoint, nil
+}
+
+// GetGormDBClient returns a gorm.DB by connecting to the running postgres container
+func (t *TestcontainerApps) GetGormDBClient() (*gorm.DB, error) {
+	endpoint, err := t.GetDBEndPoint()
+	if err != nil {
+		return nil, err
+	}
+	dbCfg := &database.Config{
+		DSN:        endpoint,
+		DriverName: "postgres",
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
+	}
+	return database.InitDB(dbCfg)
+}
+
+// GetL1GethClient returns a ethclient by dialing running L1Geth
+func (t *TestcontainerApps) GetL1GethClient() (*ethclient.Client, error) {
+	endpoint, err := t.GetL1GethEndPoint()
+	if err != nil {
+		return nil, err
+	}
+	client, err := ethclient.Dial(endpoint)
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+// GetL2GethClient returns a ethclient by dialing running L2Geth
+func (t *TestcontainerApps) GetL2GethClient() (*ethclient.Client, error) {
+	endpoint, err := t.GetL2GethEndPoint()
+	if err != nil {
+		return nil, err
+	}
+	client, err := ethclient.Dial(endpoint)
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+// Free stops all running containers
+func (t *TestcontainerApps) Free() {
+	ctx := context.Background()
+	if t.postgresContainer != nil && t.postgresContainer.IsRunning() {
+		if err := t.postgresContainer.Terminate(ctx); err != nil {
+			log.Printf("failed to stop postgres container: %s", err)
+		}
+	}
+	if t.l1GethContainer != nil && t.l1GethContainer.IsRunning() {
+		if err := t.l1GethContainer.Terminate(ctx); err != nil {
+			log.Printf("failed to stop scroll_l1geth container: %s", err)
+		}
+	}
+	if t.l2GethContainer != nil && t.l2GethContainer.IsRunning() {
+		if err := t.l2GethContainer.Terminate(ctx); err != nil {
+			log.Printf("failed to stop scroll_l2geth container: %s", err)
+		}
+	}
+}

common/testcontainers/testcontainers_test.go

@@ -0,0 +1,59 @@
+package testcontainers
+
+import (
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
+)
+
+// TestNewTestcontainerApps tests NewTestcontainerApps
+func TestNewTestcontainerApps(t *testing.T) {
+	var (
+		err          error
+		endpoint     string
+		gormDBclient *gorm.DB
+		ethclient    *ethclient.Client
+	)
+
+	// test start testcontainers
+	testApps := NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	endpoint, err = testApps.GetDBEndPoint()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, endpoint)
+	gormDBclient, err = testApps.GetGormDBClient()
+	assert.NoError(t, err)
+	assert.NotNil(t, gormDBclient)
+
+	assert.NoError(t, testApps.StartL1GethContainer())
+	endpoint, err = testApps.GetL1GethEndPoint()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, endpoint)
+	ethclient, err = testApps.GetL1GethClient()
+	assert.NoError(t, err)
+	assert.NotNil(t, ethclient)
+
+	assert.NoError(t, testApps.StartL2GethContainer())
+	endpoint, err = testApps.GetL2GethEndPoint()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, endpoint)
+	ethclient, err = testApps.GetL2GethClient()
+	assert.NoError(t, err)
+	assert.NotNil(t, ethclient)
+
+	// test free testcontainers
+	testApps.Free()
+	endpoint, err = testApps.GetDBEndPoint()
+	assert.EqualError(t, err, "postgres is not running")
+	assert.Empty(t, endpoint)
+
+	endpoint, err = testApps.GetL1GethEndPoint()
+	assert.EqualError(t, err, "l1 geth is not running")
+	assert.Empty(t, endpoint)
+
+	endpoint, err = testApps.GetL2GethEndPoint()
+	assert.EqualError(t, err, "l2 geth is not running")
+	assert.Empty(t, endpoint)
+}

common/types/encoding/codecv0/codecv0.go

@@ -442,9 +442,9 @@ func EstimateBatchL1CommitGas(b *encoding.Batch) (uint64, error) {
 }
 
 // EstimateBatchL1CommitCalldataSize calculates the calldata size in l1 commit for this batch approximately.
-func EstimateBatchL1CommitCalldataSize(c *encoding.Batch) (uint64, error) {
+func EstimateBatchL1CommitCalldataSize(b *encoding.Batch) (uint64, error) {
 	var totalL1CommitCalldataSize uint64
-	for _, chunk := range c.Chunks {
+	for _, chunk := range b.Chunks {
 		chunkL1CommitCalldataSize, err := EstimateChunkL1CommitCalldataSize(chunk)
 		if err != nil {
 			return 0, err

common/types/encoding/codecv1/codecv1.go

@@ -292,9 +292,6 @@ func constructBlobPayload(chunks []*encoding.Chunk) (*kzg4844.Blob, *kzg4844.Poi
 	// 1 hash for metadata and 1 for each chunk
 	challengePreimage := make([]byte, (1+MaxNumChunks)*32)
 
-	// the challenge point z
-	var z kzg4844.Point
-
 	// the chunk data hash used for calculating the challenge preimage
 	var chunkDataHash common.Hash
 
@@ -348,9 +345,14 @@ func constructBlobPayload(chunks []*encoding.Chunk) (*kzg4844.Blob, *kzg4844.Poi
 	}
 
 	// compute z = challenge_digest % BLS_MODULUS
-	challengeDigest := crypto.Keccak256Hash(challengePreimage[:])
-	point := new(big.Int).Mod(new(big.Int).SetBytes(challengeDigest[:]), BLSModulus)
-	copy(z[:], point.Bytes()[0:32])
+	challengeDigest := crypto.Keccak256Hash(challengePreimage)
+	pointBigInt := new(big.Int).Mod(new(big.Int).SetBytes(challengeDigest[:]), BLSModulus)
+	pointBytes := pointBigInt.Bytes()
+
+	// the challenge point z
+	var z kzg4844.Point
+	start := 32 - len(pointBytes)
+	copy(z[start:], pointBytes)
 
 	return blob, &z, nil
 }
@@ -449,8 +451,55 @@ func (b *DABatch) BlobDataProof() ([]byte, error) {
 	return BlobDataProofArgs.Pack(values...)
 }
 
+// Blob returns the blob of the batch.
+func (b *DABatch) Blob() *kzg4844.Blob {
+	return b.blob
+}
+
 // DecodeFromCalldata attempts to decode a DABatch and an array of DAChunks from the provided calldata byte slice.
 func DecodeFromCalldata(data []byte) (*DABatch, []*DAChunk, error) {
 	// TODO: implement this function.
 	return nil, nil, nil
 }
+
+// EstimateChunkL1CommitBlobSize estimates the size of the L1 commit blob for a single chunk.
+func EstimateChunkL1CommitBlobSize(c *encoding.Chunk) (uint64, error) {
+	metadataSize := uint64(2 + 4*MaxNumChunks) // over-estimate: adding metadata length
+	chunkDataSize, err := chunkL1CommitBlobDataSize(c)
+	if err != nil {
+		return 0, err
+	}
+	paddedSize := ((metadataSize + chunkDataSize + 30) / 31) * 32
+	return paddedSize, nil
+}
+
+// EstimateBatchL1CommitBlobSize estimates the total size of the L1 commit blob for a batch.
+func EstimateBatchL1CommitBlobSize(b *encoding.Batch) (uint64, error) {
+	metadataSize := uint64(2 + 4*MaxNumChunks)
+	var batchDataSize uint64
+	for _, c := range b.Chunks {
+		chunkDataSize, err := chunkL1CommitBlobDataSize(c)
+		if err != nil {
+			return 0, err
+		}
+		batchDataSize += chunkDataSize
+	}
+	paddedSize := ((metadataSize + batchDataSize + 30) / 31) * 32
+	return paddedSize, nil
+}
+
+func chunkL1CommitBlobDataSize(c *encoding.Chunk) (uint64, error) {
+	var dataSize uint64
+	for _, block := range c.Blocks {
+		for _, tx := range block.Transactions {
+			if tx.Type != types.L1MessageTxType {
+				rlpTxData, err := encoding.ConvertTxDataToRLPEncoding(tx)
+				if err != nil {
+					return 0, err
+				}
+				dataSize += uint64(len(rlpTxData))
+			}
+		}
+	}
+	return dataSize, nil
+}

common/types/encoding/codecv1/codecv1_test.go

@@ -10,7 +10,9 @@ import (
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/encoding/codecv0"
 
+	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -528,6 +530,76 @@ func TestCodecV1BatchChallenge(t *testing.T) {
 	assert.Equal(t, "03523cd88a7227826e093305cbe4ce237e8df38e2157566fb3742cc39dbc9c43", hex.EncodeToString(batch.z[:]))
 }
 
+func repeat(element byte, count int) string {
+	result := make([]byte, 0, count)
+	for i := 0; i < count; i++ {
+		result = append(result, element)
+	}
+	return "0x" + common.Bytes2Hex(result)
+}
+
+func TestCodecV1BatchChallengeWithStandardTestCases(t *testing.T) {
+	nRowsData := 126914
+
+	for _, tc := range []struct {
+		chunks    [][]string
+		expectedz string
+		expectedy string
+	}{
+		// single empty chunk
+		{chunks: [][]string{{}}, expectedz: "1fa77f72d924ed6efdc399cf7a3de45fd3b50538d368d80d94840d30fdb606ec", expectedy: "28bda8f1836f60a3879f4253c4f51b3e41a905449b60a83a594f9f2487e8df51"},
+		// single non-empty chunk
+		{chunks: [][]string{{"0x010203"}}, expectedz: "30a9d6cfc2b87fb00d80e7fea28ebb9eff0bd526dbf1da32acfe8c5fd49632ff", expectedy: "723515444cb320fe437b9cea3b51293f5fbcb5913739ad35eab28b1863f7c312"},
+		// multiple empty chunks
+		{chunks: [][]string{{}, {}}, expectedz: "17772348f946a4e4adfcaf5c1690d078933b6b090ca9a52fab6c7e545b1007ae", expectedy: "05ba9abbc81a1c97f4cdaa683a7e0c731d9dfd88feef8f7b2fcfd79e593662b5"},
+		// multiple non-empty chunks
+		{chunks: [][]string{{"0x010203"}, {"0x070809"}}, expectedz: "60376321eea0886c29bd97d95851c7b5fbdb064c8adfdadd7678617b32b3ebf2", expectedy: "50cfbcece01cadb4eade40649e17b140b31f96088097e38f020e31dfe6551604"},
+		// empty chunk followed by non-empty chunk
+		{chunks: [][]string{{}, {"0x010203"}}, expectedz: "054539f03564eda9462d582703cde0788e4e27c311582ddfb19835358273a7ca", expectedy: "1fba03580b5908c4c66b48e79c10e7a34e4b27ed37a1a049b3e17e017cad5245"},
+		// non-empty chunk followed by empty chunk
+		{chunks: [][]string{{"0x070809"}, {}}, expectedz: "0b82dceaa6ca4b5d704590c921accfd991b56b5ad0212e6a4e63e54915a2053b", expectedy: "2362f3a0c87f0ea11eb898ed608c7f09a42926a058d4c5d111a0f54cad10ebbd"},
+		// max number of chunks all empty
+		{chunks: [][]string{{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}, expectedz: "174cd3ba9b2ae8ab789ec0b5b8e0b27ee122256ec1756c383dbf2b5b96903f1b", expectedy: "225cab9658904181671eb7abc342ffc36a6836048b64a67f0fb758439da2567b"},
+		// max number of chunks all non-empty
+		{chunks: [][]string{{"0x0a"}, {"0x0a0b"}, {"0x0a0b0c"}, {"0x0a0b0c0d"}, {"0x0a0b0c0d0e"}, {"0x0a0b0c0d0e0f"}, {"0x0a0b0c0d0e0f10"}, {"0x0a0b0c0d0e0f1011"}, {"0x0a0b0c0d0e0f101112"}, {"0x0a0b0c0d0e0f10111213"}, {"0x0a0b0c0d0e0f1011121314"}, {"0x0a0b0c0d0e0f101112131415"}, {"0x0a0b0c0d0e0f10111213141516"}, {"0x0a0b0c0d0e0f1011121314151617"}, {"0x0a0b0c0d0e0f101112131415161718"}}, expectedz: "1e93e961cdfb4bd26a5be48f23af4f1aa8c6bebe57a089d3250f8afb1e988bf8", expectedy: "24ed4791a70b28a6bad21c22d58f82a5ea5f9f9d2bcfc07428b494e9ae93de6e"},
+		// single chunk blob full
+		{chunks: [][]string{{repeat(123, nRowsData)}}, expectedz: "61405cb0b114dfb4d611be84bedba0fcd2e55615e193e424f1cc7b1af0df3d31", expectedy: "58609bbca10e50489b630ecb5b9347378579ed784d6a10749fd505055d35c3c0"},
+		// multiple chunks blob full
+		{chunks: [][]string{{repeat(123, 1111)}, {repeat(231, nRowsData-1111)}}, expectedz: "22533c3ea99536b4b83a89835aa91e6f0d2fc3866c201e18d7ca4b3af92fad61", expectedy: "40d4b71492e1a06ee3c273ef9003c7cb05aed021208871e13fa33302fa0f4dcc"},
+		// max number of chunks only last one non-empty not full blob
+		{chunks: [][]string{{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {repeat(132, nRowsData-1111)}}, expectedz: "0e6525c0dd261e8f62342b1139062bb23bc2b8b460163364598fb29e82a4eed5", expectedy: "1db984d6deb5e84bc67d0755aa2da8fe687233147603b4ecba94d0c8463c3836"},
+		// max number of chunks only last one non-empty full blob
+		{chunks: [][]string{{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {repeat(132, nRowsData)}}, expectedz: "3a638eac98f22f817b84e3d81ccaa3de080f83dc80a5823a3f19320ef3cb6fc8", expectedy: "73ab100278822144e2ed8c9d986e92f7a2662fd18a51bdf96ec55848578b227a"},
+		// max number of chunks but last is empty
+		{chunks: [][]string{{repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {repeat(111, 100)}, {}}, expectedz: "02ef442d99f450559647a7823f1be0e148c75481cc5c703c02a116e8ac531fa8", expectedy: "31743538cfc3ac43d1378a5c497ebc9462c20b4cb4470e0e7a9f7342ea948333"},
+	} {
+		chunks := []*encoding.Chunk{}
+
+		for _, c := range tc.chunks {
+			block := &encoding.Block{Transactions: []*types.TransactionData{}}
+
+			for _, data := range c {
+				tx := &types.TransactionData{Type: 0xff, Data: data}
+				block.Transactions = append(block.Transactions, tx)
+			}
+
+			chunk := &encoding.Chunk{Blocks: []*encoding.Block{block}}
+			chunks = append(chunks, chunk)
+		}
+
+		b, z, err := constructBlobPayload(chunks)
+		assert.NoError(t, err)
+		actualZ := hex.EncodeToString(z[:])
+		assert.Equal(t, tc.expectedz, actualZ)
+
+		_, y, err := kzg4844.ComputeProof(*b, *z)
+		assert.NoError(t, err)
+		actualY := hex.EncodeToString(y[:])
+		assert.Equal(t, tc.expectedy, actualY)
+
+	}
+}
+
 func TestCodecV1BatchBlobDataProof(t *testing.T) {
 	trace2 := readBlockFromJSON(t, "../../../testdata/blockTrace_02.json")
 	chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{trace2}}
@@ -687,6 +759,51 @@ func TestCodecV1BatchSkipBitmap(t *testing.T) {
 	assert.Equal(t, 42, int(batch.TotalL1MessagePopped))
 }
 
+func TestCodecV1ChunkAndBatchBlobSizeEstimation(t *testing.T) {
+	trace2 := readBlockFromJSON(t, "../../../testdata/blockTrace_02.json")
+	chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{trace2}}
+	chunk2BlobSize, err := EstimateChunkL1CommitBlobSize(chunk2)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(320), chunk2BlobSize)
+	batch2 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk2}}
+	batch2BlobSize, err := EstimateBatchL1CommitBlobSize(batch2)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(320), batch2BlobSize)
+
+	trace3 := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+	chunk3 := &encoding.Chunk{Blocks: []*encoding.Block{trace3}}
+	chunk3BlobSize, err := EstimateChunkL1CommitBlobSize(chunk3)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(5952), chunk3BlobSize)
+	batch3 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk3}}
+	batch3BlobSize, err := EstimateBatchL1CommitBlobSize(batch3)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(5952), batch3BlobSize)
+
+	trace4 := readBlockFromJSON(t, "../../../testdata/blockTrace_04.json")
+	chunk4 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}}
+	chunk4BlobSize, err := EstimateChunkL1CommitBlobSize(chunk4)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(128), chunk4BlobSize)
+	batch4 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk4}}
+	batch4BlobSize, err := EstimateBatchL1CommitBlobSize(batch4)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(128), batch4BlobSize)
+
+	chunk5 := &encoding.Chunk{Blocks: []*encoding.Block{trace2, trace3}}
+	chunk5BlobSize, err := EstimateChunkL1CommitBlobSize(chunk5)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(6176), chunk5BlobSize)
+	chunk6 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}}
+	chunk6BlobSize, err := EstimateChunkL1CommitBlobSize(chunk6)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(128), chunk6BlobSize)
+	batch5 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk5, chunk6}}
+	batch5BlobSize, err := EstimateBatchL1CommitBlobSize(batch5)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(6208), batch5BlobSize)
+}
+
 func readBlockFromJSON(t *testing.T, filename string) *encoding.Block {
 	data, err := os.ReadFile(filename)
 	assert.NoError(t, err)

common/types/encoding/da.go

@@ -6,8 +6,30 @@ import (
 	"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/log"
 )
 
+// CodecVersion defines the version of encoder and decoder.
+type CodecVersion int
+
+const (
+	// CodecV0 represents the version 0 of the encoder and decoder.
+	CodecV0 CodecVersion = iota
+
+	// CodecV1 represents the version 1 of the encoder and decoder.
+	CodecV1
+
+	// txTypeTest is a special transaction type used in unit tests.
+	txTypeTest = 0xff
+)
+
+func init() {
+	// make sure txTypeTest will not interfere with other transaction types
+	if txTypeTest == types.LegacyTxType || txTypeTest == types.AccessListTxType || txTypeTest == types.DynamicFeeTxType || txTypeTest == types.BlobTxType || txTypeTest == types.L1MessageTxType {
+		log.Crit("txTypeTest is overlapping with existing transaction types")
+	}
+}
+
 // Block represents an L2 block.
 type Block struct {
 	Header         *types.Header
@@ -123,6 +145,10 @@ func ConvertTxDataToRLPEncoding(txData *types.TransactionData) ([]byte, error) {
 			S:          txData.S.ToInt(),
 		})
 
+	case txTypeTest:
+		// in the tests, we simply use `data` as the RLP-encoded transaction
+		return data, nil
+
 	case types.L1MessageTxType: // L1MessageTxType is not supported
 	default:
 		return nil, fmt.Errorf("unsupported tx type: %d", txData.Type)
@@ -209,8 +235,3 @@ func (b *Batch) WithdrawRoot() common.Hash {
 	lastChunkBlockNum := len(b.Chunks[numChunks-1].Blocks)
 	return b.Chunks[len(b.Chunks)-1].Blocks[lastChunkBlockNum-1].WithdrawRoot
 }
-
-// NumChunks gets the number of chunks of the batch.
-func (b *Batch) NumChunks() uint64 {
-	return uint64(len(b.Chunks))
-}

common/types/encoding/da_test.go

@@ -75,7 +75,6 @@ func TestUtilFunctions(t *testing.T) {
 	assert.Equal(t, uint64(240000), chunk3.L2GasUsed())
 
 	// Test Batch methods
-	assert.Equal(t, uint64(3), batch.NumChunks())
 	assert.Equal(t, block6.Header.Root, batch.StateRoot())
 	assert.Equal(t, block6.WithdrawRoot, batch.WithdrawRoot())
 }

common/types/message/message.go

@@ -259,6 +259,7 @@ type ChunkInfo struct {
 	WithdrawRoot  common.Hash `json:"withdraw_root"`
 	DataHash      common.Hash `json:"data_hash"`
 	IsPadding     bool        `json:"is_padding"`
+	TxBytes       []byte      `json:"tx_bytes"`
 }
 
 // ChunkProof includes the proof info that are required for chunk verification and rollup.

common/version/version.go

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

contracts/src/L1/rollup/ScrollChain.sol

@@ -877,7 +877,7 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
             uint256 _numTransactionsInBlock = ChunkCodecV1.getNumTransactions(chunkPtr);
             if (_numTransactionsInBlock < _numL1MessagesInBlock) revert ErrorNumTxsLessThanNumL1Msgs();
             unchecked {
-                _totalTransactionsInChunk += dataPtr - startPtr; // number of non-skipped l1 messages
+                _totalTransactionsInChunk += (dataPtr - startPtr) / 32; // number of non-skipped l1 messages
                 _totalTransactionsInChunk += _numTransactionsInBlock - _numL1MessagesInBlock; // number of l2 txs
                 _totalL1MessagesPoppedInBatch += _numL1MessagesInBlock;
                 _totalL1MessagesPoppedOverall += _numL1MessagesInBlock;

coordinator/cmd/api/app/mock_app.go

@@ -12,11 +12,11 @@ import (
 
 	"github.com/scroll-tech/go-ethereum/params"
 
-	coordinatorConfig "scroll-tech/coordinator/internal/config"
-
 	"scroll-tech/common/cmd"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/utils"
+
+	coordinatorConfig "scroll-tech/coordinator/internal/config"
 )
 
 var (
@@ -28,7 +28,7 @@ type CoordinatorApp struct {
 	Config      *coordinatorConfig.Config
 	ChainConfig *params.ChainConfig
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	configOriginFile      string
 	chainConfigOriginFile string
@@ -37,17 +37,17 @@ type CoordinatorApp struct {
 	HTTPPort              int64
 
 	args []string
-	docker.AppAPI
+	*cmd.Cmd
 }
 
 // NewCoordinatorApp return a new coordinatorApp manager.
-func NewCoordinatorApp(base *docker.App, configFile string, chainConfigFile string) *CoordinatorApp {
-	coordinatorFile := fmt.Sprintf("/tmp/%d_coordinator-config.json", base.Timestamp)
-	genesisFile := fmt.Sprintf("/tmp/%d_genesis.json", base.Timestamp)
+func NewCoordinatorApp(testApps *testcontainers.TestcontainerApps, configFile string, chainConfigFile string) *CoordinatorApp {
+	coordinatorFile := fmt.Sprintf("/tmp/%d_coordinator-config.json", testApps.Timestamp)
+	genesisFile := fmt.Sprintf("/tmp/%d_genesis.json", testApps.Timestamp)
 	port, _ := rand.Int(rand.Reader, big.NewInt(2000))
 	httpPort := port.Int64() + httpStartPort
 	coordinatorApp := &CoordinatorApp{
-		base:                  base,
+		testApps:              testApps,
 		configOriginFile:      configFile,
 		chainConfigOriginFile: chainConfigFile,
 		coordinatorFile:       coordinatorFile,
@@ -63,14 +63,14 @@ func NewCoordinatorApp(base *docker.App, configFile string, chainConfigFile stri
 
 // RunApp run coordinator-test child process by multi parameters.
 func (c *CoordinatorApp) RunApp(t *testing.T, args ...string) {
-	c.AppAPI = cmd.NewCmd(string(utils.CoordinatorAPIApp), append(c.args, args...)...)
-	c.AppAPI.RunApp(func() bool { return c.AppAPI.WaitResult(t, time.Second*20, "Start coordinator api successfully") })
+	c.Cmd = cmd.NewCmd(string(utils.CoordinatorAPIApp), append(c.args, args...)...)
+	c.Cmd.RunApp(func() bool { return c.Cmd.WaitResult(t, time.Second*20, "Start coordinator api successfully") })
 }
 
 // Free stop and release coordinator-test.
 func (c *CoordinatorApp) Free() {
-	if !utils.IsNil(c.AppAPI) {
-		c.AppAPI.WaitExit()
+	if !utils.IsNil(c.Cmd) {
+		c.Cmd.WaitExit()
 	}
 	_ = os.Remove(c.coordinatorFile)
 }
@@ -82,7 +82,6 @@ func (c *CoordinatorApp) HTTPEndpoint() string {
 
 // MockConfig creates a new coordinator config.
 func (c *CoordinatorApp) MockConfig(store bool) error {
-	base := c.base
 	cfg, err := coordinatorConfig.NewConfig(c.configOriginFile)
 	if err != nil {
 		return err
@@ -97,7 +96,11 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 		MaxVerifierWorkers:     4,
 		MinProverVersion:       "v1.0.0",
 	}
-	cfg.DB.DSN = base.DBImg.Endpoint()
+	endpoint, err := c.testApps.GetDBEndPoint()
+	if err != nil {
+		return err
+	}
+	cfg.DB.DSN = endpoint
 	cfg.L2.ChainID = 111
 	cfg.Auth.ChallengeExpireDurationSec = 1
 	cfg.Auth.LoginExpireDurationSec = 1

coordinator/go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7

coordinator/go.sum

@@ -173,8 +173,8 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -209,6 +209,9 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 			DataHash:      common.HexToHash(chunk.Hash),
 			IsPadding:     false,
 		}
+		if proof.ChunkInfo != nil {
+			chunkInfo.TxBytes = proof.ChunkInfo.TxBytes
+		}
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
 

coordinator/internal/logic/verifier/verifier_test.go

@@ -14,7 +14,6 @@ import (
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/verifier"
 )
 
 var (
@@ -34,7 +33,7 @@ func TestFFI(t *testing.T) {
 		AssetsPath: *assetsPath,
 	}
 
-	v, err := verifier.NewVerifier(cfg)
+	v, err := NewVerifier(cfg)
 	as.NoError(err)
 
 	chunkProof1 := readChunkProof(*chunkProofPath1, as)

coordinator/internal/orm/batch.go

@@ -73,22 +73,16 @@ func (*Batch) TableName() string {
 // GetUnassignedBatch retrieves unassigned batch based on the specified limit.
 // The returned batch are sorted in ascending order by their index.
 func (o *Batch) GetUnassignedBatch(ctx context.Context, startChunkIndex, endChunkIndex uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Where("proving_status = ?", int(types.ProvingTaskUnassigned))
-	db = db.Where("total_attempts < ?", maxTotalAttempts)
-	db = db.Where("active_attempts < ?", maxActiveAttempts)
-	db = db.Where("chunk_proofs_status = ?", int(types.ChunkProofsStatusReady))
-	db = db.Where("start_chunk_index >= ?", startChunkIndex)
-	db = db.Where("end_chunk_index < ?", endChunkIndex)
-
 	var batch Batch
-	err := db.First(&batch).Error
-	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, nil
-	}
-
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND start_chunk_index >= %d AND end_chunk_index < %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady), startChunkIndex, endChunkIndex)
+	err := db.Raw(sql).Scan(&batch).Error
 	if err != nil {
-		return nil, fmt.Errorf("Batch.GetUnassignedBatches error: %w", err)
+		return nil, fmt.Errorf("Batch.GetUnassignedBatch error: %w", err)
+	}
+	if batch.Hash == "" {
+		return nil, nil
 	}
 	return &batch, nil
 }
@@ -96,22 +90,16 @@ func (o *Batch) GetUnassignedBatch(ctx context.Context, startChunkIndex, endChun
 // GetAssignedBatch retrieves assigned batch based on the specified limit.
 // The returned batch are sorted in ascending order by their index.
 func (o *Batch) GetAssignedBatch(ctx context.Context, startChunkIndex, endChunkIndex uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Batch, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Where("proving_status = ?", int(types.ProvingTaskAssigned))
-	db = db.Where("total_attempts < ?", maxTotalAttempts)
-	db = db.Where("active_attempts < ?", maxActiveAttempts)
-	db = db.Where("chunk_proofs_status = ?", int(types.ChunkProofsStatusReady))
-	db = db.Where("start_chunk_index >= ?", startChunkIndex)
-	db = db.Where("end_chunk_index < ?", endChunkIndex)
-
 	var batch Batch
-	err := db.First(&batch).Error
-	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, nil
-	}
-
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM batch WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND chunk_proofs_status = %d AND start_chunk_index >= %d AND end_chunk_index < %d AND batch.deleted_at IS NULL ORDER BY batch.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, int(types.ChunkProofsStatusReady), startChunkIndex, endChunkIndex)
+	err := db.Raw(sql).Scan(&batch).Error
 	if err != nil {
-		return nil, fmt.Errorf("Batch.GetAssignedBatches error: %w", err)
+		return nil, fmt.Errorf("Batch.GetAssignedBatch error: %w", err)
+	}
+	if batch.Hash == "" {
+		return nil, nil
 	}
 	return &batch, nil
 }

coordinator/internal/orm/chunk.go

@@ -71,22 +71,16 @@ func (*Chunk) TableName() string {
 // GetUnassignedChunk retrieves unassigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
 func (o *Chunk) GetUnassignedChunk(ctx context.Context, fromBlockNum, toBlockNum uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Model(&Chunk{})
-	db = db.Where("proving_status = ?", int(types.ProvingTaskUnassigned))
-	db = db.Where("total_attempts < ?", maxTotalAttempts)
-	db = db.Where("active_attempts < ?", maxActiveAttempts)
-	db = db.Where("start_block_number >= ?", fromBlockNum)
-	db = db.Where("end_block_number < ?", toBlockNum)
-
 	var chunk Chunk
-	err := db.First(&chunk).Error
-	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, nil
-	}
-
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND start_block_number >= %d AND end_block_number < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskUnassigned), maxTotalAttempts, maxActiveAttempts, fromBlockNum, toBlockNum)
+	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
-		return nil, fmt.Errorf("Chunk.GetUnassignedChunks error: %w", err)
+		return nil, fmt.Errorf("Chunk.GetUnassignedChunk error: %w", err)
+	}
+	if chunk.Hash == "" {
+		return nil, nil
 	}
 	return &chunk, nil
 }
@@ -94,22 +88,16 @@ func (o *Chunk) GetUnassignedChunk(ctx context.Context, fromBlockNum, toBlockNum
 // GetAssignedChunk retrieves assigned chunk based on the specified limit.
 // The returned chunks are sorted in ascending order by their index.
 func (o *Chunk) GetAssignedChunk(ctx context.Context, fromBlockNum, toBlockNum uint64, maxActiveAttempts, maxTotalAttempts uint8) (*Chunk, error) {
-	db := o.db.WithContext(ctx)
-	db = db.Model(&Chunk{})
-	db = db.Where("proving_status = ?", int(types.ProvingTaskAssigned))
-	db = db.Where("total_attempts < ?", maxTotalAttempts)
-	db = db.Where("active_attempts < ?", maxActiveAttempts)
-	db = db.Where("start_block_number >= ?", fromBlockNum)
-	db = db.Where("end_block_number < ?", toBlockNum)
-
 	var chunk Chunk
-	err := db.First(&chunk).Error
-	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, nil
-	}
-
+	db := o.db.WithContext(ctx)
+	sql := fmt.Sprintf("SELECT * FROM chunk WHERE proving_status = %d AND total_attempts < %d AND active_attempts < %d AND start_block_number >= %d AND end_block_number < %d AND chunk.deleted_at IS NULL ORDER BY chunk.index LIMIT 1;",
+		int(types.ProvingTaskAssigned), maxTotalAttempts, maxActiveAttempts, fromBlockNum, toBlockNum)
+	err := db.Raw(sql).Scan(&chunk).Error
 	if err != nil {
-		return nil, fmt.Errorf("Chunk.GetAssignedChunks error: %w", err)
+		return nil, fmt.Errorf("Chunk.GetAssignedChunk error: %w", err)
+	}
+	if chunk.Hash == "" {
+		return nil, nil
 	}
 	return &chunk, nil
 }

coordinator/internal/orm/orm_test.go

@@ -9,41 +9,36 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
-
 	"scroll-tech/database/migrate"
 )
 
 var (
-	base *docker.App
-
+	testApps      *testcontainers.TestcontainerApps
 	db            *gorm.DB
 	proverTaskOrm *ProverTask
 )
 
 func TestMain(m *testing.M) {
 	t := &testing.T{}
-	setupEnv(t)
-	defer tearDownEnv(t)
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		tearDownEnv(t)
+	}()
 	m.Run()
 }
 
 func setupEnv(t *testing.T) {
-	base = docker.NewDockerApp()
-	base.RunDBImage(t)
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+
 	var err error
-	db, err = database.InitDB(
-		&database.Config{
-			DSN:        base.DBConfig.DSN,
-			DriverName: base.DBConfig.DriverName,
-			MaxOpenNum: base.DBConfig.MaxOpenNum,
-			MaxIdleNum: base.DBConfig.MaxIdleNum,
-		},
-	)
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -56,10 +51,11 @@ func tearDownEnv(t *testing.T) {
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	sqlDB.Close()
-	base.Free()
 }
 
 func TestProverTaskOrm(t *testing.T) {
+	setupEnv(t)
+
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))

coordinator/test/api_test.go

@@ -21,8 +21,7 @@ import (
 
 	"scroll-tech/database/migrate"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/message"
@@ -43,10 +42,9 @@ const (
 )
 
 var (
-	dbCfg *database.Config
-	conf  *config.Config
+	conf *config.Config
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	db                 *gorm.DB
 	l2BlockOrm         *orm.L2Block
@@ -70,13 +68,12 @@ var (
 )
 
 func TestMain(m *testing.M) {
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
-	glogger.Verbosity(log.LvlInfo)
-	log.Root().SetHandler(glogger)
-
-	base = docker.NewDockerApp()
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+	}()
 	m.Run()
-	base.Free()
 }
 
 func randomURL() string {
@@ -86,7 +83,8 @@ func randomURL() string {
 
 func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
 	var err error
-	db, err = database.InitDB(dbCfg)
+	db, err = testApps.GetGormDBClient()
+
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -115,8 +113,8 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 	var chainConf params.ChainConfig
 	for forkName, forkNumber := range nameForkMap {
 		switch forkName {
-		case "banach":
-			chainConf.BanachBlock = big.NewInt(forkNumber)
+		case "bernoulli":
+			chainConf.BernoulliBlock = big.NewInt(forkNumber)
 		case "london":
 			chainConf.LondonBlock = big.NewInt(forkNumber)
 		case "istanbul":
@@ -149,20 +147,18 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 }
 
 func setEnv(t *testing.T) {
+	var err error
+
 	version.Version = "v4.1.98"
 
-	base = docker.NewDockerApp()
-	base.RunDBImage(t)
+	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
+	glogger.Verbosity(log.LvlInfo)
+	log.Root().SetHandler(glogger)
 
-	dbCfg = &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
 
-	var err error
-	db, err = database.InitDB(dbCfg)
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -199,7 +195,6 @@ func setEnv(t *testing.T) {
 
 func TestApis(t *testing.T) {
 	// Set up the test environment.
-	base = docker.NewDockerApp()
 	setEnv(t)
 
 	t.Run("TestHandshake", testHandshake)
@@ -211,11 +206,6 @@ func TestApis(t *testing.T) {
 	t.Run("TestProofGeneratedFailed", testProofGeneratedFailed)
 	t.Run("TestTimeoutProof", testTimeoutProof)
 	t.Run("TestHardFork", testHardForkAssignTask)
-
-	// Teardown
-	t.Cleanup(func() {
-		base.Free()
-	})
 }
 
 func testHandshake(t *testing.T) {
@@ -332,18 +322,18 @@ func testHardForkAssignTask(t *testing.T) {
 		{ // hard fork 4, prover 4  block [2-3]
 			name:                  "noTaskForkChunkProverVersionLargeOrEqualThanHardFork",
 			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"banach": forkNumberFour},
+			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour},
 			exceptTaskNumber:      0,
-			proverForkNames:       []string{"banach", "banach"},
+			proverForkNames:       []string{"bernoulli", "bernoulli"},
 			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
 			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
 		},
 		{
 			name:                  "noTaskForkBatchProverVersionLargeOrEqualThanHardFork",
 			proofType:             message.ProofTypeBatch,
-			forkNumbers:           map[string]int64{"banach": forkNumberFour},
+			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour},
 			exceptTaskNumber:      0,
-			proverForkNames:       []string{"banach", "banach"},
+			proverForkNames:       []string{"bernoulli", "bernoulli"},
 			exceptGetTaskErrCodes: []int{types.ErrCoordinatorEmptyProofData, types.ErrCoordinatorEmptyProofData},
 			exceptGetTaskErrMsgs:  []string{"get empty prover task", "get empty prover task"},
 		},
@@ -431,7 +421,7 @@ func testHardForkAssignTask(t *testing.T) {
 		{ // hard fork 4, prover 3 block [2-3]
 			name:                  "twoTaskForkChunkProverVersionLessThanHardFork",
 			proofType:             message.ProofTypeChunk,
-			forkNumbers:           map[string]int64{"banach": forkNumberFour, "istanbul": forkNumberTwo},
+			forkNumbers:           map[string]int64{"bernoulli": forkNumberFour, "istanbul": forkNumberTwo},
 			exceptTaskNumber:      2,
 			proverForkNames:       []string{"istanbul", "istanbul"},
 			exceptGetTaskErrCodes: []int{types.Success, types.Success},

database/go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/lib/pq v1.10.9
 	github.com/pressly/goose/v3 v3.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 )
@@ -20,6 +20,7 @@ require (
 	github.com/docker/go-connections v0.5.0 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/jackc/pgx/v5 v5.5.4 // indirect
 	github.com/klauspost/compress v1.17.4 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/mattn/go-sqlite3 v1.14.16 // indirect
@@ -31,7 +32,6 @@ require (
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/mod v0.16.0 // indirect
 	golang.org/x/sync v0.6.0 // indirect
 	golang.org/x/sys v0.17.0 // indirect

database/go.sum

@@ -58,8 +58,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.5.0 h1:NxstgwndsTRy7eq9/kqYc/BZh5w2hHJV86wjvO+1xPw=
-github.com/jackc/pgx/v5 v5.5.0/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
+github.com/jackc/pgx/v5 v5.5.4 h1:Xp2aQS8uXButQdnCMWNmvx6UysWQQC+u1EoizjguY+8=
+github.com/jackc/pgx/v5 v5.5.4/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
@@ -119,8 +119,8 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
 github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
 github.com/sethvargo/go-retry v0.2.4 h1:T+jHEQy/zKJf5s95UkguisicE0zuF9y7+/vgz08Ocec=

database/migrate/migrate_test.go

@@ -1,93 +1,89 @@
 package migrate
 
 import (
+	"database/sql"
 	"testing"
 
-	"github.com/jmoiron/sqlx"
 	_ "github.com/lib/pq"
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/common/docker"
-
-	"scroll-tech/database"
+	"scroll-tech/common/testcontainers"
 )
 
 var (
-	base *docker.App
-	pgDB *sqlx.DB
+	testApps *testcontainers.TestcontainerApps
+	pgDB     *sql.DB
 )
 
-func initEnv(t *testing.T) error {
+func setupEnv(t *testing.T) {
 	// Start db container.
-	base.RunDBImage(t)
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	gormClient, err := testApps.GetGormDBClient()
+	assert.NoError(t, err)
+	pgDB, err = gormClient.DB()
+	assert.NoError(t, err)
+}
 
-	// Create db orm handler.
-	factory, err := database.NewOrmFactory(base.DBConfig)
-	if err != nil {
-		return err
-	}
-	pgDB = factory.GetDB()
-	return nil
+func TestMain(m *testing.M) {
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+	}()
+	m.Run()
 }
 
 func TestMigrate(t *testing.T) {
-	base = docker.NewDockerApp()
-	if err := initEnv(t); err != nil {
-		t.Fatal(err)
-	}
-
+	setupEnv(t)
 	t.Run("testCurrent", testCurrent)
 	t.Run("testStatus", testStatus)
 	t.Run("testResetDB", testResetDB)
 	t.Run("testMigrate", testMigrate)
 	t.Run("testRollback", testRollback)
-
-	t.Cleanup(func() {
-		base.Free()
-	})
 }
 
 func testCurrent(t *testing.T) {
-	cur, err := Current(pgDB.DB)
+	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(0), cur)
 }
 
 func testStatus(t *testing.T) {
-	status := Status(pgDB.DB)
+	status := Status(pgDB)
 	assert.NoError(t, status)
 }
 
 func testResetDB(t *testing.T) {
-	assert.NoError(t, ResetDB(pgDB.DB))
-	cur, err := Current(pgDB.DB)
+	assert.NoError(t, ResetDB(pgDB))
+	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	// total number of tables.
 	assert.Equal(t, int64(16), cur)
 }
 
 func testMigrate(t *testing.T) {
-	assert.NoError(t, Migrate(pgDB.DB))
-	cur, err := Current(pgDB.DB)
+	assert.NoError(t, Migrate(pgDB))
+	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(16), cur)
 }
 
 func testRollback(t *testing.T) {
-	version, err := Current(pgDB.DB)
+	version, err := Current(pgDB)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(16), version)
 
-	assert.NoError(t, Rollback(pgDB.DB, nil))
+	assert.NoError(t, Rollback(pgDB, nil))
 
-	cur, err := Current(pgDB.DB)
+	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	assert.Equal(t, version, cur+1)
 
 	targetVersion := int64(0)
-	assert.NoError(t, Rollback(pgDB.DB, &targetVersion))
+	assert.NoError(t, Rollback(pgDB, &targetVersion))
 
-	cur, err = Current(pgDB.DB)
+	cur, err = Current(pgDB)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(0), cur)
 }

go.work.sum

@@ -660,6 +660,7 @@ github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV
 github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7 h1:6IrxszG5G+O7zhtkWxq6+unVvnrm1fqV2Pe+T95DUzw=
 github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7/go.mod h1:gFnFS95y8HstDP6P9pPwzrxOOC5TRDkwbM+ao15ChAI=
 github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80 h1:DuBDHVjgGMPki7bAyh91+3cF1Vh34sAEdH8JQgbc2R0=
@@ -779,8 +780,6 @@ github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk=
-github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk=
 github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs=
 github.com/fjl/gencodec v0.0.0-20220412091415-8bb9e558978c h1:CndMRAH4JIwxbW8KYq6Q+cGWcGHz0FjGR3QqcInWcW0=
@@ -1560,6 +1559,9 @@ github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZy
 github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
 github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
 github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/testcontainers/testcontainers-go v0.28.0/go.mod h1:COlDpUXbwW3owtpMkEB1zo9gwb1CoKVKlyrVPejF4AU=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0/go.mod h1:lShXm8oldlLck3ltA5u+ShSvUnZ+wiNxwpp8wAQGZ1Y=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0/go.mod h1:fXgcYpbyrduNdiz2qRZuYkmvqLnEqsjbQiBNYH1ystI=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tinylib/msgp v1.0.2 h1:DfdQrzQa7Yh2es9SuLkixqxuXS2SxsdYn0KbdrOGWD8=
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
@@ -1737,8 +1739,6 @@ golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EH
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5 h1:rxKZ2gOnYxjfmakvUUqh9Gyb6KXfrj7JWTxORTYqb0E=
 golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
-golang.org/x/exp v0.0.0-20230510235704-dd950f8aeaea h1:vLCWI/yYrdEHyN2JzIzPO3aaQJHQdp89IZBA/+azVC4=
-golang.org/x/exp v0.0.0-20230510235704-dd950f8aeaea/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
@@ -1768,6 +1768,7 @@ golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1952,6 +1953,7 @@ golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc
 golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=

prover/cmd/app/mock_app.go

@@ -12,7 +12,7 @@ import (
 	"scroll-tech/prover/config"
 
 	"scroll-tech/common/cmd"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 )
@@ -30,7 +30,7 @@ func getIndex() int {
 type ProverApp struct {
 	Config *config.Config
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	originFile string
 	proverFile string
@@ -39,11 +39,11 @@ type ProverApp struct {
 	index int
 	name  string
 	args  []string
-	docker.AppAPI
+	*cmd.Cmd
 }
 
 // NewProverApp return a new proverApp manager.
-func NewProverApp(base *docker.App, mockName utils.MockAppName, file string, httpURL string) *ProverApp {
+func NewProverApp(testApps *testcontainers.TestcontainerApps, mockName utils.MockAppName, file string, httpURL string) *ProverApp {
 	var proofType message.ProofType
 	switch mockName {
 	case utils.ChunkProverApp:
@@ -54,17 +54,17 @@ func NewProverApp(base *docker.App, mockName utils.MockAppName, file string, htt
 		return nil
 	}
 	name := string(mockName)
-	proverFile := fmt.Sprintf("/tmp/%d_%s-config.json", base.Timestamp, name)
+	proverFile := fmt.Sprintf("/tmp/%d_%s-config.json", testApps.Timestamp, name)
 	proverApp := &ProverApp{
-		base:       base,
+		testApps:   testApps,
 		originFile: file,
 		proverFile: proverFile,
-		bboltDB:    fmt.Sprintf("/tmp/%d_%s_bbolt_db", base.Timestamp, name),
+		bboltDB:    fmt.Sprintf("/tmp/%d_%s_bbolt_db", testApps.Timestamp, name),
 		index:      getIndex(),
 		name:       name,
 		args:       []string{"--log.debug", "--config", proverFile},
 	}
-	proverApp.AppAPI = cmd.NewCmd(proverApp.name, proverApp.args...)
+	proverApp.Cmd = cmd.NewCmd(proverApp.name, proverApp.args...)
 	if err := proverApp.MockConfig(true, httpURL, proofType); err != nil {
 		panic(err)
 	}
@@ -73,13 +73,13 @@ func NewProverApp(base *docker.App, mockName utils.MockAppName, file string, htt
 
 // RunApp run prover-test child process by multi parameters.
 func (r *ProverApp) RunApp(t *testing.T) {
-	r.AppAPI.RunApp(func() bool { return r.AppAPI.WaitResult(t, time.Second*40, "prover start successfully") })
+	r.Cmd.RunApp(func() bool { return r.Cmd.WaitResult(t, time.Second*40, "prover start successfully") })
 }
 
 // Free stop and release prover-test.
 func (r *ProverApp) Free() {
-	if !utils.IsNil(r.AppAPI) {
-		r.AppAPI.WaitExit()
+	if !utils.IsNil(r.Cmd) {
+		r.Cmd.WaitExit()
 	}
 	_ = os.Remove(r.proverFile)
 	_ = os.Remove(r.Config.KeystorePath)
@@ -93,8 +93,13 @@ func (r *ProverApp) MockConfig(store bool, httpURL string, proofType message.Pro
 		return err
 	}
 	cfg.ProverName = fmt.Sprintf("%s_%d", r.name, r.index)
-	cfg.KeystorePath = fmt.Sprintf("/tmp/%d_%s.json", r.base.Timestamp, cfg.ProverName)
-	cfg.L2Geth.Endpoint = r.base.L2gethImg.Endpoint()
+	cfg.KeystorePath = fmt.Sprintf("/tmp/%d_%s.json", r.testApps.Timestamp, cfg.ProverName)
+
+	endpoint, err := r.testApps.GetL2GethEndPoint()
+	if err != nil {
+		return err
+	}
+	cfg.L2Geth.Endpoint = endpoint
 	cfg.L2Geth.Confirmations = rpc.LatestBlockNumber
 	// Reuse l1geth's keystore file
 	cfg.KeystorePassword = "scrolltest"

prover/core/prover_test.go

@@ -7,8 +7,11 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"flag"
+	"fmt"
 	"io"
 	"os"
+	"path/filepath"
+	"sort"
 	"testing"
 
 	"github.com/scroll-tech/go-ethereum/core/types"
@@ -24,8 +27,7 @@ var (
 	paramsPath    = flag.String("params", "/assets/test_params", "params dir")
 	assetsPath    = flag.String("assets", "/assets/test_assets", "assets dir")
 	proofDumpPath = flag.String("dump", "/assets/proof_data", "the path proofs dump to")
-	tracePath1    = flag.String("trace1", "/assets/traces/1_transfer.json", "chunk trace 1")
-	tracePath2    = flag.String("trace2", "/assets/traces/10_transfer.json", "chunk trace 2")
+	batchDirPath  = flag.String("batch-dir", "/assets/traces/batch_24", "batch directory")
 	batchVkPath   = flag.String("batch-vk", "/assets/test_assets/agg_vk.vkey", "batch vk")
 	chunkVkPath   = flag.String("chunk-vk", "/assets/test_assets/chunk_vk.vkey", "chunk vk")
 )
@@ -46,23 +48,34 @@ func TestFFI(t *testing.T) {
 	as.Equal(chunkProverCore.VK, readVk(*chunkVkPath, as))
 	t.Log("Chunk VK must be available when init")
 
-	chunkTrace1 := readChunkTrace(*tracePath1, as)
-	chunkTrace2 := readChunkTrace(*tracePath2, as)
-	t.Log("Loaded chunk traces")
+	// Get the list of subdirectories (chunks)
+	chunkDirs, err := os.ReadDir(*batchDirPath)
+	as.NoError(err)
+	sort.Slice(chunkDirs, func(i, j int) bool {
+		return chunkDirs[i].Name() < chunkDirs[j].Name()
+	})
 
-	chunkInfo1, err := chunkProverCore.TracesToChunkInfo(chunkTrace1)
-	as.NoError(err)
-	chunkInfo2, err := chunkProverCore.TracesToChunkInfo(chunkTrace2)
-	as.NoError(err)
-	t.Log("Converted to chunk infos")
+	chunkInfos := make([]*message.ChunkInfo, 0, len(chunkDirs))
+	chunkProofs := make([]*message.ChunkProof, 0, len(chunkDirs))
 
-	chunkProof1, err := chunkProverCore.ProveChunk("chunk_proof1", chunkTrace1)
-	as.NoError(err)
-	t.Log("Generated and dumped chunk proof 1")
+	for i, dir := range chunkDirs {
+		if dir.IsDir() {
+			chunkPath := filepath.Join(*batchDirPath, dir.Name())
 
-	chunkProof2, err := chunkProverCore.ProveChunk("chunk_proof2", chunkTrace2)
-	as.NoError(err)
-	t.Log("Generated and dumped chunk proof 2")
+			chunkTrace := readChunkTrace(chunkPath, as)
+			t.Logf("Loaded chunk trace %d", i+1)
+
+			chunkInfo, err := chunkProverCore.TracesToChunkInfo(chunkTrace)
+			as.NoError(err)
+			chunkInfos = append(chunkInfos, chunkInfo)
+			t.Logf("Converted to chunk info %d", i+1)
+
+			chunkProof, err := chunkProverCore.ProveChunk(fmt.Sprintf("chunk_proof%d", i+1), chunkTrace)
+			as.NoError(err)
+			chunkProofs = append(chunkProofs, chunkProof)
+			t.Logf("Generated and dumped chunk proof %d", i+1)
+		}
+	}
 
 	as.Equal(chunkProverCore.VK, readVk(*chunkVkPath, as))
 	t.Log("Chunk VKs must be equal after proving")
@@ -79,8 +92,6 @@ func TestFFI(t *testing.T) {
 	as.Equal(batchProverCore.VK, readVk(*batchVkPath, as))
 	t.Log("Batch VK must be available when init")
 
-	chunkInfos := []*message.ChunkInfo{chunkInfo1, chunkInfo2}
-	chunkProofs := []*message.ChunkProof{chunkProof1, chunkProof2}
 	_, err = batchProverCore.ProveBatch("batch_proof", chunkInfos, chunkProofs)
 	as.NoError(err)
 	t.Log("Generated and dumped batch proof")
@@ -88,20 +99,46 @@ func TestFFI(t *testing.T) {
 	as.Equal(batchProverCore.VK, readVk(*batchVkPath, as))
 	t.Log("Batch VKs must be equal after proving")
 }
-
 func readChunkTrace(filePat string, as *assert.Assertions) []*types.BlockTrace {
-	f, err := os.Open(filePat)
-	as.NoError(err)
-	defer func() {
-		as.NoError(f.Close())
-	}()
-	byt, err := io.ReadAll(f)
+	fileInfo, err := os.Stat(filePat)
 	as.NoError(err)
 
-	trace := &types.BlockTrace{}
-	as.NoError(json.Unmarshal(byt, trace))
+	var traces []*types.BlockTrace
 
-	return []*types.BlockTrace{trace}
+	readFile := func(path string) {
+		f, err := os.Open(path)
+		as.NoError(err)
+		defer func() {
+			as.NoError(f.Close())
+		}()
+		byt, err := io.ReadAll(f)
+		as.NoError(err)
+
+		trace := &types.BlockTrace{}
+		as.NoError(json.Unmarshal(byt, trace))
+
+		traces = append(traces, trace)
+	}
+
+	if fileInfo.IsDir() {
+		files, err := os.ReadDir(filePat)
+		as.NoError(err)
+
+		// Sort files alphabetically
+		sort.Slice(files, func(i, j int) bool {
+			return files[i].Name() < files[j].Name()
+		})
+
+		for _, file := range files {
+			if !file.IsDir() {
+				readFile(filepath.Join(filePat, file.Name()))
+			}
+		}
+	} else {
+		readFile(filePat)
+	}
+
+	return traces
 }
 
 func readVk(filePat string, as *assert.Assertions) string {

prover/go.mod

@@ -5,7 +5,7 @@ go 1.21
 require (
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/google/uuid v1.6.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	go.etcd.io/bbolt v1.3.7

prover/go.sum

@@ -168,8 +168,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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

rollup/cmd/gas_oracle/app/app.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/urfave/cli/v2"
 
@@ -83,7 +84,7 @@ func action(ctx *cli.Context) error {
 	if err != nil {
 		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, false /* initGenesis */, relayer.ServiceTypeL2GasOracle, registry)
+	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, false /* initGenesis */, relayer.ServiceTypeL2GasOracle, registry)
 	if err != nil {
 		log.Crit("failed to create new l2 relayer", "config file", cfgFile, "error", err)
 	}

rollup/cmd/mock_app.go

@@ -7,19 +7,19 @@ import (
 	"testing"
 	"time"
 
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/docker"
-	"scroll-tech/common/utils"
-
 	"scroll-tech/rollup/internal/config"
+
+	"scroll-tech/common/cmd"
+	"scroll-tech/common/testcontainers"
+	"scroll-tech/common/utils"
 )
 
 // MockApp mockApp-test client manager.
 type MockApp struct {
-	Config *config.Config
-	base   *docker.App
+	Config   *config.Config
+	testApps *testcontainers.TestcontainerApps
 
-	mockApps map[utils.MockAppName]docker.AppAPI
+	mockApps map[utils.MockAppName]*cmd.Cmd
 
 	originFile string
 	rollupFile string
@@ -27,13 +27,12 @@ type MockApp struct {
 	args []string
 }
 
-// NewRollupApp return a new rollupApp manager, name mush be one them.
-func NewRollupApp(base *docker.App, file string) *MockApp {
-
-	rollupFile := fmt.Sprintf("/tmp/%d_rollup-config.json", base.Timestamp)
+// NewRollupApp return a new rollupApp manager.
+func NewRollupApp(testApps *testcontainers.TestcontainerApps, file string) *MockApp {
+	rollupFile := fmt.Sprintf("/tmp/%d_rollup-config.json", testApps.Timestamp)
 	rollupApp := &MockApp{
-		base:       base,
-		mockApps:   make(map[utils.MockAppName]docker.AppAPI),
+		testApps:   testApps,
+		mockApps:   make(map[utils.MockAppName]*cmd.Cmd),
 		originFile: file,
 		rollupFile: rollupFile,
 		args:       []string{"--log.debug", "--config", rollupFile},
@@ -69,7 +68,7 @@ func (b *MockApp) WaitExit() {
 	for _, app := range b.mockApps {
 		app.WaitExit()
 	}
-	b.mockApps = make(map[utils.MockAppName]docker.AppAPI)
+	b.mockApps = make(map[utils.MockAppName]*cmd.Cmd)
 }
 
 // Free stop and release rollup mocked apps.
@@ -80,18 +79,29 @@ func (b *MockApp) Free() {
 
 // MockConfig creates a new rollup config.
 func (b *MockApp) MockConfig(store bool) error {
-	base := b.base
 	// Load origin rollup config file.
 	cfg, err := config.NewConfig(b.originFile)
 	if err != nil {
 		return err
 	}
 
-	cfg.L1Config.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L2Config.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.DBConfig.DSN = base.DBImg.Endpoint()
+	l1GethEndpoint, err := b.testApps.GetL1GethEndPoint()
+	if err != nil {
+		return err
+	}
+	l2GethEndpoint, err := b.testApps.GetL2GethEndPoint()
+	if err != nil {
+		return err
+	}
+	dbEndpoint, err := b.testApps.GetDBEndPoint()
+	if err != nil {
+		return err
+	}
+	cfg.L1Config.Endpoint = l1GethEndpoint
+	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = l2GethEndpoint
+	cfg.L2Config.Endpoint = l2GethEndpoint
+	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = l1GethEndpoint
+	cfg.DBConfig.DSN = dbEndpoint
 	b.Config = cfg
 
 	if !store {

rollup/cmd/rollup_relayer/app/app.go

@@ -72,18 +72,18 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
-	initGenesis := ctx.Bool(utils.ImportGenesisFlag.Name)
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, initGenesis, relayer.ServiceTypeL2RollupRelayer, registry)
-	if err != nil {
-		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
-	}
-
 	genesisPath := ctx.String(utils.Genesis.Name)
 	genesis, err := utils.ReadGenesis(genesisPath)
 	if err != nil {
 		log.Crit("failed to read genesis", "genesis file", genesisPath, "error", err)
 	}
 
+	initGenesis := ctx.Bool(utils.ImportGenesisFlag.Name)
+	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, genesis.Config, initGenesis, relayer.ServiceTypeL2RollupRelayer, registry)
+	if err != nil {
+		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
+	}
+
 	chunkProposer := watcher.NewChunkProposer(subCtx, cfg.L2Config.ChunkProposerConfig, genesis.Config, db, registry)
 	if err != nil {
 		log.Crit("failed to create chunkProposer", "config file", cfgFile, "error", err)

rollup/conf/config.json

@@ -10,11 +10,10 @@
       "sender_config": {
         "endpoint": "https://rpc.scroll.io",
         "escalate_blocks": 1,
-        "confirmations": "0x1",
+        "confirmations": "0x0",
         "escalate_multiple_num": 2,
         "escalate_multiple_den": 1,
         "max_gas_price": 1000000000000,
-        "max_blob_gas_price": 10000000000000,
         "tx_type": "LegacyTx",
         "check_pending_time": 1
       },
@@ -35,7 +34,7 @@
       "sender_config": {
         "endpoint": "https://rpc.ankr.com/eth",
         "escalate_blocks": 1,
-        "confirmations": "0x6",
+        "confirmations": "0x0",
         "escalate_multiple_num": 2,
         "escalate_multiple_den": 1,
         "max_gas_price": 1000000000000,

rollup/go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/holiman/uint256 v1.2.4
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7

rollup/go.sum

@@ -237,8 +237,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/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

rollup/internal/controller/relayer/l2_relayer.go

@@ -13,13 +13,17 @@ import (
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/params"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/encoding/codecv0"
+	"scroll-tech/common/types/encoding/codecv1"
+	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 
 	bridgeAbi "scroll-tech/rollup/abi"
@@ -61,10 +65,12 @@ type Layer2Relayer struct {
 	chainMonitorClient *resty.Client
 
 	metrics *l2RelayerMetrics
+
+	chainCfg *params.ChainConfig
 }
 
 // NewLayer2Relayer will return a new instance of Layer2RelayerClient
-func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, initGenesis bool, serviceType ServiceType, reg prometheus.Registerer) (*Layer2Relayer, error) {
+func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, chainCfg *params.ChainConfig, initGenesis bool, serviceType ServiceType, reg prometheus.Registerer) (*Layer2Relayer, error) {
 	var gasOracleSender, commitSender, finalizeSender *sender.Sender
 	var err error
 
@@ -133,7 +139,8 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		minGasPrice:  minGasPrice,
 		gasPriceDiff: gasPriceDiff,
 
-		cfg: cfg,
+		cfg:      cfg,
+		chainCfg: chainCfg,
 	}
 
 	// chain_monitor client
@@ -189,7 +196,7 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 	err = r.db.Transaction(func(dbTX *gorm.DB) error {
 		var dbChunk *orm.Chunk
-		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, dbTX)
+		dbChunk, err = r.chunkOrm.InsertChunk(r.ctx, chunk, encoding.CodecV0, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert chunk: %v", err)
 		}
@@ -206,7 +213,7 @@ func (r *Layer2Relayer) initializeGenesis() error {
 		}
 
 		var dbBatch *orm.Batch
-		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, dbTX)
+		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert batch: %v", err)
 		}
@@ -239,9 +246,9 @@ func (r *Layer2Relayer) initializeGenesis() error {
 
 func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte, stateRoot common.Hash) error {
 	// encode "importGenesisBatch" transaction calldata
-	calldata, err := r.l1RollupABI.Pack("importGenesisBatch", batchHeader, stateRoot)
-	if err != nil {
-		return fmt.Errorf("failed to pack importGenesisBatch with batch header: %v and state root: %v. error: %v", common.Bytes2Hex(batchHeader), stateRoot, err)
+	calldata, packErr := r.l1RollupABI.Pack("importGenesisBatch", batchHeader, stateRoot)
+	if packErr != nil {
+		return fmt.Errorf("failed to pack importGenesisBatch with batch header: %v and state root: %v. error: %v", common.Bytes2Hex(batchHeader), stateRoot, packErr)
 	}
 
 	// submit genesis batch to L1 rollup contract
@@ -284,8 +291,8 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 func (r *Layer2Relayer) ProcessGasPriceOracle() {
 	r.metrics.rollupL2RelayerGasPriceOraclerRunTotal.Inc()
 	batch, err := r.batchOrm.GetLatestBatch(r.ctx)
-	if batch == nil || err != nil {
-		log.Error("Failed to GetLatestBatch", "batch", batch, "err", err)
+	if err != nil {
+		log.Error("Failed to GetLatestBatch", "err", err)
 		return
 	}
 
@@ -330,95 +337,78 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 // ProcessPendingBatches processes the pending batches by sending commitBatch transactions to layer 1.
 func (r *Layer2Relayer) ProcessPendingBatches() {
 	// get pending batches from database in ascending order by their index.
-	batches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, 5)
+	dbBatches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, 5)
 	if err != nil {
 		log.Error("Failed to fetch pending L2 batches", "err", err)
 		return
 	}
-	for _, batch := range batches {
+	for _, dbBatch := range dbBatches {
 		r.metrics.rollupL2RelayerProcessPendingBatchTotal.Inc()
-		// get current header and parent header.
-		daBatch, err := codecv0.NewDABatchFromBytes(batch.BatchHeader)
-		if err != nil {
-			log.Error("Failed to initialize new DA batch from bytes", "index", batch.Index, "hash", batch.Hash, "err", err)
-			return
-		}
-		parentBatch := &orm.Batch{}
-		if batch.Index > 0 {
-			parentBatch, err = r.batchOrm.GetBatchByIndex(r.ctx, batch.Index-1)
-			if err != nil {
-				log.Error("Failed to get parent batch header", "index", batch.Index-1, "error", err)
-				return
-			}
 
-			if types.RollupStatus(parentBatch.RollupStatus) == types.RollupCommitFailed {
-				log.Error("Previous batch commit failed, halting further committing",
-					"index", parentBatch.Index, "tx hash", parentBatch.CommitTxHash)
-				return
-			}
-		}
-
-		// get the metadata of chunks for the batch
-		dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, batch.StartChunkIndex, batch.EndChunkIndex)
+		dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
 		if err != nil {
-			log.Error("Failed to fetch chunks",
-				"start index", batch.StartChunkIndex,
-				"end index", batch.EndChunkIndex, "error", err)
+			log.Error("failed to get chunks in range", "err", err)
 			return
 		}
 
-		encodedChunks := make([][]byte, len(dbChunks))
+		chunks := make([]*encoding.Chunk, len(dbChunks))
 		for i, c := range dbChunks {
-			var blocks []*encoding.Block
-			blocks, err = r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
-			if err != nil {
-				log.Error("Failed to fetch blocks", "start number", c.StartBlockNumber, "end number", c.EndBlockNumber, "error", err)
+			blocks, getErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
+			if getErr != nil {
+				log.Error("failed to get blocks in range", "err", getErr)
 				return
 			}
-			chunk := &encoding.Chunk{
-				Blocks: blocks,
-			}
-			var daChunk *codecv0.DAChunk
-			daChunk, err = codecv0.NewDAChunk(chunk, c.TotalL1MessagesPoppedBefore)
-			if err != nil {
-				log.Error("Failed to initialize new DA chunk", "start number", c.StartBlockNumber, "end number", c.EndBlockNumber, "error", err)
-				return
-			}
-			var daChunkBytes []byte
-			daChunkBytes, err = daChunk.Encode()
-			if err != nil {
-				log.Error("Failed to encode DA chunk", "start number", c.StartBlockNumber, "end number", c.EndBlockNumber, "error", err)
-				return
-			}
-			encodedChunks[i] = daChunkBytes
+			chunks[i] = &encoding.Chunk{Blocks: blocks}
 		}
 
-		calldata, err := r.l1RollupABI.Pack("commitBatch", daBatch.Version, parentBatch.BatchHeader, encodedChunks, daBatch.SkippedL1MessageBitmap)
-		if err != nil {
-			log.Error("Failed to pack commitBatch", "index", batch.Index, "error", err)
+		if dbBatch.Index == 0 {
+			log.Error("invalid args: batch index is 0, should only happen in committing genesis batch")
 			return
 		}
 
-		// send transaction
-		fallbackGasLimit := uint64(float64(batch.TotalL1CommitGas) * r.cfg.L1CommitGasLimitMultiplier)
-		if types.RollupStatus(batch.RollupStatus) == types.RollupCommitFailed {
-			// use eth_estimateGas if this batch has been committed failed.
-			fallbackGasLimit = 0
-			log.Warn("Batch commit previously failed, using eth_estimateGas for the re-submission", "hash", batch.Hash)
+		dbParentBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, dbBatch.Index-1)
+		if getErr != nil {
+			log.Error("failed to get parent batch header", "err", getErr)
+			return
 		}
-		txHash, err := r.commitSender.SendTransaction(batch.Hash, &r.cfg.RollupContractAddress, calldata, nil, fallbackGasLimit)
+
+		var calldata []byte
+		var blob *kzg4844.Blob
+		if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
+			calldata, err = r.constructCommitBatchPayloadCodecV0(dbBatch, dbParentBatch, dbChunks, chunks)
+			if err != nil {
+				log.Error("failed to construct commitBatch payload codecv0", "index", dbBatch.Index, "err", err)
+				return
+			}
+		} else { // codecv1
+			calldata, blob, err = r.constructCommitBatchPayloadCodecV1(dbBatch, dbParentBatch, dbChunks, chunks)
+			if err != nil {
+				log.Error("failed to construct commitBatch payload codecv1", "index", dbBatch.Index, "err", err)
+				return
+			}
+		}
+
+		// fallbackGasLimit is non-zero only in sending non-blob transactions.
+		fallbackGasLimit := uint64(float64(dbBatch.TotalL1CommitGas) * r.cfg.L1CommitGasLimitMultiplier)
+		if types.RollupStatus(dbBatch.RollupStatus) == types.RollupCommitFailed {
+			// use eth_estimateGas if this batch has been committed and failed at least once.
+			fallbackGasLimit = 0
+			log.Warn("Batch commit previously failed, using eth_estimateGas for the re-submission", "hash", dbBatch.Hash)
+		}
+
+		txHash, err := r.commitSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, blob, fallbackGasLimit)
 		if err != nil {
 			log.Error(
 				"Failed to send commitBatch tx to layer1",
-				"index", batch.Index,
-				"hash", batch.Hash,
+				"index", dbBatch.Index,
+				"hash", dbBatch.Hash,
 				"RollupContractAddress", r.cfg.RollupContractAddress,
 				"err", err,
 			)
 			log.Debug(
 				"Failed to send commitBatch tx to layer1",
-				"index", batch.Index,
-				"hash", batch.Hash,
+				"index", dbBatch.Index,
+				"hash", dbBatch.Hash,
 				"RollupContractAddress", r.cfg.RollupContractAddress,
 				"calldata", common.Bytes2Hex(calldata),
 				"err", err,
@@ -426,13 +416,13 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 			return
 		}
 
-		err = r.batchOrm.UpdateCommitTxHashAndRollupStatus(r.ctx, batch.Hash, txHash.String(), types.RollupCommitting)
+		err = r.batchOrm.UpdateCommitTxHashAndRollupStatus(r.ctx, dbBatch.Hash, txHash.String(), types.RollupCommitting)
 		if err != nil {
-			log.Error("UpdateCommitTxHashAndRollupStatus failed", "hash", batch.Hash, "index", batch.Index, "err", err)
+			log.Error("UpdateCommitTxHashAndRollupStatus failed", "hash", dbBatch.Hash, "index", dbBatch.Index, "err", err)
 			return
 		}
 		r.metrics.rollupL2RelayerProcessPendingBatchSuccessTotal.Inc()
-		log.Info("Sent the commitBatch tx to layer1", "batch index", batch.Index, "batch hash", batch.Hash, "tx hash", txHash.Hex())
+		log.Info("Sent the commitBatch tx to layer1", "batch index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String())
 	}
 }
 
@@ -501,103 +491,98 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 	}
 }
 
-func (r *Layer2Relayer) finalizeBatch(batch *orm.Batch, withProof bool) error {
+func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error {
 	// Check batch status before send `finalizeBatch` tx.
 	if r.cfg.ChainMonitor.Enabled {
 		var batchStatus bool
-		batchStatus, err := r.getBatchStatusByIndex(batch)
+		batchStatus, err := r.getBatchStatusByIndex(dbBatch)
 		if err != nil {
 			r.metrics.rollupL2ChainMonitorLatestFailedCall.Inc()
-			log.Warn("failed to get batch status, please check chain_monitor api server", "batch_index", batch.Index, "err", err)
+			log.Warn("failed to get batch status, please check chain_monitor api server", "batch_index", dbBatch.Index, "err", err)
 			return err
 		}
 		if !batchStatus {
 			r.metrics.rollupL2ChainMonitorLatestFailedBatchStatus.Inc()
-			log.Error("the batch status is not right, stop finalize batch and check the reason", "batch_index", batch.Index)
+			log.Error("the batch status is not right, stop finalize batch and check the reason", "batch_index", dbBatch.Index)
 			return err
 		}
 	}
 
-	var parentBatchStateRoot string
-	if batch.Index > 0 {
-		var parentBatch *orm.Batch
-		parentBatch, err := r.batchOrm.GetBatchByIndex(r.ctx, batch.Index-1)
-		// handle unexpected db error
-		if err != nil {
-			log.Error("Failed to get batch", "index", batch.Index-1, "err", err)
-			return err
-		}
-		parentBatchStateRoot = parentBatch.StateRoot
+	if dbBatch.Index == 0 {
+		return fmt.Errorf("invalid args: batch index is 0, should only happen in finalizing genesis batch")
 	}
 
-	var txCalldata []byte
+	dbParentBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, dbBatch.Index-1)
+	if getErr != nil {
+		return fmt.Errorf("failed to get batch, index: %d, err: %w", dbBatch.Index-1, getErr)
+	}
+
+	dbChunks, err := r.chunkOrm.GetChunksInRange(r.ctx, dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
+	if err != nil {
+		return fmt.Errorf("failed to fetch chunks: %w", err)
+	}
+
+	var aggProof *message.BatchProof
 	if withProof {
-		aggProof, err := r.batchOrm.GetVerifiedProofByHash(r.ctx, batch.Hash)
-		if err != nil {
-			log.Error("get verified proof by hash failed", "hash", batch.Hash, "err", err)
-			return err
+		aggProof, getErr = r.batchOrm.GetVerifiedProofByHash(r.ctx, dbBatch.Hash)
+		if getErr != nil {
+			return fmt.Errorf("failed to get verified proof by hash, index: %d, err: %w", dbBatch.Index, getErr)
 		}
 
 		if err = aggProof.SanityCheck(); err != nil {
-			log.Error("agg_proof sanity check fails", "hash", batch.Hash, "error", err)
-			return err
-		}
-
-		txCalldata, err = r.l1RollupABI.Pack(
-			"finalizeBatchWithProof",
-			batch.BatchHeader,
-			common.HexToHash(parentBatchStateRoot),
-			common.HexToHash(batch.StateRoot),
-			common.HexToHash(batch.WithdrawRoot),
-			aggProof.Proof,
-		)
-		if err != nil {
-			log.Error("Pack finalizeBatchWithProof failed", "err", err)
-			return err
-		}
-	} else {
-		var err error
-		txCalldata, err = r.l1RollupABI.Pack(
-			"finalizeBatch",
-			batch.BatchHeader,
-			common.HexToHash(parentBatchStateRoot),
-			common.HexToHash(batch.StateRoot),
-			common.HexToHash(batch.WithdrawRoot),
-		)
-		if err != nil {
-			log.Error("Pack finalizeBatch failed", "err", err)
-			return err
+			return fmt.Errorf("failed to check agg_proof sanity, index: %d, err: %w", dbBatch.Index, err)
 		}
 	}
 
-	// add suffix `-finalize` to avoid duplication with commit tx in unit tests
-	txHash, err := r.finalizeSender.SendTransaction(batch.Hash, &r.cfg.RollupContractAddress, txCalldata, nil, 0)
-	finalizeTxHash := &txHash
+	var calldata []byte
+	if !r.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) { // codecv0
+		calldata, err = r.constructFinalizeBatchPayloadCodecV0(dbBatch, dbParentBatch, aggProof)
+		if err != nil {
+			return fmt.Errorf("failed to construct commitBatch payload codecv0, index: %v, err: %w", dbBatch.Index, err)
+		}
+	} else { // codecv1
+		chunks := make([]*encoding.Chunk, len(dbChunks))
+		for i, c := range dbChunks {
+			blocks, dbErr := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
+			if dbErr != nil {
+				return fmt.Errorf("failed to fetch blocks: %w", dbErr)
+			}
+			chunks[i] = &encoding.Chunk{Blocks: blocks}
+		}
+
+		calldata, err = r.constructFinalizeBatchPayloadCodecV1(dbBatch, dbParentBatch, dbChunks, chunks, aggProof)
+		if err != nil {
+			return fmt.Errorf("failed to construct commitBatch payload codecv1, index: %v, err: %w", dbBatch.Index, err)
+		}
+	}
+
+	txHash, err := r.finalizeSender.SendTransaction(dbBatch.Hash, &r.cfg.RollupContractAddress, calldata, nil, 0)
 	if err != nil {
 		log.Error(
 			"finalizeBatch in layer1 failed",
 			"with proof", withProof,
-			"index", batch.Index,
-			"hash", batch.Hash,
+			"index", dbBatch.Index,
+			"hash", dbBatch.Hash,
 			"RollupContractAddress", r.cfg.RollupContractAddress,
 			"err", err,
 		)
 		log.Debug(
 			"finalizeBatch in layer1 failed",
 			"with proof", withProof,
-			"index", batch.Index,
-			"hash", batch.Hash,
+			"index", dbBatch.Index,
+			"hash", dbBatch.Hash,
 			"RollupContractAddress", r.cfg.RollupContractAddress,
-			"calldata", common.Bytes2Hex(txCalldata),
+			"calldata", common.Bytes2Hex(calldata),
 			"err", err,
 		)
 		return err
 	}
-	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", batch.Index, "batch hash", batch.Hash, "tx hash", batch.Hash)
+
+	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash)
 
 	// record and sync with db, @todo handle db error
-	if err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, batch.Hash, finalizeTxHash.String(), types.RollupFinalizing); err != nil {
-		log.Error("UpdateFinalizeTxHashAndRollupStatus failed", "index", batch.Index, "batch hash", batch.Hash, "tx hash", finalizeTxHash.String(), "err", err)
+	if err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, dbBatch.Hash, txHash.String(), types.RollupFinalizing); err != nil {
+		log.Error("UpdateFinalizeTxHashAndRollupStatus failed", "index", dbBatch.Index, "batch hash", dbBatch.Hash, "tx hash", txHash.String(), "err", err)
 		return err
 	}
 	r.metrics.rollupL2RelayerProcessCommittedBatchesFinalizedSuccessTotal.Inc()
@@ -729,6 +714,140 @@ func (r *Layer2Relayer) handleL2RollupRelayerConfirmLoop(ctx context.Context) {
 	}
 }
 
+func (r *Layer2Relayer) constructCommitBatchPayloadCodecV0(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, error) {
+	daBatch, err := codecv0.NewDABatchFromBytes(dbBatch.BatchHeader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create DA batch from bytes: %w", err)
+	}
+
+	encodedChunks := make([][]byte, len(dbChunks))
+	for i, c := range dbChunks {
+		daChunk, createErr := codecv0.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
+		if createErr != nil {
+			return nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
+		}
+		daChunkBytes, encodeErr := daChunk.Encode()
+		if encodeErr != nil {
+			return nil, fmt.Errorf("failed to encode DA chunk: %w", encodeErr)
+		}
+		encodedChunks[i] = daChunkBytes
+	}
+
+	calldata, packErr := r.l1RollupABI.Pack("commitBatch", daBatch.Version, dbParentBatch.BatchHeader, encodedChunks, daBatch.SkippedL1MessageBitmap)
+	if packErr != nil {
+		return nil, fmt.Errorf("failed to pack commitBatch: %w", packErr)
+	}
+	return calldata, nil
+}
+
+func (r *Layer2Relayer) constructCommitBatchPayloadCodecV1(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk) ([]byte, *kzg4844.Blob, error) {
+	batch := &encoding.Batch{
+		Index:                      dbBatch.Index,
+		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
+		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
+		Chunks:                     chunks,
+	}
+
+	daBatch, createErr := codecv1.NewDABatch(batch)
+	if createErr != nil {
+		return nil, nil, fmt.Errorf("failed to create DA batch: %w", createErr)
+	}
+
+	encodedChunks := make([][]byte, len(dbChunks))
+	for i, c := range dbChunks {
+		daChunk, createErr := codecv1.NewDAChunk(chunks[i], c.TotalL1MessagesPoppedBefore)
+		if createErr != nil {
+			return nil, nil, fmt.Errorf("failed to create DA chunk: %w", createErr)
+		}
+		encodedChunks[i] = daChunk.Encode()
+	}
+
+	calldata, packErr := r.l1RollupABI.Pack("commitBatch", daBatch.Version, dbParentBatch.BatchHeader, encodedChunks, daBatch.SkippedL1MessageBitmap)
+	if packErr != nil {
+		return nil, nil, fmt.Errorf("failed to pack commitBatch: %w", packErr)
+	}
+	return calldata, daBatch.Blob(), nil
+}
+
+func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV0(dbBatch *orm.Batch, dbParentBatch *orm.Batch, aggProof *message.BatchProof) ([]byte, error) {
+	if aggProof != nil { // finalizeBatch with proof.
+		calldata, packErr := r.l1RollupABI.Pack(
+			"finalizeBatchWithProof",
+			dbBatch.BatchHeader,
+			common.HexToHash(dbParentBatch.StateRoot),
+			common.HexToHash(dbBatch.StateRoot),
+			common.HexToHash(dbBatch.WithdrawRoot),
+			aggProof.Proof,
+		)
+		if packErr != nil {
+			return nil, fmt.Errorf("failed to pack finalizeBatchWithProof: %w", packErr)
+		}
+		return calldata, nil
+	}
+
+	// finalizeBatch without proof.
+	calldata, packErr := r.l1RollupABI.Pack(
+		"finalizeBatch",
+		dbBatch.BatchHeader,
+		common.HexToHash(dbParentBatch.StateRoot),
+		common.HexToHash(dbBatch.StateRoot),
+		common.HexToHash(dbBatch.WithdrawRoot),
+	)
+	if packErr != nil {
+		return nil, fmt.Errorf("failed to pack finalizeBatch: %w", packErr)
+	}
+	return calldata, nil
+}
+
+func (r *Layer2Relayer) constructFinalizeBatchPayloadCodecV1(dbBatch *orm.Batch, dbParentBatch *orm.Batch, dbChunks []*orm.Chunk, chunks []*encoding.Chunk, aggProof *message.BatchProof) ([]byte, error) {
+	batch := &encoding.Batch{
+		Index:                      dbBatch.Index,
+		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
+		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
+		Chunks:                     chunks,
+	}
+
+	daBatch, createErr := codecv1.NewDABatch(batch)
+	if createErr != nil {
+		return nil, fmt.Errorf("failed to create DA batch: %w", createErr)
+	}
+
+	blobDataProof, getErr := daBatch.BlobDataProof()
+	if getErr != nil {
+		return nil, fmt.Errorf("failed to get blob data proof: %w", getErr)
+	}
+
+	if aggProof != nil { // finalizeBatch4844 with proof.
+		calldata, packErr := r.l1RollupABI.Pack(
+			"finalizeBatchWithProof4844",
+			dbBatch.BatchHeader,
+			common.HexToHash(dbParentBatch.StateRoot),
+			common.HexToHash(dbBatch.StateRoot),
+			common.HexToHash(dbBatch.WithdrawRoot),
+			blobDataProof,
+			aggProof.Proof,
+		)
+		if packErr != nil {
+			return nil, fmt.Errorf("failed to pack finalizeBatchWithProof4844: %w", packErr)
+		}
+		return calldata, nil
+	}
+
+	// finalizeBatch4844 without proof.
+	calldata, packErr := r.l1RollupABI.Pack(
+		"finalizeBatch4844",
+		dbBatch.BatchHeader,
+		common.HexToHash(dbParentBatch.StateRoot),
+		common.HexToHash(dbBatch.StateRoot),
+		common.HexToHash(dbBatch.WithdrawRoot),
+		blobDataProof,
+	)
+	if packErr != nil {
+		return nil, fmt.Errorf("failed to pack finalizeBatch4844: %w", packErr)
+	}
+	return calldata, nil
+}
+
 // StopSenders stops the senders of the rollup-relayer to prevent querying the removed pending_transaction table in unit tests.
 // for unit test
 func (r *Layer2Relayer) StopSenders() {

rollup/internal/controller/relayer/l2_relayer_test.go

@@ -11,7 +11,9 @@ import (
 	"github.com/agiledragon/gomonkey/v2"
 	"github.com/gin-gonic/gin"
 	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
@@ -40,128 +42,173 @@ func setupL2RelayerDB(t *testing.T) *gorm.DB {
 func testCreateNewRelayer(t *testing.T) {
 	db := setupL2RelayerDB(t)
 	defer database.CloseDB(db)
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
 }
 
 func testL2RelayerProcessPendingBatches(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV0, encoding.CodecV1}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
-	defer relayer.StopSenders()
+		l2Cfg := cfg.L2Config
+		chainConfig := &params.ChainConfig{}
+		if codecVersion == encoding.CodecV0 {
+			chainConfig.BernoulliBlock = big.NewInt(0)
+		}
 
-	l2BlockOrm := orm.NewL2Block(db)
-	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
-	assert.NoError(t, err)
-	chunkOrm := orm.NewChunk(db)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk1)
-	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2)
-	assert.NoError(t, err)
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, true, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		patchGuard := gomonkey.ApplyMethodFunc(l2Cli, "SendTransaction", func(_ context.Context, _ *gethTypes.Transaction) error {
+			return nil
+		})
+
+		l2BlockOrm := orm.NewL2Block(db)
+		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+		assert.NoError(t, err)
+		chunkOrm := orm.NewChunk(db)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion)
+		assert.NoError(t, err)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion)
+		assert.NoError(t, err)
+
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion)
+		assert.NoError(t, err)
+
+		relayer.ProcessPendingBatches()
+
+		statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(statuses))
+		assert.Equal(t, types.RollupCommitting, statuses[0])
+		relayer.StopSenders()
+		patchGuard.Reset()
 	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
-	assert.NoError(t, err)
-
-	relayer.ProcessPendingBatches()
-
-	statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(statuses))
-	assert.Equal(t, types.RollupCommitting, statuses[0])
 }
 
 func testL2RelayerProcessCommittedBatches(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV0, encoding.CodecV1}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
-	defer relayer.StopSenders()
+		l2Cfg := cfg.L2Config
+		chainConfig := &params.ChainConfig{}
+		if codecVersion == encoding.CodecV0 {
+			chainConfig.BernoulliBlock = big.NewInt(0)
+		}
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, true, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		l2BlockOrm := orm.NewL2Block(db)
+		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+		assert.NoError(t, err)
+		chunkOrm := orm.NewChunk(db)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion)
+		assert.NoError(t, err)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion)
+		assert.NoError(t, err)
+
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion)
+		assert.NoError(t, err)
+
+		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
+		assert.NoError(t, err)
+
+		err = batchOrm.UpdateProvingStatus(context.Background(), dbBatch.Hash, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+
+		relayer.ProcessCommittedBatches()
+
+		statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(statuses))
+		// no valid proof, rollup status remains the same
+		assert.Equal(t, types.RollupCommitted, statuses[0])
+
+		proof := &message.BatchProof{
+			Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
+		}
+		err = batchOrm.UpdateProofByHash(context.Background(), dbBatch.Hash, proof, 100)
+		assert.NoError(t, err)
+
+		relayer.ProcessCommittedBatches()
+		statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(statuses))
+		assert.Equal(t, types.RollupFinalizing, statuses[0])
+		relayer.StopSenders()
 	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
-	assert.NoError(t, err)
-
-	err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
-	assert.NoError(t, err)
-
-	err = batchOrm.UpdateProvingStatus(context.Background(), dbBatch.Hash, types.ProvingTaskVerified)
-	assert.NoError(t, err)
-
-	relayer.ProcessCommittedBatches()
-
-	statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(statuses))
-	// no valid proof, rollup status remains the same
-	assert.Equal(t, types.RollupCommitted, statuses[0])
-
-	proof := &message.BatchProof{
-		Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
-	}
-	err = batchOrm.UpdateProofByHash(context.Background(), dbBatch.Hash, proof, 100)
-	assert.NoError(t, err)
-
-	relayer.ProcessCommittedBatches()
-	statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
-	assert.NoError(t, err)
-	assert.Equal(t, 1, len(statuses))
-	assert.Equal(t, types.RollupFinalizing, statuses[0])
 }
 
 func testL2RelayerFinalizeTimeoutBatches(t *testing.T) {
-	db := setupL2RelayerDB(t)
-	defer database.CloseDB(db)
+	codecVersions := []encoding.CodecVersion{encoding.CodecV0, encoding.CodecV1}
+	for _, codecVersion := range codecVersions {
+		db := setupL2RelayerDB(t)
+		defer database.CloseDB(db)
 
-	l2Cfg := cfg.L2Config
-	l2Cfg.RelayerConfig.EnableTestEnvBypassFeatures = true
-	l2Cfg.RelayerConfig.FinalizeBatchWithoutProofTimeoutSec = 0
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
-	defer relayer.StopSenders()
+		l2Cfg := cfg.L2Config
+		l2Cfg.RelayerConfig.EnableTestEnvBypassFeatures = true
+		l2Cfg.RelayerConfig.FinalizeBatchWithoutProofTimeoutSec = 0
+		chainConfig := &params.ChainConfig{}
+		if codecVersion == encoding.CodecV0 {
+			chainConfig.BernoulliBlock = big.NewInt(0)
+		}
+		relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, l2Cfg.RelayerConfig, chainConfig, true, ServiceTypeL2RollupRelayer, nil)
+		assert.NoError(t, err)
 
-	batch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		l2BlockOrm := orm.NewL2Block(db)
+		err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+		assert.NoError(t, err)
+		chunkOrm := orm.NewChunk(db)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion)
+		assert.NoError(t, err)
+		_, err = chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion)
+		assert.NoError(t, err)
+
+		batch := &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
+		}
+
+		batchOrm := orm.NewBatch(db)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion)
+		assert.NoError(t, err)
+
+		err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
+		assert.NoError(t, err)
+
+		// Check the database for the updated status using TryTimes.
+		ok := utils.TryTimes(5, func() bool {
+			relayer.ProcessCommittedBatches()
+			statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
+			return err == nil && len(statuses) == 1 && statuses[0] == types.RollupFinalizing
+		})
+		assert.True(t, ok)
+		relayer.StopSenders()
 	}
-
-	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
-	assert.NoError(t, err)
-
-	err = batchOrm.UpdateRollupStatus(context.Background(), dbBatch.Hash, types.RollupCommitted)
-	assert.NoError(t, err)
-
-	// Check the database for the updated status using TryTimes.
-	ok := utils.TryTimes(5, func() bool {
-		relayer.ProcessCommittedBatches()
-		statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{dbBatch.Hash})
-		return err == nil && len(statuses) == 1 && statuses[0] == types.RollupFinalizing
-	})
-	assert.True(t, ok)
 }
 
 func testL2RelayerCommitConfirm(t *testing.T) {
@@ -172,7 +219,7 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 	l2Cfg := cfg.L2Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -182,13 +229,13 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 	batchHashes := make([]string, len(isSuccessful))
 	for i := range batchHashes {
 		batch := &encoding.Batch{
-			Index:                      uint64(i),
+			Index:                      uint64(i + 1),
 			TotalL1MessagePoppedBefore: 0,
 			ParentBatchHash:            common.Hash{},
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		}
 
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 	}
@@ -228,7 +275,7 @@ func testL2RelayerFinalizeConfirm(t *testing.T) {
 	l2Cfg := cfg.L2Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -238,13 +285,13 @@ func testL2RelayerFinalizeConfirm(t *testing.T) {
 	batchHashes := make([]string, len(isSuccessful))
 	for i := range batchHashes {
 		batch := &encoding.Batch{
-			Index:                      uint64(i),
+			Index:                      uint64(i + 1),
 			TotalL1MessagePoppedBefore: 0,
 			ParentBatchHash:            common.Hash{},
 			Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 		}
 
-		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
+		dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
 		assert.NoError(t, err)
 		batchHashes[i] = dbBatch.Hash
 	}
@@ -288,7 +335,7 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 	}
 
 	batchOrm := orm.NewBatch(db)
-	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1)
+	dbBatch1, err := batchOrm.InsertBatch(context.Background(), batch1, encoding.CodecV0)
 	assert.NoError(t, err)
 
 	batch2 := &encoding.Batch{
@@ -298,14 +345,14 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 		Chunks:                     []*encoding.Chunk{chunk2},
 	}
 
-	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2)
+	dbBatch2, err := batchOrm.InsertBatch(context.Background(), batch2, encoding.CodecV0)
 	assert.NoError(t, err)
 
 	// Create and set up the Layer2 Relayer.
 	l2Cfg := cfg.L2Config
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, false, ServiceTypeL2GasOracle, nil)
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, false, ServiceTypeL2GasOracle, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -345,7 +392,7 @@ func testLayer2RelayerProcessGasPriceOracle(t *testing.T) {
 	db := setupL2RelayerDB(t)
 	defer database.CloseDB(db)
 
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, false, ServiceTypeL2GasOracle, nil)
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, false, ServiceTypeL2GasOracle, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, relayer)
 	defer relayer.StopSenders()
@@ -440,32 +487,32 @@ func testGetBatchStatusByIndex(t *testing.T) {
 	db := setupL2RelayerDB(t)
 	defer database.CloseDB(db)
 
+	cfg.L2Config.RelayerConfig.ChainMonitor.Enabled = true
+	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, &params.ChainConfig{}, true, ServiceTypeL2RollupRelayer, nil)
+	assert.NoError(t, err)
+	assert.NotNil(t, relayer)
+	defer relayer.StopSenders()
+
 	l2BlockOrm := orm.NewL2Block(db)
-	err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 	assert.NoError(t, err)
 	chunkOrm := orm.NewChunk(db)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk1)
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk1, encoding.CodecV0)
 	assert.NoError(t, err)
-	_, err = chunkOrm.InsertChunk(context.Background(), chunk2)
+	_, err = chunkOrm.InsertChunk(context.Background(), chunk2, encoding.CodecV0)
 	assert.NoError(t, err)
 
 	batch := &encoding.Batch{
-		Index:                      0,
+		Index:                      1,
 		TotalL1MessagePoppedBefore: 0,
 		ParentBatchHash:            common.Hash{},
 		Chunks:                     []*encoding.Chunk{chunk1, chunk2},
 	}
 
 	batchOrm := orm.NewBatch(db)
-	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch)
+	dbBatch, err := batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
 	assert.NoError(t, err)
 
-	cfg.L2Config.RelayerConfig.ChainMonitor.Enabled = true
-	relayer, err := NewLayer2Relayer(context.Background(), l2Cli, db, cfg.L2Config.RelayerConfig, false, ServiceTypeL2RollupRelayer, nil)
-	assert.NoError(t, err)
-	assert.NotNil(t, relayer)
-	defer relayer.StopSenders()
-
 	status, err := relayer.getBatchStatusByIndex(dbBatch)
 	assert.NoError(t, err)
 	assert.Equal(t, true, status)

rollup/internal/controller/relayer/relayer_test.go

@@ -14,7 +14,8 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	dockercompose "scroll-tech/common/docker-compose/l1"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/encoding/codecv0"
 
@@ -25,7 +26,8 @@ var (
 	// config
 	cfg *config.Config
 
-	base *docker.App
+	testApps     *testcontainers.TestcontainerApps
+	posL1TestEnv *dockercompose.PoSL1TestEnv
 
 	// l2geth client
 	l2Cli *ethclient.Client
@@ -51,15 +53,25 @@ func setupEnv(t *testing.T) {
 	cfg, err = config.NewConfig("../../../conf/config.json")
 	assert.NoError(t, err)
 
-	base.RunImages(t)
+	posL1TestEnv, err = dockercompose.NewPoSL1TestEnv()
+	assert.NoError(t, err, "failed to create PoS L1 test environment")
+	assert.NoError(t, posL1TestEnv.Start(), "failed to start PoS L1 test environment")
 
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
+
+	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = posL1TestEnv.Endpoint()
+	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetL2GethEndPoint()
+	assert.NoError(t, err)
+
+	dsn, err := testApps.GetDBEndPoint()
+	assert.NoError(t, err)
 	cfg.DBConfig = &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
+		DSN:        dsn,
+		DriverName: "postgres",
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
 	}
 	port, err := rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)
@@ -67,7 +79,7 @@ func setupEnv(t *testing.T) {
 	cfg.L2Config.RelayerConfig.ChainMonitor.BaseURL = "http://localhost:" + svrPort
 
 	// Create l2geth client.
-	l2Cli, err = base.L2Client()
+	l2Cli, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
 
 	templateBlockTrace1, err := os.ReadFile("../../../testdata/blockTrace_02.json")
@@ -94,11 +106,15 @@ func setupEnv(t *testing.T) {
 }
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		if posL1TestEnv != nil {
+			posL1TestEnv.Stop()
+		}
+	}()
 	m.Run()
-
-	base.Free()
 }
 
 func TestFunctions(t *testing.T) {

rollup/internal/controller/sender/sender.go

@@ -37,9 +37,6 @@ const (
 
 	// DynamicFeeTxType type for DynamicFeeTx
 	DynamicFeeTxType = "DynamicFeeTx"
-
-	// BlobTxType type for BlobTx
-	BlobTxType = "BlobTx"
 )
 
 // Confirmation struct used to indicate transaction confirmation details
@@ -163,8 +160,9 @@ func (s *Sender) getFeeData(target *common.Address, data []byte, sidecar *gethTy
 	case LegacyTxType:
 		return s.estimateLegacyGas(target, data, fallbackGasLimit)
 	case DynamicFeeTxType:
-		return s.estimateDynamicGas(target, data, baseFee, fallbackGasLimit)
-	case BlobTxType:
+		if sidecar == nil {
+			return s.estimateDynamicGas(target, data, baseFee, fallbackGasLimit)
+		}
 		return s.estimateBlobGas(target, data, sidecar, baseFee, blobBaseFee, fallbackGasLimit)
 	default:
 		return nil, fmt.Errorf("unsupported transaction type: %s", s.config.TxType)
@@ -181,7 +179,7 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 		err     error
 	)
 
-	if s.config.TxType == BlobTxType {
+	if blob != nil {
 		sidecar, err = makeSidecar(blob)
 		if err != nil {
 			log.Error("failed to make sidecar for blob transaction", "error", err)
@@ -235,39 +233,36 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, data
 			Data:     data,
 		}
 	case DynamicFeeTxType:
-		txData = &gethTypes.DynamicFeeTx{
-			Nonce:      nonce,
-			To:         target,
-			Data:       data,
-			Gas:        feeData.gasLimit,
-			AccessList: feeData.accessList,
-			ChainID:    s.chainID,
-			GasTipCap:  feeData.gasTipCap,
-			GasFeeCap:  feeData.gasFeeCap,
-		}
-	case BlobTxType:
-		if target == nil {
-			log.Error("blob transaction to address cannot be nil", "address", s.auth.From.String(), "chainID", s.chainID.Uint64(), "nonce", s.auth.Nonce.Uint64())
-			return nil, errors.New("blob transaction to address cannot be nil")
-		}
-
 		if sidecar == nil {
-			log.Error("blob transaction sidecar cannot be nil", "address", s.auth.From.String(), "chainID", s.chainID.Uint64(), "nonce", s.auth.Nonce.Uint64())
-			return nil, errors.New("blob transaction sidecar cannot be nil")
-		}
+			txData = &gethTypes.DynamicFeeTx{
+				Nonce:      nonce,
+				To:         target,
+				Data:       data,
+				Gas:        feeData.gasLimit,
+				AccessList: feeData.accessList,
+				ChainID:    s.chainID,
+				GasTipCap:  feeData.gasTipCap,
+				GasFeeCap:  feeData.gasFeeCap,
+			}
+		} else {
+			if target == nil {
+				log.Error("blob transaction to address cannot be nil", "address", s.auth.From.String(), "chainID", s.chainID.Uint64(), "nonce", s.auth.Nonce.Uint64())
+				return nil, errors.New("blob transaction to address cannot be nil")
+			}
 
-		txData = &gethTypes.BlobTx{
-			ChainID:    uint256.MustFromBig(s.chainID),
-			Nonce:      nonce,
-			GasTipCap:  uint256.MustFromBig(feeData.gasTipCap),
-			GasFeeCap:  uint256.MustFromBig(feeData.gasFeeCap),
-			Gas:        feeData.gasLimit,
-			To:         *target,
-			Data:       data,
-			AccessList: feeData.accessList,
-			BlobFeeCap: uint256.MustFromBig(feeData.blobGasFeeCap),
-			BlobHashes: sidecar.BlobHashes(),
-			Sidecar:    sidecar,
+			txData = &gethTypes.BlobTx{
+				ChainID:    uint256.MustFromBig(s.chainID),
+				Nonce:      nonce,
+				GasTipCap:  uint256.MustFromBig(feeData.gasTipCap),
+				GasFeeCap:  uint256.MustFromBig(feeData.gasFeeCap),
+				Gas:        feeData.gasLimit,
+				To:         *target,
+				Data:       data,
+				AccessList: feeData.accessList,
+				BlobFeeCap: uint256.MustFromBig(feeData.blobGasFeeCap),
+				BlobHashes: sidecar.BlobHashes(),
+				Sidecar:    sidecar,
+			}
 		}
 	}
 
@@ -357,94 +352,95 @@ func (s *Sender) resubmitTransaction(tx *gethTypes.Transaction, baseFee, blobBas
 		txInfo["adjusted_gas_price"] = gasPrice.Uint64()
 
 	case DynamicFeeTxType:
-		originalGasTipCap := tx.GasTipCap()
-		originalGasFeeCap := tx.GasFeeCap()
+		if tx.BlobTxSidecar() == nil {
+			originalGasTipCap := tx.GasTipCap()
+			originalGasFeeCap := tx.GasFeeCap()
 
-		gasTipCap := new(big.Int).Mul(originalGasTipCap, escalateMultipleNum)
-		gasTipCap = new(big.Int).Div(gasTipCap, escalateMultipleDen)
-		gasFeeCap := new(big.Int).Mul(originalGasFeeCap, escalateMultipleNum)
-		gasFeeCap = new(big.Int).Div(gasFeeCap, escalateMultipleDen)
+			gasTipCap := new(big.Int).Mul(originalGasTipCap, escalateMultipleNum)
+			gasTipCap = new(big.Int).Div(gasTipCap, escalateMultipleDen)
+			gasFeeCap := new(big.Int).Mul(originalGasFeeCap, escalateMultipleNum)
+			gasFeeCap = new(big.Int).Div(gasFeeCap, escalateMultipleDen)
 
-		// adjust for rising basefee
-		currentGasFeeCap := getGasFeeCap(new(big.Int).SetUint64(baseFee), gasTipCap)
-		if gasFeeCap.Cmp(currentGasFeeCap) < 0 {
-			gasFeeCap = currentGasFeeCap
+			// adjust for rising basefee
+			currentGasFeeCap := getGasFeeCap(new(big.Int).SetUint64(baseFee), gasTipCap)
+			if gasFeeCap.Cmp(currentGasFeeCap) < 0 {
+				gasFeeCap = currentGasFeeCap
+			}
+
+			// but don't exceed maxGasPrice
+			if gasFeeCap.Cmp(maxGasPrice) > 0 {
+				gasFeeCap = maxGasPrice
+			}
+
+			// gasTipCap <= gasFeeCap
+			if gasTipCap.Cmp(gasFeeCap) > 0 {
+				gasTipCap = gasFeeCap
+			}
+
+			if originalGasTipCap.Cmp(gasTipCap) == 0 {
+				log.Warn("gas tip cap bump corner case, add 1 wei", "original", originalGasTipCap.Uint64(), "adjusted", gasTipCap.Uint64())
+				gasTipCap = new(big.Int).Add(gasTipCap, big.NewInt(1))
+			}
+
+			if originalGasFeeCap.Cmp(gasFeeCap) == 0 {
+				log.Warn("gas fee cap bump corner case, add 1 wei", "original", originalGasFeeCap.Uint64(), "adjusted", gasFeeCap.Uint64())
+				gasFeeCap = new(big.Int).Add(gasFeeCap, big.NewInt(1))
+			}
+
+			feeData.gasFeeCap = gasFeeCap
+			feeData.gasTipCap = gasTipCap
+			txInfo["original_gas_tip_cap"] = originalGasTipCap.Uint64()
+			txInfo["adjusted_gas_tip_cap"] = gasTipCap.Uint64()
+			txInfo["original_gas_fee_cap"] = originalGasFeeCap.Uint64()
+			txInfo["adjusted_gas_fee_cap"] = gasFeeCap.Uint64()
+		} else {
+			originalGasTipCap := tx.GasTipCap()
+			originalGasFeeCap := tx.GasFeeCap()
+			originalBlobGasFeeCap := tx.BlobGasFeeCap()
+
+			// bumping at least 100%
+			gasTipCap := new(big.Int).Mul(originalGasTipCap, big.NewInt(2))
+			gasFeeCap := new(big.Int).Mul(originalGasFeeCap, big.NewInt(2))
+			blobGasFeeCap := new(big.Int).Mul(originalBlobGasFeeCap, big.NewInt(2))
+
+			// adjust for rising basefee
+			currentGasFeeCap := getGasFeeCap(new(big.Int).SetUint64(baseFee), gasTipCap)
+			if gasFeeCap.Cmp(currentGasFeeCap) < 0 {
+				gasFeeCap = currentGasFeeCap
+			}
+
+			// but don't exceed maxGasPrice
+			if gasFeeCap.Cmp(maxGasPrice) > 0 {
+				gasFeeCap = maxGasPrice
+			}
+
+			// gasTipCap <= gasFeeCap
+			if gasTipCap.Cmp(gasFeeCap) > 0 {
+				gasTipCap = gasFeeCap
+			}
+
+			// adjust for rising blobbasefee
+			currentBlobGasFeeCap := getBlobGasFeeCap(new(big.Int).SetUint64(blobBaseFee))
+			if blobGasFeeCap.Cmp(currentBlobGasFeeCap) < 0 {
+				blobGasFeeCap = currentBlobGasFeeCap
+			}
+
+			// but don't exceed maxBlobGasPrice
+			if blobGasFeeCap.Cmp(maxBlobGasPrice) > 0 {
+				blobGasFeeCap = maxBlobGasPrice
+			}
+
+			feeData.gasFeeCap = gasFeeCap
+			feeData.gasTipCap = gasTipCap
+			feeData.blobGasFeeCap = blobGasFeeCap
+			txInfo["original_gas_tip_cap"] = originalGasTipCap.Uint64()
+			txInfo["adjusted_gas_tip_cap"] = gasTipCap.Uint64()
+			txInfo["original_gas_fee_cap"] = originalGasFeeCap.Uint64()
+			txInfo["adjusted_gas_fee_cap"] = gasFeeCap.Uint64()
+			txInfo["original_blob_gas_fee_cap"] = originalBlobGasFeeCap.Uint64()
+			txInfo["adjusted_blob_gas_fee_cap"] = blobGasFeeCap.Uint64()
 		}
 
-		// but don't exceed maxGasPrice
-		if gasFeeCap.Cmp(maxGasPrice) > 0 {
-			gasFeeCap = maxGasPrice
-		}
-
-		// gasTipCap <= gasFeeCap
-		if gasTipCap.Cmp(gasFeeCap) > 0 {
-			gasTipCap = gasFeeCap
-		}
-
-		if originalGasTipCap.Cmp(gasTipCap) == 0 {
-			log.Warn("gas tip cap bump corner case, add 1 wei", "original", originalGasTipCap.Uint64(), "adjusted", gasTipCap.Uint64())
-			gasTipCap = new(big.Int).Add(gasTipCap, big.NewInt(1))
-		}
-
-		if originalGasFeeCap.Cmp(gasFeeCap) == 0 {
-			log.Warn("gas fee cap bump corner case, add 1 wei", "original", originalGasFeeCap.Uint64(), "adjusted", gasFeeCap.Uint64())
-			gasFeeCap = new(big.Int).Add(gasFeeCap, big.NewInt(1))
-		}
-
-		feeData.gasFeeCap = gasFeeCap
-		feeData.gasTipCap = gasTipCap
-		txInfo["original_gas_tip_cap"] = originalGasTipCap.Uint64()
-		txInfo["adjusted_gas_tip_cap"] = gasTipCap.Uint64()
-		txInfo["original_gas_fee_cap"] = originalGasFeeCap.Uint64()
-		txInfo["adjusted_gas_fee_cap"] = gasFeeCap.Uint64()
-
-	case BlobTxType:
-		originalGasTipCap := tx.GasTipCap()
-		originalGasFeeCap := tx.GasFeeCap()
-		originalBlobGasFeeCap := tx.BlobGasFeeCap()
-
-		// bumping at least 100%
-		gasTipCap := new(big.Int).Mul(originalGasTipCap, big.NewInt(2))
-		gasFeeCap := new(big.Int).Mul(originalGasFeeCap, big.NewInt(2))
-		blobGasFeeCap := new(big.Int).Mul(originalBlobGasFeeCap, big.NewInt(2))
-
-		// adjust for rising basefee
-		currentGasFeeCap := getGasFeeCap(new(big.Int).SetUint64(baseFee), gasTipCap)
-		if gasFeeCap.Cmp(currentGasFeeCap) < 0 {
-			gasFeeCap = currentGasFeeCap
-		}
-
-		// but don't exceed maxGasPrice
-		if gasFeeCap.Cmp(maxGasPrice) > 0 {
-			gasFeeCap = maxGasPrice
-		}
-
-		// gasTipCap <= gasFeeCap
-		if gasTipCap.Cmp(gasFeeCap) > 0 {
-			gasTipCap = gasFeeCap
-		}
-
-		// adjust for rising blobbasefee
-		currentBlobGasFeeCap := getBlobGasFeeCap(new(big.Int).SetUint64(blobBaseFee))
-		if blobGasFeeCap.Cmp(currentBlobGasFeeCap) < 0 {
-			blobGasFeeCap = currentBlobGasFeeCap
-		}
-
-		// but don't exceed maxBlobGasPrice
-		if blobGasFeeCap.Cmp(maxBlobGasPrice) > 0 {
-			blobGasFeeCap = maxBlobGasPrice
-		}
-
-		feeData.gasFeeCap = gasFeeCap
-		feeData.gasTipCap = gasTipCap
-		feeData.blobGasFeeCap = blobGasFeeCap
-		txInfo["original_gas_tip_cap"] = originalGasTipCap.Uint64()
-		txInfo["adjusted_gas_tip_cap"] = gasTipCap.Uint64()
-		txInfo["original_gas_fee_cap"] = originalGasFeeCap.Uint64()
-		txInfo["adjusted_gas_fee_cap"] = gasFeeCap.Uint64()
-		txInfo["original_blob_gas_fee_cap"] = originalBlobGasFeeCap.Uint64()
-		txInfo["adjusted_blob_gas_fee_cap"] = blobGasFeeCap.Uint64()
-
 	default:
 		return nil, fmt.Errorf("unsupported transaction type: %s", s.config.TxType)
 	}

rollup/internal/controller/sender/sender_test.go

@@ -26,9 +26,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
 	dockercompose "scroll-tech/common/docker-compose/l1"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/database/migrate"
 
@@ -38,33 +37,27 @@ import (
 	"scroll-tech/rollup/mock_bridge"
 )
 
-const TXBatch = 50
-
 var (
 	privateKey           *ecdsa.PrivateKey
 	cfg                  *config.Config
-	base                 *docker.App
+	testApps             *testcontainers.TestcontainerApps
 	posL1TestEnv         *dockercompose.PoSL1TestEnv
-	txTypes              = []string{"LegacyTx", "DynamicFeeTx", "BlobTx"}
+	txTypes              = []string{"LegacyTx", "DynamicFeeTx", "DynamicFeeTx"}
+	txBlob               = []*kzg4844.Blob{nil, nil, randBlob()}
 	txUint8Types         = []uint8{0, 2, 3}
 	db                   *gorm.DB
 	testContractsAddress common.Address
 )
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-	defer base.Free()
-
-	var err error
-	posL1TestEnv, err = dockercompose.NewPoSL1TestEnv()
-	if err != nil {
-		log.Crit("failed to create PoS L1 test environment", "err", err)
-	}
-	if err := posL1TestEnv.Start(); err != nil {
-		log.Crit("failed to start PoS L1 test environment", "err", err)
-	}
-	defer posL1TestEnv.Stop()
-
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		if posL1TestEnv != nil {
+			posL1TestEnv.Stop()
+		}
+	}()
 	m.Run()
 }
 
@@ -80,17 +73,18 @@ func setupEnv(t *testing.T) {
 	assert.NoError(t, err)
 	privateKey = priv
 
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = posL1TestEnv.Endpoint()
+	posL1TestEnv, err = dockercompose.NewPoSL1TestEnv()
+	assert.NoError(t, err, "failed to create PoS L1 test environment")
+	assert.NoError(t, posL1TestEnv.Start(), "failed to start PoS L1 test environment")
 
-	base.RunDBImage(t)
-	db, err = database.InitDB(
-		&database.Config{
-			DSN:        base.DBConfig.DSN,
-			DriverName: base.DBConfig.DriverName,
-			MaxOpenNum: base.DBConfig.MaxOpenNum,
-			MaxIdleNum: base.DBConfig.MaxIdleNum,
-		},
-	)
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL1GethContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
+
+	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = posL1TestEnv.Endpoint()
+
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -110,7 +104,7 @@ func setupEnv(t *testing.T) {
 
 	testContractsAddress = crypto.CreateAddress(auth.From, nonce)
 
-	tx := gethTypes.NewContractCreation(nonce, big.NewInt(0), 1000000, big.NewInt(10000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
+	tx := gethTypes.NewContractCreation(nonce, big.NewInt(0), 10000000, big.NewInt(10000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
 	signedTx, err := auth.Signer(auth.From, tx)
 	assert.NoError(t, err)
 	err = l1Client.SendTransaction(context.Background(), signedTx)
@@ -158,14 +152,14 @@ func testNewSender(t *testing.T) {
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
 		// exit by Stop()
-		cfgCopy1 := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy1 := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy1.TxType = txType
 		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		newSender1.Stop()
 
 		// exit by ctx.Done()
-		cfgCopy2 := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy2 := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy2.TxType = txType
 		subCtx, cancel := context.WithCancel(context.Background())
 		_, err = NewSender(subCtx, &cfgCopy2, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
@@ -180,12 +174,12 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
-		hash, err := s.SendTransaction("0", &common.Address{}, nil, randBlob(), 0)
+		hash, err := s.SendTransaction("0", &common.Address{}, nil, txBlob[i], 0)
 		assert.NoError(t, err)
 		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
 		assert.NoError(t, err)
@@ -210,12 +204,12 @@ func testSendAndRetrieveTransaction(t *testing.T) {
 }
 
 func testFallbackGasLimit(t *testing.T) {
-	for _, txType := range txTypes {
+	for i, txType := range txTypes {
 		sqlDB, err := db.DB()
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.Confirmations = rpc.LatestBlockNumber
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
@@ -225,7 +219,7 @@ func testFallbackGasLimit(t *testing.T) {
 		assert.NoError(t, err)
 
 		// FallbackGasLimit = 0
-		txHash0, err := s.SendTransaction("0", &common.Address{}, nil, randBlob(), 0)
+		txHash0, err := s.SendTransaction("0", &common.Address{}, nil, txBlob[i], 0)
 		assert.NoError(t, err)
 		tx0, _, err := client.TransactionByHash(context.Background(), txHash0)
 		assert.NoError(t, err)
@@ -245,7 +239,7 @@ func testFallbackGasLimit(t *testing.T) {
 			},
 		)
 
-		txHash1, err := s.SendTransaction("1", &common.Address{}, nil, randBlob(), 100000)
+		txHash1, err := s.SendTransaction("1", &common.Address{}, nil, txBlob[i], 100000)
 		assert.NoError(t, err)
 		tx1, _, err := client.TransactionByHash(context.Background(), txHash1)
 		assert.NoError(t, err)
@@ -263,8 +257,8 @@ func testFallbackGasLimit(t *testing.T) {
 }
 
 func testResubmitZeroGasPriceTransaction(t *testing.T) {
-	for _, txType := range txTypes {
-		if txType == BlobTxType {
+	for i, txType := range txTypes {
+		if txBlob[i] != nil {
 			continue
 		}
 
@@ -272,7 +266,7 @@ func testResubmitZeroGasPriceTransaction(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
@@ -312,7 +306,7 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
@@ -323,16 +317,20 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 		data, err := l2GasOracleABI.Pack("setL2BaseFee", big.NewInt(int64(i+1)))
 		assert.NoError(t, err)
 
-		sidecar, err := makeSidecar(randBlob())
-		assert.NoError(t, err)
+		var sidecar *gethTypes.BlobTxSidecar
+		if txBlob[i] != nil {
+			sidecar, err = makeSidecar(txBlob[i])
+			assert.NoError(t, err)
+		}
+
 		gasLimit, accessList, err := s.estimateGasLimit(&testContractsAddress, data, sidecar, nil, big.NewInt(1000000000), big.NewInt(1000000000), big.NewInt(1000000000))
 		assert.NoError(t, err)
 
 		if txType == LegacyTxType { // Legacy transactions can not have an access list.
-			assert.Equal(t, uint64(43935), gasLimit)
+			assert.Equal(t, uint64(43956), gasLimit)
 			assert.Nil(t, accessList)
 		} else { // Dynamic fee and blob transactions can have an access list.
-			assert.Equal(t, uint64(43458), gasLimit)
+			assert.Equal(t, uint64(43479), gasLimit)
 			assert.NotNil(t, accessList)
 		}
 
@@ -341,12 +339,12 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 }
 
 func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
-	for _, txType := range txTypes {
+	for i, txType := range txTypes {
 		sqlDB, err := db.DB()
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		// Bump gas price, gas tip cap and gas fee cap just touch the minimum threshold of 10% (default config of geth).
 		cfgCopy.EscalateMultipleNum = 110
 		cfgCopy.EscalateMultipleDen = 100
@@ -360,8 +358,11 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 			blobGasFeeCap: big.NewInt(1000000000),
 			gasLimit:      50000,
 		}
-		sidecar, err := makeSidecar(randBlob())
-		assert.NoError(t, err)
+		var sidecar *gethTypes.BlobTxSidecar
+		if txBlob[i] != nil {
+			sidecar, err = makeSidecar(txBlob[i])
+			assert.NoError(t, err)
+		}
 		tx, err := s.createAndSendTx(feeData, &common.Address{}, nil, sidecar, nil)
 		assert.NoError(t, err)
 		assert.NotNil(t, tx)
@@ -383,8 +384,8 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 }
 
 func testResubmitUnderpricedTransaction(t *testing.T) {
-	for _, txType := range txTypes {
-		if txType == BlobTxType {
+	for i, txType := range txTypes {
+		if txBlob[i] != nil {
 			continue
 		}
 
@@ -392,7 +393,7 @@ func testResubmitUnderpricedTransaction(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		// Bump gas price, gas tip cap and gas fee cap less than 10% (default config of geth).
 		cfgCopy.EscalateMultipleNum = 109
 		cfgCopy.EscalateMultipleDen = 100
@@ -431,7 +432,7 @@ func testResubmitDynamicFeeTransactionWithRisingBaseFee(t *testing.T) {
 	assert.NoError(t, migrate.ResetDB(sqlDB))
 
 	txType := "DynamicFeeTx"
-	cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = txType
 
 	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
@@ -473,9 +474,8 @@ func testResubmitBlobTransactionWithRisingBaseFeeAndBlobBaseFee(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))
 
-	txType := "BlobTx"
-	cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
-	cfgCopy.TxType = txType
+	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
+	cfgCopy.TxType = DynamicFeeTxType
 
 	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 	assert.NoError(t, err)
@@ -531,7 +531,7 @@ func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
 		assert.NoError(t, err)
@@ -572,7 +572,7 @@ func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeFinalizeBatch, db, nil)
@@ -632,7 +632,7 @@ func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeL1GasOracle, db, nil)
@@ -702,7 +702,7 @@ func testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending(t *testing.T
 		assert.NoError(t, err)
 		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.EscalateBlocks = 0
 		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
@@ -777,8 +777,8 @@ func testBlobTransactionWithBlobhashOpContractCall(t *testing.T) {
 	)
 	assert.NoError(t, err)
 
-	cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
-	cfgCopy.TxType = BlobTxType
+	cfgCopy := *cfg.L2Config.RelayerConfig.SenderConfig
+	cfgCopy.TxType = DynamicFeeTxType
 	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeL1GasOracle, db, nil)
 	assert.NoError(t, err)
 	defer s.Stop()

rollup/internal/controller/watcher/batch_proposer.go

@@ -3,6 +3,7 @@ package watcher
 import (
 	"context"
 	"fmt"
+	"math/big"
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
@@ -14,10 +15,10 @@ import (
 
 	"scroll-tech/common/forks"
 	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv0"
 
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/orm"
+	"scroll-tech/rollup/internal/utils"
 )
 
 // BatchProposer proposes batches based on available unbatched chunks.
@@ -36,12 +37,15 @@ type BatchProposer struct {
 	gasCostIncreaseMultiplier       float64
 	forkMap                         map[uint64]bool
 
+	chainCfg *params.ChainConfig
+
 	batchProposerCircleTotal           prometheus.Counter
 	proposeBatchFailureTotal           prometheus.Counter
 	proposeBatchUpdateInfoTotal        prometheus.Counter
 	proposeBatchUpdateInfoFailureTotal prometheus.Counter
 	totalL1CommitGas                   prometheus.Gauge
 	totalL1CommitCalldataSize          prometheus.Gauge
+	totalL1CommitBlobSize              prometheus.Gauge
 	batchChunksNum                     prometheus.Gauge
 	batchFirstBlockTimeoutReached      prometheus.Counter
 	batchChunksProposeNotEnoughTotal   prometheus.Counter
@@ -58,7 +62,7 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, chai
 		"gasCostIncreaseMultiplier", cfg.GasCostIncreaseMultiplier,
 		"forkHeights", forkHeights)
 
-	return &BatchProposer{
+	p := &BatchProposer{
 		ctx:                             ctx,
 		db:                              db,
 		batchOrm:                        orm.NewBatch(db),
@@ -70,6 +74,7 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, chai
 		batchTimeoutSec:                 cfg.BatchTimeoutSec,
 		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
 		forkMap:                         forkMap,
+		chainCfg:                        chainCfg,
 
 		batchProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_batch_circle_total",
@@ -95,6 +100,10 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, chai
 			Name: "rollup_propose_batch_total_l1_call_data_size",
 			Help: "The total l1 call data size",
 		}),
+		totalL1CommitBlobSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_batch_total_l1_commit_blob_size",
+			Help: "The total l1 commit blob size",
+		}),
 		batchChunksNum: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_batch_chunks_number",
 			Help: "The number of chunks in the batch",
@@ -108,22 +117,23 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, chai
 			Help: "Total number of batch chunk propose not enough",
 		}),
 	}
+
+	return p
 }
 
 // TryProposeBatch tries to propose a new batches.
 func (p *BatchProposer) TryProposeBatch() {
 	p.batchProposerCircleTotal.Inc()
-	batch, err := p.proposeBatch()
-	if err != nil {
+	if err := p.proposeBatch(); err != nil {
 		p.proposeBatchFailureTotal.Inc()
 		log.Error("proposeBatchChunks failed", "err", err)
 		return
 	}
-	if batch == nil {
-		return
-	}
-	err = p.db.Transaction(func(dbTX *gorm.DB) error {
-		batch, dbErr := p.batchOrm.InsertBatch(p.ctx, batch, dbTX)
+}
+
+func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion encoding.CodecVersion) error {
+	err := p.db.Transaction(func(dbTX *gorm.DB) error {
+		batch, dbErr := p.batchOrm.InsertBatch(p.ctx, batch, codecVersion, dbTX)
 		if dbErr != nil {
 			log.Warn("BatchProposer.updateBatchInfoInDB insert batch failure",
 				"start chunk index", batch.StartChunkIndex, "end chunk index", batch.EndChunkIndex, "error", dbErr)
@@ -140,22 +150,23 @@ func (p *BatchProposer) TryProposeBatch() {
 		p.proposeBatchUpdateInfoFailureTotal.Inc()
 		log.Error("update batch info in db failed", "err", err)
 	}
+	return nil
 }
 
-func (p *BatchProposer) proposeBatch() (*encoding.Batch, error) {
+func (p *BatchProposer) proposeBatch() error {
 	unbatchedChunkIndex, err := p.batchOrm.GetFirstUnbatchedChunkIndex(p.ctx)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// select at most p.maxChunkNumPerBatch chunks
 	dbChunks, err := p.chunkOrm.GetChunksGEIndex(p.ctx, unbatchedChunkIndex, int(p.maxChunkNumPerBatch))
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if len(dbChunks) == 0 {
-		return nil, nil
+		return nil
 	}
 
 	maxChunksThisBatch := p.maxChunkNumPerBatch
@@ -170,124 +181,89 @@ func (p *BatchProposer) proposeBatch() (*encoding.Batch, error) {
 		}
 	}
 
-	daChunks, err := p.getDAChunks(dbChunks)
-	if err != nil {
-		return nil, err
+	codecVersion := encoding.CodecV0
+	if p.chainCfg.IsBernoulli(new(big.Int).SetUint64(dbChunks[0].StartBlockNumber)) {
+		codecVersion = encoding.CodecV1
 	}
 
-	parentDBBatch, err := p.batchOrm.GetLatestBatch(p.ctx)
+	daChunks, err := p.getDAChunks(dbChunks)
 	if err != nil {
-		return nil, err
+		return err
+	}
+
+	dbParentBatch, err := p.batchOrm.GetLatestBatch(p.ctx)
+	if err != nil {
+		return err
 	}
 
 	var batch encoding.Batch
-	if parentDBBatch != nil {
-		batch.Index = parentDBBatch.Index + 1
-		parentDABatch, err := codecv0.NewDABatchFromBytes(parentDBBatch.BatchHeader)
-		if err != nil {
-			return nil, err
-		}
-		batch.TotalL1MessagePoppedBefore = parentDABatch.TotalL1MessagePopped
-		batch.ParentBatchHash = common.HexToHash(parentDBBatch.Hash)
+	batch.Index = dbParentBatch.Index + 1
+	batch.ParentBatchHash = common.HexToHash(dbParentBatch.Hash)
+	parentBatchEndBlockNumber := daChunks[0].Blocks[0].Header.Number.Uint64() - 1
+	parentBatchCodecVersion := encoding.CodecV0
+	// Genesis batch uses codecv0 encoding, otherwise using bernoulli fork to choose codec version.
+	if dbParentBatch.Index > 0 && p.chainCfg.IsBernoulli(new(big.Int).SetUint64(parentBatchEndBlockNumber)) {
+		parentBatchCodecVersion = encoding.CodecV1
+	}
+	batch.TotalL1MessagePoppedBefore, err = utils.GetTotalL1MessagePoppedBeforeBatch(dbParentBatch.BatchHeader, parentBatchCodecVersion)
+	if err != nil {
+		return err
 	}
 
 	for i, chunk := range daChunks {
 		batch.Chunks = append(batch.Chunks, chunk)
-		totalL1CommitCalldataSize, err := codecv0.EstimateBatchL1CommitCalldataSize(&batch)
-		if err != nil {
-			return nil, err
+		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
+		if calcErr != nil {
+			return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 		}
-		totalL1CommitGas, err := codecv0.EstimateBatchL1CommitGas(&batch)
-		if err != nil {
-			return nil, err
-		}
-		totalOverEstimateL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(totalL1CommitGas))
-		if totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch ||
-			totalOverEstimateL1CommitGas > p.maxL1CommitGasPerBatch {
-			// Check if the first chunk breaks hard limits.
-			// If so, it indicates there are bugs in chunk-proposer, manual fix is needed.
+		totalOverEstimateL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(metrics.L1CommitGas))
+		if metrics.L1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch ||
+			totalOverEstimateL1CommitGas > p.maxL1CommitGasPerBatch ||
+			metrics.L1CommitBlobSize > maxBlobSize {
 			if i == 0 {
-				if totalOverEstimateL1CommitGas > p.maxL1CommitGasPerBatch {
-					return nil, fmt.Errorf(
-						"the first chunk exceeds l1 commit gas limit; start block number: %v, end block number: %v, commit gas: %v, max commit gas limit: %v",
-						dbChunks[0].StartBlockNumber,
-						dbChunks[0].EndBlockNumber,
-						totalL1CommitGas,
-						p.maxL1CommitGasPerBatch,
-					)
-				}
-				if totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch {
-					return nil, fmt.Errorf(
-						"the first chunk exceeds l1 commit calldata size limit; start block number: %v, end block number %v, calldata size: %v, max calldata size limit: %v",
-						dbChunks[0].StartBlockNumber,
-						dbChunks[0].EndBlockNumber,
-						totalL1CommitCalldataSize,
-						p.maxL1CommitCalldataSizePerBatch,
-					)
-				}
+				// The first chunk exceeds hard limits, which indicates a bug in the chunk-proposer, manual fix is needed.
+				return fmt.Errorf("the first chunk exceeds limits; start block number: %v, end block number: %v, limits: %+v, maxChunkNum: %v, maxL1CommitCalldataSize: %v, maxL1CommitGas: %v, maxBlobSize: %v",
+					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, p.maxChunkNumPerBatch, p.maxL1CommitCalldataSizePerBatch, p.maxL1CommitGasPerBatch, maxBlobSize)
 			}
 
 			log.Debug("breaking limit condition in batching",
-				"currentL1CommitCalldataSize", totalL1CommitCalldataSize,
+				"currentL1CommitCalldataSize", metrics.L1CommitCalldataSize,
 				"maxL1CommitCalldataSizePerBatch", p.maxL1CommitCalldataSizePerBatch,
 				"currentOverEstimateL1CommitGas", totalOverEstimateL1CommitGas,
 				"maxL1CommitGasPerBatch", p.maxL1CommitGasPerBatch)
 
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]
 
-			totalL1CommitCalldataSize, err := codecv0.EstimateBatchL1CommitCalldataSize(&batch)
+			metrics, err := utils.CalculateBatchMetrics(&batch, codecVersion)
 			if err != nil {
-				return nil, err
+				return fmt.Errorf("failed to calculate batch metrics: %w", err)
 			}
 
-			totalL1CommitGas, err := codecv0.EstimateBatchL1CommitGas(&batch)
-			if err != nil {
-				return nil, err
-			}
-
-			p.totalL1CommitCalldataSize.Set(float64(totalL1CommitCalldataSize))
-			p.totalL1CommitGas.Set(float64(totalL1CommitGas))
-			p.batchChunksNum.Set(float64(batch.NumChunks()))
-			return &batch, nil
+			p.recordBatchMetrics(metrics)
+			return p.updateDBBatchInfo(&batch, codecVersion)
 		}
 	}
 
+	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codecVersion)
+	if calcErr != nil {
+		return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
+	}
 	currentTimeSec := uint64(time.Now().Unix())
-	if dbChunks[0].StartBlockTime+p.batchTimeoutSec < currentTimeSec ||
-		batch.NumChunks() == maxChunksThisBatch {
-		if dbChunks[0].StartBlockTime+p.batchTimeoutSec < currentTimeSec {
-			log.Warn("first block timeout",
-				"start block number", dbChunks[0].StartBlockNumber,
-				"start block timestamp", dbChunks[0].StartBlockTime,
-				"current time", currentTimeSec,
-			)
-		} else {
-			log.Info("reached maximum number of chunks in batch",
-				"chunk count", batch.NumChunks(),
-			)
-		}
-
-		totalL1CommitCalldataSize, err := codecv0.EstimateBatchL1CommitCalldataSize(&batch)
-		if err != nil {
-			return nil, err
-		}
-
-		totalL1CommitGas, err := codecv0.EstimateBatchL1CommitGas(&batch)
-		if err != nil {
-			return nil, err
-		}
+	if metrics.FirstBlockTimestamp+p.batchTimeoutSec < currentTimeSec || metrics.NumChunks == maxChunksThisBatch {
+		log.Info("reached maximum number of chunks in batch or first block timeout",
+			"chunk count", metrics.NumChunks,
+			"start block number", dbChunks[0].StartBlockNumber,
+			"start block timestamp", dbChunks[0].StartBlockTime,
+			"current time", currentTimeSec)
 
 		p.batchFirstBlockTimeoutReached.Inc()
-		p.totalL1CommitCalldataSize.Set(float64(totalL1CommitCalldataSize))
-		p.totalL1CommitGas.Set(float64(totalL1CommitGas))
-		p.batchChunksNum.Set(float64(batch.NumChunks()))
-
-		return &batch, nil
+		p.recordBatchMetrics(metrics)
+		return p.updateDBBatchInfo(&batch, codecVersion)
 	}
 
 	log.Debug("pending chunks do not reach one of the constraints or contain a timeout block")
 	p.batchChunksProposeNotEnoughTotal.Inc()
-	return nil, nil
+	return nil
 }
 
 func (p *BatchProposer) getDAChunks(dbChunks []*orm.Chunk) ([]*encoding.Chunk, error) {
@@ -304,3 +280,10 @@ func (p *BatchProposer) getDAChunks(dbChunks []*orm.Chunk) ([]*encoding.Chunk, e
 	}
 	return chunks, nil
 }
+
+func (p *BatchProposer) recordBatchMetrics(metrics *utils.BatchMetrics) {
+	p.totalL1CommitGas.Set(float64(metrics.L1CommitGas))
+	p.totalL1CommitCalldataSize.Set(float64(metrics.L1CommitCalldataSize))
+	p.batchChunksNum.Set(float64(metrics.NumChunks))
+	p.totalL1CommitBlobSize.Set(float64(metrics.L1CommitBlobSize))
+}

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -2,9 +2,12 @@ package watcher
 
 import (
 	"context"
+	"math"
 	"math/big"
 	"testing"
 
+	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
 
@@ -16,7 +19,7 @@ import (
 	"scroll-tech/rollup/internal/orm"
 )
 
-func testBatchProposerLimits(t *testing.T) {
+func testBatchProposerCodecv0Limits(t *testing.T) {
 	tests := []struct {
 		name                       string
 		maxChunkNum                uint64
@@ -104,8 +107,31 @@ func testBatchProposerLimits(t *testing.T) {
 			db := setupDB(t)
 			defer database.CloseDB(db)
 
+			// Add genesis batch.
+			block := &encoding.Block{
+				Header: &gethTypes.Header{
+					Number: big.NewInt(0),
+				},
+				RowConsumption: &gethTypes.RowConsumption{},
+			}
+			chunk := &encoding.Chunk{
+				Blocks: []*encoding.Block{block},
+			}
+			chunkOrm := orm.NewChunk(db)
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0)
+			assert.NoError(t, err)
+			batch := &encoding.Batch{
+				Index:                      0,
+				TotalL1MessagePoppedBefore: 0,
+				ParentBatchHash:            common.Hash{},
+				Chunks:                     []*encoding.Chunk{chunk},
+			}
+			batchOrm := orm.NewBatch(db)
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
+			assert.NoError(t, err)
+
 			l2BlockOrm := orm.NewL2Block(db)
-			err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+			err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 			assert.NoError(t, err)
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
@@ -122,8 +148,7 @@ func testBatchProposerLimits(t *testing.T) {
 			cp.TryProposeChunk() // chunk1 contains block1
 			cp.TryProposeChunk() // chunk2 contains block2
 
-			chunkOrm := orm.NewChunk(db)
-			chunks, err := chunkOrm.GetChunksInRange(context.Background(), 0, 1)
+			chunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
 			assert.NoError(t, err)
 			assert.Equal(t, uint64(6042), chunks[0].TotalL1CommitGas)
 			assert.Equal(t, uint64(298), chunks[0].TotalL1CommitCalldataSize)
@@ -141,17 +166,142 @@ func testBatchProposerLimits(t *testing.T) {
 			}, db, nil)
 			bp.TryProposeBatch()
 
-			batchOrm := orm.NewBatch(db)
 			batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
 			assert.NoError(t, err)
-			assert.Len(t, batches, tt.expectedBatchesLen)
+			assert.Len(t, batches, tt.expectedBatchesLen+1)
+			batches = batches[1:]
 			if tt.expectedBatchesLen > 0 {
-				assert.Equal(t, uint64(0), batches[0].StartChunkIndex)
-				assert.Equal(t, tt.expectedChunksInFirstBatch-1, batches[0].EndChunkIndex)
+				assert.Equal(t, uint64(1), batches[0].StartChunkIndex)
+				assert.Equal(t, tt.expectedChunksInFirstBatch, batches[0].EndChunkIndex)
 				assert.Equal(t, types.RollupPending, types.RollupStatus(batches[0].RollupStatus))
 				assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(batches[0].ProvingStatus))
 
-				dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 0, tt.expectedChunksInFirstBatch-1)
+				dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, tt.expectedChunksInFirstBatch)
+				assert.NoError(t, err)
+				assert.Len(t, dbChunks, int(tt.expectedChunksInFirstBatch))
+				for _, chunk := range dbChunks {
+					assert.Equal(t, batches[0].Hash, chunk.BatchHash)
+					assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(chunk.ProvingStatus))
+				}
+			}
+		})
+	}
+}
+
+func testBatchProposerCodecv1Limits(t *testing.T) {
+	tests := []struct {
+		name                       string
+		maxChunkNum                uint64
+		batchTimeoutSec            uint64
+		forkBlock                  *big.Int
+		expectedBatchesLen         int
+		expectedChunksInFirstBatch uint64 // only be checked when expectedBatchesLen > 0
+	}{
+		{
+			name:               "NoLimitReached",
+			maxChunkNum:        10,
+			batchTimeoutSec:    1000000000000,
+			expectedBatchesLen: 0,
+		},
+		{
+			name:                       "Timeout",
+			maxChunkNum:                10,
+			batchTimeoutSec:            0,
+			expectedBatchesLen:         1,
+			expectedChunksInFirstBatch: 2,
+		},
+		{
+			name:                       "MaxChunkNumPerBatchIs1",
+			maxChunkNum:                1,
+			batchTimeoutSec:            1000000000000,
+			expectedBatchesLen:         1,
+			expectedChunksInFirstBatch: 1,
+		},
+		{
+			name:                       "ForkBlockReached",
+			maxChunkNum:                10,
+			batchTimeoutSec:            1000000000000,
+			expectedBatchesLen:         1,
+			expectedChunksInFirstBatch: 1,
+			forkBlock:                  big.NewInt(3),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := setupDB(t)
+			defer database.CloseDB(db)
+
+			// Add genesis batch.
+			block := &encoding.Block{
+				Header: &gethTypes.Header{
+					Number: big.NewInt(0),
+				},
+				RowConsumption: &gethTypes.RowConsumption{},
+			}
+			chunk := &encoding.Chunk{
+				Blocks: []*encoding.Block{block},
+			}
+			chunkOrm := orm.NewChunk(db)
+			_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV1)
+			assert.NoError(t, err)
+			batch := &encoding.Batch{
+				Index:                      0,
+				TotalL1MessagePoppedBefore: 0,
+				ParentBatchHash:            common.Hash{},
+				Chunks:                     []*encoding.Chunk{chunk},
+			}
+			batchOrm := orm.NewBatch(db)
+			_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV1)
+			assert.NoError(t, err)
+
+			l2BlockOrm := orm.NewL2Block(db)
+			err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+			assert.NoError(t, err)
+
+			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+				MaxBlockNumPerChunk:             1,
+				MaxTxNumPerChunk:                10000,
+				MaxL1CommitGasPerChunk:          1,
+				MaxL1CommitCalldataSizePerChunk: 1,
+				MaxRowConsumptionPerChunk:       1000000,
+				ChunkTimeoutSec:                 300,
+				GasCostIncreaseMultiplier:       1.2,
+			}, &params.ChainConfig{
+				BernoulliBlock: big.NewInt(0), HomesteadBlock: tt.forkBlock,
+			}, db, nil)
+			cp.TryProposeChunk() // chunk1 contains block1
+			cp.TryProposeChunk() // chunk2 contains block2
+
+			chunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
+			assert.NoError(t, err)
+			assert.Equal(t, uint64(0), chunks[0].TotalL1CommitGas)
+			assert.Equal(t, uint64(0), chunks[0].TotalL1CommitCalldataSize)
+			assert.Equal(t, uint64(0), chunks[1].TotalL1CommitGas)
+			assert.Equal(t, uint64(0), chunks[1].TotalL1CommitCalldataSize)
+
+			bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+				MaxChunkNumPerBatch:             tt.maxChunkNum,
+				MaxL1CommitGasPerBatch:          1,
+				MaxL1CommitCalldataSizePerBatch: 1,
+				BatchTimeoutSec:                 tt.batchTimeoutSec,
+				GasCostIncreaseMultiplier:       1.2,
+			}, &params.ChainConfig{
+				BernoulliBlock: big.NewInt(0), HomesteadBlock: tt.forkBlock,
+			}, db, nil)
+			bp.TryProposeBatch()
+
+			batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
+			assert.NoError(t, err)
+			assert.Len(t, batches, tt.expectedBatchesLen+1)
+			batches = batches[1:]
+			if tt.expectedBatchesLen > 0 {
+				assert.Equal(t, uint64(1), batches[0].StartChunkIndex)
+				assert.Equal(t, tt.expectedChunksInFirstBatch, batches[0].EndChunkIndex)
+				assert.Equal(t, types.RollupPending, types.RollupStatus(batches[0].RollupStatus))
+				assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(batches[0].ProvingStatus))
+
+				dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, tt.expectedChunksInFirstBatch)
 				assert.NoError(t, err)
 				assert.Len(t, dbChunks, int(tt.expectedChunksInFirstBatch))
 				for _, chunk := range dbChunks {
@@ -167,8 +317,31 @@ func testBatchCommitGasAndCalldataSizeEstimation(t *testing.T) {
 	db := setupDB(t)
 	defer database.CloseDB(db)
 
+	// Add genesis batch.
+	block := &encoding.Block{
+		Header: &gethTypes.Header{
+			Number: big.NewInt(0),
+		},
+		RowConsumption: &gethTypes.RowConsumption{},
+	}
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{block},
+	}
+	chunkOrm := orm.NewChunk(db)
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV0)
+	assert.NoError(t, err)
+	batch := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
+	assert.NoError(t, err)
+
 	l2BlockOrm := orm.NewL2Block(db)
-	err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
 	assert.NoError(t, err)
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
@@ -183,8 +356,7 @@ func testBatchCommitGasAndCalldataSizeEstimation(t *testing.T) {
 	cp.TryProposeChunk() // chunk1 contains block1
 	cp.TryProposeChunk() // chunk2 contains block2
 
-	chunkOrm := orm.NewChunk(db)
-	chunks, err := chunkOrm.GetChunksInRange(context.Background(), 0, 1)
+	chunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
 	assert.NoError(t, err)
 	assert.Equal(t, uint64(6042), chunks[0].TotalL1CommitGas)
 	assert.Equal(t, uint64(298), chunks[0].TotalL1CommitCalldataSize)
@@ -200,16 +372,16 @@ func testBatchCommitGasAndCalldataSizeEstimation(t *testing.T) {
 	}, &params.ChainConfig{}, db, nil)
 	bp.TryProposeBatch()
 
-	batchOrm := orm.NewBatch(db)
 	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
 	assert.NoError(t, err)
-	assert.Len(t, batches, 1)
-	assert.Equal(t, uint64(0), batches[0].StartChunkIndex)
-	assert.Equal(t, uint64(1), batches[0].EndChunkIndex)
+	assert.Len(t, batches, 2)
+	batches = batches[1:]
+	assert.Equal(t, uint64(1), batches[0].StartChunkIndex)
+	assert.Equal(t, uint64(2), batches[0].EndChunkIndex)
 	assert.Equal(t, types.RollupPending, types.RollupStatus(batches[0].RollupStatus))
 	assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(batches[0].ProvingStatus))
 
-	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 0, 1)
+	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 1, 2)
 	assert.NoError(t, err)
 	assert.Len(t, dbChunks, 2)
 	for _, chunk := range dbChunks {
@@ -220,3 +392,76 @@ func testBatchCommitGasAndCalldataSizeEstimation(t *testing.T) {
 	assert.Equal(t, uint64(258383), batches[0].TotalL1CommitGas)
 	assert.Equal(t, uint64(6035), batches[0].TotalL1CommitCalldataSize)
 }
+
+func testBatchProposerBlobSizeLimit(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	// Add genesis batch.
+	block := &encoding.Block{
+		Header: &gethTypes.Header{
+			Number: big.NewInt(0),
+		},
+		RowConsumption: &gethTypes.RowConsumption{},
+	}
+	chunk := &encoding.Chunk{
+		Blocks: []*encoding.Block{block},
+	}
+	chunkOrm := orm.NewChunk(db)
+	_, err := chunkOrm.InsertChunk(context.Background(), chunk, encoding.CodecV1)
+	assert.NoError(t, err)
+	batch := &encoding.Batch{
+		Index:                      0,
+		TotalL1MessagePoppedBefore: 0,
+		ParentBatchHash:            common.Hash{},
+		Chunks:                     []*encoding.Chunk{chunk},
+	}
+	batchOrm := orm.NewBatch(db)
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV1)
+	assert.NoError(t, err)
+
+	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:             math.MaxUint64,
+		MaxTxNumPerChunk:                math.MaxUint64,
+		MaxL1CommitGasPerChunk:          1,
+		MaxL1CommitCalldataSizePerChunk: 1,
+		MaxRowConsumptionPerChunk:       math.MaxUint64,
+		ChunkTimeoutSec:                 math.MaxUint64,
+		GasCostIncreaseMultiplier:       1,
+	}, &params.ChainConfig{BernoulliBlock: big.NewInt(0)}, db, nil)
+
+	block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
+	for total := int64(0); total < 7; total++ {
+		for i := int64(0); i < 10; i++ {
+			l2BlockOrm := orm.NewL2Block(db)
+			block.Header.Number = big.NewInt(total*10 + i + 1)
+			err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
+			assert.NoError(t, err)
+		}
+		cp.TryProposeChunk()
+	}
+
+	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxChunkNumPerBatch:             math.MaxUint64,
+		MaxL1CommitGasPerBatch:          1,
+		MaxL1CommitCalldataSizePerBatch: 1,
+		BatchTimeoutSec:                 math.MaxUint64,
+		GasCostIncreaseMultiplier:       1,
+	}, &params.ChainConfig{BernoulliBlock: big.NewInt(0)}, db, nil)
+
+	for i := 0; i < 10; i++ {
+		bp.TryProposeBatch()
+	}
+
+	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
+	batches = batches[1:]
+	assert.NoError(t, err)
+	assert.Len(t, batches, 4)
+	for i, batch := range batches {
+		expected := uint64(2 * (i + 1))
+		if expected > 7 {
+			expected = 7
+		}
+		assert.Equal(t, expected, batch.EndChunkIndex)
+	}
+}

rollup/internal/controller/watcher/chunk_proposer.go

@@ -13,12 +13,14 @@ import (
 
 	"scroll-tech/common/forks"
 	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv0"
 
 	"scroll-tech/rollup/internal/config"
 	"scroll-tech/rollup/internal/orm"
+	"scroll-tech/rollup/internal/utils"
 )
 
+const maxBlobSize = uint64(131072)
+
 // ChunkProposer proposes chunks based on available unchunked blocks.
 type ChunkProposer struct {
 	ctx context.Context
@@ -36,6 +38,8 @@ type ChunkProposer struct {
 	gasCostIncreaseMultiplier       float64
 	forkHeights                     []uint64
 
+	chainCfg *params.ChainConfig
+
 	chunkProposerCircleTotal           prometheus.Counter
 	proposeChunkFailureTotal           prometheus.Counter
 	proposeChunkUpdateInfoTotal        prometheus.Counter
@@ -43,6 +47,7 @@ type ChunkProposer struct {
 	chunkTxNum                         prometheus.Gauge
 	chunkEstimateL1CommitGas           prometheus.Gauge
 	totalL1CommitCalldataSize          prometheus.Gauge
+	totalL1CommitBlobSize              prometheus.Gauge
 	maxTxConsumption                   prometheus.Gauge
 	chunkBlocksNum                     prometheus.Gauge
 	chunkFirstBlockTimeoutReached      prometheus.Counter
@@ -61,7 +66,7 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, chai
 		"gasCostIncreaseMultiplier", cfg.GasCostIncreaseMultiplier,
 		"forkHeights", forkHeights)
 
-	return &ChunkProposer{
+	p := &ChunkProposer{
 		ctx:                             ctx,
 		db:                              db,
 		chunkOrm:                        orm.NewChunk(db),
@@ -74,6 +79,7 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, chai
 		chunkTimeoutSec:                 cfg.ChunkTimeoutSec,
 		gasCostIncreaseMultiplier:       cfg.GasCostIncreaseMultiplier,
 		forkHeights:                     forkHeights,
+		chainCfg:                        chainCfg,
 
 		chunkProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_chunk_circle_total",
@@ -103,6 +109,10 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, chai
 			Name: "rollup_propose_chunk_total_l1_commit_call_data_size",
 			Help: "The total l1 commit call data size",
 		}),
+		totalL1CommitBlobSize: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "rollup_propose_chunk_total_l1_commit_blob_size",
+			Help: "The total l1 commit blob size",
+		}),
 		maxTxConsumption: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
 			Name: "rollup_propose_chunk_max_tx_consumption",
 			Help: "The max tx consumption",
@@ -120,32 +130,28 @@ func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, chai
 			Help: "Total number of chunk block propose not enough",
 		}),
 	}
+
+	return p
 }
 
 // TryProposeChunk tries to propose a new chunk.
 func (p *ChunkProposer) TryProposeChunk() {
 	p.chunkProposerCircleTotal.Inc()
-	proposedChunk, err := p.proposeChunk()
-	if err != nil {
+	if err := p.proposeChunk(); err != nil {
 		p.proposeChunkFailureTotal.Inc()
 		log.Error("propose new chunk failed", "err", err)
 		return
 	}
-
-	if err := p.updateChunkInfoInDB(proposedChunk); err != nil {
-		p.proposeChunkUpdateInfoFailureTotal.Inc()
-		log.Error("update chunk info in orm failed", "err", err)
-	}
 }
 
-func (p *ChunkProposer) updateChunkInfoInDB(chunk *encoding.Chunk) error {
+func (p *ChunkProposer) updateDBChunkInfo(chunk *encoding.Chunk, codecVersion encoding.CodecVersion) error {
 	if chunk == nil {
 		return nil
 	}
 
 	p.proposeChunkUpdateInfoTotal.Inc()
 	err := p.db.Transaction(func(dbTX *gorm.DB) error {
-		dbChunk, err := p.chunkOrm.InsertChunk(p.ctx, chunk, dbTX)
+		dbChunk, err := p.chunkOrm.InsertChunk(p.ctx, chunk, codecVersion, dbTX)
 		if err != nil {
 			log.Warn("ChunkProposer.InsertChunk failed", "err", err)
 			return err
@@ -156,13 +162,18 @@ func (p *ChunkProposer) updateChunkInfoInDB(chunk *encoding.Chunk) error {
 		}
 		return nil
 	})
-	return err
+	if err != nil {
+		p.proposeChunkUpdateInfoFailureTotal.Inc()
+		log.Error("update chunk info in orm failed", "err", err)
+		return err
+	}
+	return nil
 }
 
-func (p *ChunkProposer) proposeChunk() (*encoding.Chunk, error) {
+func (p *ChunkProposer) proposeChunk() error {
 	unchunkedBlockHeight, err := p.chunkOrm.GetUnchunkedBlockHeight(p.ctx)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	maxBlocksThisChunk := p.maxBlockNumPerChunk
@@ -174,157 +185,91 @@ func (p *ChunkProposer) proposeChunk() (*encoding.Chunk, error) {
 	// select at most maxBlocksThisChunk blocks
 	blocks, err := p.l2BlockOrm.GetL2BlocksGEHeight(p.ctx, unchunkedBlockHeight, int(maxBlocksThisChunk))
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if len(blocks) == 0 {
-		return nil, nil
+		return nil
+	}
+
+	codecVersion := encoding.CodecV0
+	if p.chainCfg.IsBernoulli(blocks[0].Header.Number) {
+		codecVersion = encoding.CodecV1
 	}
 
 	var chunk encoding.Chunk
 	for i, block := range blocks {
 		chunk.Blocks = append(chunk.Blocks, block)
 
-		crcMax, err := chunk.CrcMax()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get crc max: %w", err)
+		metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+		if calcErr != nil {
+			return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 		}
 
-		totalTxNum := chunk.NumTransactions()
-
-		totalL1CommitCalldataSize, err := codecv0.EstimateChunkL1CommitCalldataSize(&chunk)
-		if err != nil {
-			return nil, fmt.Errorf("failed to estimate chunk L1 commit calldata size: %w", err)
-		}
-
-		totalL1CommitGas, err := codecv0.EstimateChunkL1CommitGas(&chunk)
-		if err != nil {
-			return nil, fmt.Errorf("failed to estimate chunk L1 commit gas: %w", err)
-		}
-
-		totalOverEstimateL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(totalL1CommitGas))
-
-		if totalTxNum > p.maxTxNumPerChunk ||
-			totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk ||
-			totalOverEstimateL1CommitGas > p.maxL1CommitGasPerChunk ||
-			crcMax > p.maxRowConsumptionPerChunk {
-			// Check if the first block breaks hard limits.
-			// If so, it indicates there are bugs in sequencer, manual fix is needed.
+		overEstimatedL1CommitGas := uint64(p.gasCostIncreaseMultiplier * float64(metrics.L1CommitGas))
+		if metrics.TxNum > p.maxTxNumPerChunk ||
+			metrics.L1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk ||
+			overEstimatedL1CommitGas > p.maxL1CommitGasPerChunk ||
+			metrics.CrcMax > p.maxRowConsumptionPerChunk ||
+			metrics.L1CommitBlobSize > maxBlobSize {
 			if i == 0 {
-				if totalTxNum > p.maxTxNumPerChunk {
-					return nil, fmt.Errorf(
-						"the first block exceeds l2 tx number limit; block number: %v, number of transactions: %v, max transaction number limit: %v",
-						block.Header.Number,
-						totalTxNum,
-						p.maxTxNumPerChunk,
-					)
-				}
-
-				if totalOverEstimateL1CommitGas > p.maxL1CommitGasPerChunk {
-					return nil, fmt.Errorf(
-						"the first block exceeds l1 commit gas limit; block number: %v, commit gas: %v, max commit gas limit: %v",
-						block.Header.Number,
-						totalL1CommitGas,
-						p.maxL1CommitGasPerChunk,
-					)
-				}
-
-				if totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk {
-					return nil, fmt.Errorf(
-						"the first block exceeds l1 commit calldata size limit; block number: %v, calldata size: %v, max calldata size limit: %v",
-						block.Header.Number,
-						totalL1CommitCalldataSize,
-						p.maxL1CommitCalldataSizePerChunk,
-					)
-				}
-
-				if crcMax > p.maxRowConsumptionPerChunk {
-					return nil, fmt.Errorf(
-						"the first block exceeds row consumption limit; block number: %v, crc max: %v, limit: %v",
-						block.Header.Number,
-						crcMax,
-						p.maxRowConsumptionPerChunk,
-					)
-				}
+				// The first block exceeds hard limits, which indicates a bug in the sequencer, manual fix is needed.
+				return fmt.Errorf("the first block exceeds limits; block number: %v, limits: %+v, maxTxNum: %v, maxL1CommitCalldataSize: %v, maxL1CommitGas: %v, maxRowConsumption: %v, maxBlobSize: %v",
+					block.Header.Number, metrics, p.maxTxNumPerChunk, p.maxL1CommitCalldataSizePerChunk, p.maxL1CommitGasPerChunk, p.maxRowConsumptionPerChunk, maxBlobSize)
 			}
 
 			log.Debug("breaking limit condition in chunking",
-				"totalTxNum", totalTxNum,
-				"maxTxNumPerChunk", p.maxTxNumPerChunk,
-				"currentL1CommitCalldataSize", totalL1CommitCalldataSize,
-				"maxL1CommitCalldataSizePerChunk", p.maxL1CommitCalldataSizePerChunk,
-				"currentOverEstimateL1CommitGas", totalOverEstimateL1CommitGas,
-				"maxL1CommitGasPerChunk", p.maxL1CommitGasPerChunk,
-				"chunkRowConsumptionMax", crcMax,
-				"p.maxRowConsumptionPerChunk", p.maxRowConsumptionPerChunk)
+				"txNum", metrics.TxNum,
+				"maxTxNum", p.maxTxNumPerChunk,
+				"l1CommitCalldataSize", metrics.L1CommitCalldataSize,
+				"maxL1CommitCalldataSize", p.maxL1CommitCalldataSizePerChunk,
+				"overEstimatedL1CommitGas", overEstimatedL1CommitGas,
+				"maxL1CommitGas", p.maxL1CommitGasPerChunk,
+				"rowConsumption", metrics.CrcMax,
+				"maxRowConsumption", p.maxRowConsumptionPerChunk,
+				"maxBlobSize", maxBlobSize)
 
 			chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
 
-			crcMax, err := chunk.CrcMax()
-			if err != nil {
-				return nil, fmt.Errorf("failed to get crc max: %w", err)
+			metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+			if calcErr != nil {
+				return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
 			}
 
-			totalL1CommitCalldataSize, err := codecv0.EstimateChunkL1CommitCalldataSize(&chunk)
-			if err != nil {
-				return nil, fmt.Errorf("failed to estimate chunk L1 commit calldata size: %w", err)
-			}
-
-			totalL1CommitGas, err := codecv0.EstimateChunkL1CommitGas(&chunk)
-			if err != nil {
-				return nil, fmt.Errorf("failed to estimate chunk L1 commit gas: %w", err)
-			}
-
-			p.chunkTxNum.Set(float64(chunk.NumTransactions()))
-			p.totalL1CommitCalldataSize.Set(float64(totalL1CommitCalldataSize))
-			p.chunkEstimateL1CommitGas.Set(float64(totalL1CommitGas))
-			p.maxTxConsumption.Set(float64(crcMax))
-			p.chunkBlocksNum.Set(float64(len(chunk.Blocks)))
-			return &chunk, nil
+			p.recordChunkMetrics(metrics)
+			return p.updateDBChunkInfo(&chunk, codecVersion)
 		}
 	}
 
+	metrics, calcErr := utils.CalculateChunkMetrics(&chunk, codecVersion)
+	if calcErr != nil {
+		return fmt.Errorf("failed to calculate chunk metrics: %w", calcErr)
+	}
+
 	currentTimeSec := uint64(time.Now().Unix())
-	if chunk.Blocks[0].Header.Time+p.chunkTimeoutSec < currentTimeSec ||
-		uint64(len(chunk.Blocks)) == maxBlocksThisChunk {
-		if chunk.Blocks[0].Header.Time+p.chunkTimeoutSec < currentTimeSec {
-			log.Warn("first block timeout",
-				"block number", chunk.Blocks[0].Header.Number,
-				"block timestamp", chunk.Blocks[0].Header.Time,
-				"current time", currentTimeSec,
-			)
-		} else {
-			log.Info("reached maximum number of blocks in chunk",
-				"start block number", chunk.Blocks[0].Header.Number,
-				"block count", len(chunk.Blocks),
-			)
-		}
-
-		crcMax, err := chunk.CrcMax()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get crc max: %w", err)
-		}
-
-		totalL1CommitCalldataSize, err := codecv0.EstimateChunkL1CommitCalldataSize(&chunk)
-		if err != nil {
-			return nil, fmt.Errorf("failed to estimate chunk L1 commit calldata size: %w", err)
-		}
-
-		totalL1CommitGas, err := codecv0.EstimateChunkL1CommitGas(&chunk)
-		if err != nil {
-			return nil, fmt.Errorf("failed to estimate chunk L1 commit gas: %w", err)
-		}
+	if metrics.FirstBlockTimestamp+p.chunkTimeoutSec < currentTimeSec || metrics.NumBlocks == maxBlocksThisChunk {
+		log.Info("reached maximum number of blocks in chunk or first block timeout",
+			"start block number", chunk.Blocks[0].Header.Number,
+			"block count", len(chunk.Blocks),
+			"block number", chunk.Blocks[0].Header.Number,
+			"block timestamp", metrics.FirstBlockTimestamp,
+			"current time", currentTimeSec)
 
 		p.chunkFirstBlockTimeoutReached.Inc()
-		p.chunkTxNum.Set(float64(chunk.NumTransactions()))
-		p.totalL1CommitCalldataSize.Set(float64(totalL1CommitCalldataSize))
-		p.chunkEstimateL1CommitGas.Set(float64(totalL1CommitGas))
-		p.maxTxConsumption.Set(float64(crcMax))
-		p.chunkBlocksNum.Set(float64(len(chunk.Blocks)))
-		return &chunk, nil
+		p.recordChunkMetrics(metrics)
+		return p.updateDBChunkInfo(&chunk, codecVersion)
 	}
 
 	log.Debug("pending blocks do not reach one of the constraints or contain a timeout block")
 	p.chunkBlocksProposeNotEnoughTotal.Inc()
-	return nil, nil
+	return nil
+}
+
+func (p *ChunkProposer) recordChunkMetrics(metrics *utils.ChunkMetrics) {
+	p.chunkTxNum.Set(float64(metrics.TxNum))
+	p.maxTxConsumption.Set(float64(metrics.CrcMax))
+	p.chunkBlocksNum.Set(float64(metrics.NumBlocks))
+	p.totalL1CommitCalldataSize.Set(float64(metrics.L1CommitCalldataSize))
+	p.chunkEstimateL1CommitGas.Set(float64(metrics.L1CommitGas))
+	p.totalL1CommitBlobSize.Set(float64(metrics.L1CommitBlobSize))
 }

rollup/internal/controller/watcher/chunk_proposer_test.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/scroll-tech/go-ethereum/common/math"
 	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
 
@@ -15,7 +16,7 @@ import (
 	"scroll-tech/rollup/internal/orm"
 )
 
-func testChunkProposerLimits(t *testing.T) {
+func testChunkProposerCodecv0Limits(t *testing.T) {
 	tests := []struct {
 		name                       string
 		maxBlockNum                uint64
@@ -198,3 +199,164 @@ func testChunkProposerLimits(t *testing.T) {
 		})
 	}
 }
+
+func testChunkProposerCodecv1Limits(t *testing.T) {
+	tests := []struct {
+		name                       string
+		maxBlockNum                uint64
+		maxTxNum                   uint64
+		maxRowConsumption          uint64
+		chunkTimeoutSec            uint64
+		forkBlock                  *big.Int
+		expectedChunksLen          int
+		expectedBlocksInFirstChunk int // only be checked when expectedChunksLen > 0
+	}{
+		{
+			name:              "NoLimitReached",
+			maxBlockNum:       100,
+			maxTxNum:          10000,
+			maxRowConsumption: 1000000,
+			chunkTimeoutSec:   1000000000000,
+			expectedChunksLen: 0,
+		},
+		{
+			name:                       "Timeout",
+			maxBlockNum:                100,
+			maxTxNum:                   10000,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            0,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 2,
+		},
+		{
+			name:              "MaxTxNumPerChunkIs0",
+			maxBlockNum:       10,
+			maxTxNum:          0,
+			maxRowConsumption: 1000000,
+			chunkTimeoutSec:   1000000000000,
+			expectedChunksLen: 0,
+		},
+		{
+			name:              "MaxRowConsumptionPerChunkIs0",
+			maxBlockNum:       100,
+			maxTxNum:          10000,
+			maxRowConsumption: 0,
+			chunkTimeoutSec:   1000000000000,
+			expectedChunksLen: 0,
+		},
+		{
+			name:                       "MaxBlockNumPerChunkIs1",
+			maxBlockNum:                1,
+			maxTxNum:                   10000,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxTxNumPerChunkIsFirstBlock",
+			maxBlockNum:                10,
+			maxTxNum:                   2,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "MaxRowConsumptionPerChunkIs1",
+			maxBlockNum:                10,
+			maxTxNum:                   10000,
+			maxRowConsumption:          1,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+		},
+		{
+			name:                       "ForkBlockReached",
+			maxBlockNum:                100,
+			maxTxNum:                   10000,
+			maxRowConsumption:          1000000,
+			chunkTimeoutSec:            1000000000000,
+			expectedChunksLen:          1,
+			expectedBlocksInFirstChunk: 1,
+			forkBlock:                  big.NewInt(2),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := setupDB(t)
+			defer database.CloseDB(db)
+
+			l2BlockOrm := orm.NewL2Block(db)
+			err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+			assert.NoError(t, err)
+
+			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+				MaxBlockNumPerChunk:             tt.maxBlockNum,
+				MaxTxNumPerChunk:                tt.maxTxNum,
+				MaxL1CommitGasPerChunk:          1,
+				MaxL1CommitCalldataSizePerChunk: 1,
+				MaxRowConsumptionPerChunk:       tt.maxRowConsumption,
+				ChunkTimeoutSec:                 tt.chunkTimeoutSec,
+				GasCostIncreaseMultiplier:       1.2,
+			}, &params.ChainConfig{BernoulliBlock: big.NewInt(0), HomesteadBlock: tt.forkBlock}, db, nil)
+			cp.TryProposeChunk()
+
+			chunkOrm := orm.NewChunk(db)
+			chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
+			assert.NoError(t, err)
+			assert.Len(t, chunks, tt.expectedChunksLen)
+
+			if len(chunks) > 0 {
+				blockOrm := orm.NewL2Block(db)
+				chunkHashes, err := blockOrm.GetChunkHashes(context.Background(), tt.expectedBlocksInFirstChunk)
+				assert.NoError(t, err)
+				assert.Len(t, chunkHashes, tt.expectedBlocksInFirstChunk)
+				firstChunkHash := chunks[0].Hash
+				for _, chunkHash := range chunkHashes {
+					assert.Equal(t, firstChunkHash, chunkHash)
+				}
+			}
+		})
+	}
+}
+
+func testChunkProposerCodecv1BlobSizeLimit(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	block := readBlockFromJSON(t, "../../../testdata/blockTrace_02.json")
+	for i := int64(0); i < 2000; i++ {
+		l2BlockOrm := orm.NewL2Block(db)
+		block.Header.Number = big.NewInt(i + 1)
+		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})
+		assert.NoError(t, err)
+	}
+
+	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:             math.MaxUint64,
+		MaxTxNumPerChunk:                math.MaxUint64,
+		MaxL1CommitGasPerChunk:          1,
+		MaxL1CommitCalldataSizePerChunk: 1,
+		MaxRowConsumptionPerChunk:       math.MaxUint64,
+		ChunkTimeoutSec:                 math.MaxUint64,
+		GasCostIncreaseMultiplier:       1,
+	}, &params.ChainConfig{BernoulliBlock: big.NewInt(0)}, db, nil)
+
+	for i := 0; i < 10; i++ {
+		cp.TryProposeChunk()
+	}
+
+	chunkOrm := orm.NewChunk(db)
+	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
+	assert.NoError(t, err)
+	assert.Len(t, chunks, 4)
+	for i, chunk := range chunks {
+		expected := uint64(551 * (i + 1))
+		if expected > 2000 {
+			expected = 2000
+		}
+		assert.Equal(t, expected, chunk.EndBlockNumber)
+	}
+}

rollup/internal/controller/watcher/l1_watcher_test.go

@@ -27,7 +27,7 @@ import (
 
 func setupL1Watcher(t *testing.T) (*L1WatcherClient, *gorm.DB) {
 	db := setupDB(t)
-	client, err := ethclient.Dial(base.L1gethImg.Endpoint())
+	client, err := testApps.GetL1GethClient()
 	assert.NoError(t, err)
 	l1Cfg := cfg.L1Config
 	watcher := NewL1WatcherClient(context.Background(), client, l1Cfg.StartHeight, l1Cfg.Confirmations, l1Cfg.L1MessageQueueAddress, l1Cfg.RelayerConfig.RollupContractAddress, db, nil)

rollup/internal/controller/watcher/l2_watcher.go

@@ -59,7 +59,7 @@ func NewL2WatcherClient(ctx context.Context, client *ethclient.Client, confirmat
 	}
 }
 
-const blockTracesFetchLimit = uint64(10)
+const blocksFetchLimit = uint64(10)
 
 // TryFetchRunningMissingBlocks attempts to fetch and store block traces for any missing blocks.
 func (w *L2WatcherClient) TryFetchRunningMissingBlocks(blockHeight uint64) {
@@ -71,8 +71,8 @@ func (w *L2WatcherClient) TryFetchRunningMissingBlocks(blockHeight uint64) {
 	}
 
 	// Fetch and store block traces for missing blocks
-	for from := heightInDB + 1; from <= blockHeight; from += blockTracesFetchLimit {
-		to := from + blockTracesFetchLimit - 1
+	for from := heightInDB + 1; from <= blockHeight; from += blocksFetchLimit {
+		to := from + blocksFetchLimit - 1
 
 		if to > blockHeight {
 			to = blockHeight

rollup/internal/controller/watcher/watcher_test.go

@@ -11,9 +11,8 @@ import (
 	"gorm.io/gorm"
 
 	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/encoding"
-
 	"scroll-tech/database/migrate"
 
 	"scroll-tech/rollup/internal/config"
@@ -23,7 +22,7 @@ var (
 	// config
 	cfg *config.Config
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	// l2geth client
 	l2Cli *ethclient.Client
@@ -42,40 +41,32 @@ func setupEnv(t *testing.T) (err error) {
 	cfg, err = config.NewConfig("../../../conf/config.json")
 	assert.NoError(t, err)
 
-	base.RunImages(t)
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL1GethContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
 
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
+	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetL1GethEndPoint()
+	assert.NoError(t, err)
+	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetL2GethEndPoint()
+	assert.NoError(t, err)
+
+	dsn, err := testApps.GetDBEndPoint()
+	assert.NoError(t, err)
 	cfg.DBConfig = &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
+		DSN:        dsn,
+		DriverName: "postgres",
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
 	}
 
 	// Create l2geth client.
-	l2Cli, err = base.L2Client()
+	l2Cli, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
 
-	templateBlockTrace1, err := os.ReadFile("../../../testdata/blockTrace_02.json")
-	if err != nil {
-		return err
-	}
-	// unmarshal blockTrace
-	block1 = &encoding.Block{}
-	if err = json.Unmarshal(templateBlockTrace1, block1); err != nil {
-		return err
-	}
+	block1 = readBlockFromJSON(t, "../../../testdata/blockTrace_02.json")
+	block2 = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
 
-	templateBlockTrace2, err := os.ReadFile("../../../testdata/blockTrace_03.json")
-	if err != nil {
-		return err
-	}
-	// unmarshal blockTrace
-	block2 = &encoding.Block{}
-	if err = json.Unmarshal(templateBlockTrace2, block2); err != nil {
-		return err
-	}
 	return err
 }
 
@@ -89,11 +80,12 @@ func setupDB(t *testing.T) *gorm.DB {
 }
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+	}()
 	m.Run()
-
-	base.Free()
 }
 
 func TestFunction(t *testing.T) {
@@ -113,9 +105,22 @@ func TestFunction(t *testing.T) {
 	t.Run("TestFetchRunningMissingBlocks", testFetchRunningMissingBlocks)
 
 	// Run chunk proposer test cases.
-	t.Run("TestChunkProposerLimits", testChunkProposerLimits)
+	t.Run("TestChunkProposerCodecv0Limits", testChunkProposerCodecv0Limits)
+	t.Run("TestChunkProposerCodecv1Limits", testChunkProposerCodecv1Limits)
+	t.Run("TestChunkProposerCodecv1BlobSizeLimit", testChunkProposerCodecv1BlobSizeLimit)
 
 	// Run chunk proposer test cases.
-	t.Run("TestBatchProposerLimits", testBatchProposerLimits)
+	t.Run("TestBatchProposerCodecv0Limits", testBatchProposerCodecv0Limits)
+	t.Run("TestBatchProposerCodecv1Limits", testBatchProposerCodecv1Limits)
 	t.Run("TestBatchCommitGasAndCalldataSizeEstimation", testBatchCommitGasAndCalldataSizeEstimation)
+	t.Run("TestBatchProposerBlobSizeLimit", testBatchProposerBlobSizeLimit)
+}
+
+func readBlockFromJSON(t *testing.T, filename string) *encoding.Block {
+	data, err := os.ReadFile(filename)
+	assert.NoError(t, err)
+
+	block := &encoding.Block{}
+	assert.NoError(t, json.Unmarshal(data, block))
+	return block
 }

rollup/internal/orm/batch.go

@@ -7,14 +7,15 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv0"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 
-	"github.com/scroll-tech/go-ethereum/log"
-	"gorm.io/gorm"
+	rutils "scroll-tech/rollup/internal/utils"
 )
 
 // Batch represents a batch of chunks.
@@ -136,9 +137,6 @@ func (o *Batch) GetLatestBatch(ctx context.Context) (*Batch, error) {
 
 	var latestBatch Batch
 	if err := db.First(&latestBatch).Error; err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
 		return nil, fmt.Errorf("Batch.GetLatestBatch error: %w", err)
 	}
 	return &latestBatch, nil
@@ -149,12 +147,7 @@ func (o *Batch) GetFirstUnbatchedChunkIndex(ctx context.Context) (uint64, error)
 	// Get the latest batch
 	latestBatch, err := o.GetLatestBatch(ctx)
 	if err != nil {
-		return 0, fmt.Errorf("Chunk.GetChunkedBlockHeight error: %w", err)
-	}
-	// if parentBatch==nil then err==gorm.ErrRecordNotFound,
-	// which means there is not batched chunk yet, thus returns 0
-	if latestBatch == nil {
-		return 0, nil
+		return 0, fmt.Errorf("Batch.GetFirstUnbatchedChunkIndex error: %w", err)
 	}
 	return latestBatch.EndChunkIndex + 1, nil
 }
@@ -226,7 +219,7 @@ func (o *Batch) GetBatchByIndex(ctx context.Context, index uint64) (*Batch, erro
 }
 
 // InsertBatch inserts a new batch into the database.
-func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, dbTX ...*gorm.DB) (*Batch, error) {
+func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVersion encoding.CodecVersion, dbTX ...*gorm.DB) (*Batch, error) {
 	if batch == nil {
 		return nil, errors.New("invalid args: batch is nil")
 	}
@@ -236,94 +229,48 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, dbTX ...
 		return nil, errors.New("invalid args: batch contains 0 chunk")
 	}
 
-	daBatch, err := codecv0.NewDABatch(batch)
+	metrics, err := rutils.CalculateBatchMetrics(batch, codecVersion)
 	if err != nil {
-		log.Error("failed to create new DA batch",
+		log.Error("failed to calculate batch metrics",
 			"index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
 			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
-		return nil, err
-	}
-
-	totalL1CommitGas, err := codecv0.EstimateBatchL1CommitGas(batch)
-	if err != nil {
-		log.Error("failed to estimate batch L1 commit gas",
-			"index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", len(batch.Chunks), "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
-	}
-
-	totalL1CommitCalldataSize, err := codecv0.EstimateBatchL1CommitCalldataSize(batch)
-	if err != nil {
-		log.Error("failed to estimate batch L1 commit calldata size",
-			"index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", len(batch.Chunks), "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
 	}
 
 	var startChunkIndex uint64
-	parentBatch, err := o.GetLatestBatch(ctx)
-	if err != nil {
-		log.Error("failed to get latest batch", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
-	}
-
-	// if parentBatch==nil then err==gorm.ErrRecordNotFound, which means there's
-	// no batch record in the db, we then use default empty values for the creating batch;
-	// if parentBatch!=nil then err==nil, then we fill the parentBatch-related data into the creating batch
-	if parentBatch != nil {
+	if batch.Index > 0 {
+		parentBatch, getErr := o.GetBatchByIndex(ctx, batch.Index-1)
+		if getErr != nil {
+			log.Error("failed to get batch by index", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
+				"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", getErr)
+			return nil, fmt.Errorf("Batch.InsertBatch error: %w", getErr)
+		}
 		startChunkIndex = parentBatch.EndChunkIndex + 1
 	}
 
-	startDAChunk, err := codecv0.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
+	batchMeta, err := rutils.GetBatchMetadata(batch, codecVersion)
 	if err != nil {
-		log.Error("failed to create start DA chunk", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
-	}
-
-	startDAChunkHash, err := startDAChunk.Hash()
-	if err != nil {
-		log.Error("failed to get start DA chunk hash", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
-	}
-
-	totalL1MessagePoppedBeforeEndDAChunk := batch.TotalL1MessagePoppedBefore
-	for i := uint64(0); i < numChunks-1; i++ {
-		totalL1MessagePoppedBeforeEndDAChunk += batch.Chunks[i].NumL1Messages(totalL1MessagePoppedBeforeEndDAChunk)
-	}
-	endDAChunk, err := codecv0.NewDAChunk(batch.Chunks[numChunks-1], totalL1MessagePoppedBeforeEndDAChunk)
-	if err != nil {
-		log.Error("failed to create end DA chunk", "index", batch.Index, "total l1 message popped before", totalL1MessagePoppedBeforeEndDAChunk,
-			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
-		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
-	}
-
-	endDAChunkHash, err := endDAChunk.Hash()
-	if err != nil {
-		log.Error("failed to get end DA chunk hash", "index", batch.Index, "total l1 message popped before", totalL1MessagePoppedBeforeEndDAChunk,
+		log.Error("failed to get batch metadata", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
 			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
 		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
 	}
 
 	newBatch := Batch{
 		Index:                     batch.Index,
-		Hash:                      daBatch.Hash().Hex(),
-		StartChunkHash:            startDAChunkHash.Hex(),
+		Hash:                      batchMeta.BatchHash.Hex(),
+		StartChunkHash:            batchMeta.StartChunkHash.Hex(),
 		StartChunkIndex:           startChunkIndex,
-		EndChunkHash:              endDAChunkHash.Hex(),
+		EndChunkHash:              batchMeta.EndChunkHash.Hex(),
 		EndChunkIndex:             startChunkIndex + numChunks - 1,
 		StateRoot:                 batch.StateRoot().Hex(),
 		WithdrawRoot:              batch.WithdrawRoot().Hex(),
 		ParentBatchHash:           batch.ParentBatchHash.Hex(),
-		BatchHeader:               daBatch.Encode(),
+		BatchHeader:               batchMeta.BatchBytes,
 		ChunkProofsStatus:         int16(types.ChunkProofsStatusPending),
 		ProvingStatus:             int16(types.ProvingTaskUnassigned),
 		RollupStatus:              int16(types.RollupPending),
 		OracleStatus:              int16(types.GasOraclePending),
-		TotalL1CommitGas:          totalL1CommitGas,
-		TotalL1CommitCalldataSize: totalL1CommitCalldataSize,
+		TotalL1CommitGas:          metrics.L1CommitGas,
+		TotalL1CommitCalldataSize: metrics.L1CommitCalldataSize,
 	}
 
 	db := o.db

rollup/internal/orm/chunk.go

@@ -8,7 +8,8 @@ import (
 
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv0"
+
+	"scroll-tech/rollup/internal/utils"
 
 	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
@@ -110,7 +111,7 @@ func (o *Chunk) GetUnchunkedBlockHeight(ctx context.Context) (uint64, error) {
 	// Get the latest chunk
 	latestChunk, err := o.getLatestChunk(ctx)
 	if err != nil {
-		return 0, fmt.Errorf("Chunk.GetChunkedBlockHeight error: %w", err)
+		return 0, fmt.Errorf("Chunk.GetUnchunkedBlockHeight error: %w", err)
 	}
 	if latestChunk == nil {
 		// if there is no chunk, return block number 1,
@@ -140,7 +141,7 @@ func (o *Chunk) GetChunksGEIndex(ctx context.Context, index uint64, limit int) (
 }
 
 // InsertChunk inserts a new chunk into the database.
-func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, dbTX ...*gorm.DB) (*Chunk, error) {
+func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, codecVersion encoding.CodecVersion, dbTX ...*gorm.DB) (*Chunk, error) {
 	if chunk == nil || len(chunk.Blocks) == 0 {
 		return nil, errors.New("invalid args")
 	}
@@ -165,42 +166,30 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, dbTX ...
 		parentChunkStateRoot = parentChunk.StateRoot
 	}
 
-	daChunk, err := codecv0.NewDAChunk(chunk, totalL1MessagePoppedBefore)
+	metrics, err := utils.CalculateChunkMetrics(chunk, codecVersion)
 	if err != nil {
-		log.Error("failed to initialize new DA chunk", "err", err)
+		log.Error("failed to calculate chunk metrics", "err", err)
 		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
 	}
 
-	daChunkHash, err := daChunk.Hash()
+	chunkHash, err := utils.GetChunkHash(chunk, totalL1MessagePoppedBefore, codecVersion)
 	if err != nil {
-		log.Error("failed to get DA chunk hash", "err", err)
-		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
-	}
-
-	totalL1CommitCalldataSize, err := codecv0.EstimateChunkL1CommitCalldataSize(chunk)
-	if err != nil {
-		log.Error("failed to estimate chunk L1 commit calldata size", "err", err)
-		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
-	}
-
-	totalL1CommitGas, err := codecv0.EstimateChunkL1CommitGas(chunk)
-	if err != nil {
-		log.Error("failed to estimate chunk L1 commit gas", "err", err)
+		log.Error("failed to get chunk hash", "err", err)
 		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
 	}
 
 	numBlocks := len(chunk.Blocks)
 	newChunk := Chunk{
 		Index:                        chunkIndex,
-		Hash:                         daChunkHash.Hex(),
+		Hash:                         chunkHash.Hex(),
 		StartBlockNumber:             chunk.Blocks[0].Header.Number.Uint64(),
 		StartBlockHash:               chunk.Blocks[0].Header.Hash().Hex(),
 		EndBlockNumber:               chunk.Blocks[numBlocks-1].Header.Number.Uint64(),
 		EndBlockHash:                 chunk.Blocks[numBlocks-1].Header.Hash().Hex(),
 		TotalL2TxGas:                 chunk.L2GasUsed(),
 		TotalL2TxNum:                 chunk.NumL2Transactions(),
-		TotalL1CommitCalldataSize:    totalL1CommitCalldataSize,
-		TotalL1CommitGas:             totalL1CommitGas,
+		TotalL1CommitCalldataSize:    metrics.L1CommitCalldataSize,
+		TotalL1CommitGas:             metrics.L1CommitGas,
 		StartBlockTime:               chunk.Blocks[0].Header.Time,
 		TotalL1MessagesPoppedBefore:  totalL1MessagePoppedBefore,
 		TotalL1MessagesPoppedInChunk: chunk.NumL1Messages(totalL1MessagePoppedBefore),

rollup/internal/orm/orm_test.go

@@ -12,16 +12,17 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/database/migrate"
+
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/encoding/codecv0"
-	"scroll-tech/database/migrate"
+	"scroll-tech/common/types/encoding/codecv1"
 )
 
 var (
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	db                    *gorm.DB
 	l2BlockOrm            *L2Block
@@ -29,33 +30,29 @@ var (
 	batchOrm              *Batch
 	pendingTransactionOrm *PendingTransaction
 
-	block1     *encoding.Block
-	block2     *encoding.Block
-	chunk1     *encoding.Chunk
-	chunk2     *encoding.Chunk
-	chunkHash1 common.Hash
-	chunkHash2 common.Hash
+	block1 *encoding.Block
+	block2 *encoding.Block
 )
 
 func TestMain(m *testing.M) {
 	t := &testing.T{}
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		tearDownEnv(t)
+	}()
 	setupEnv(t)
-	defer tearDownEnv(t)
 	m.Run()
 }
 
 func setupEnv(t *testing.T) {
-	base = docker.NewDockerApp()
-	base.RunDBImage(t)
 	var err error
-	db, err = database.InitDB(
-		&database.Config{
-			DSN:        base.DBConfig.DSN,
-			DriverName: base.DBConfig.DriverName,
-			MaxOpenNum: base.DBConfig.MaxOpenNum,
-			MaxIdleNum: base.DBConfig.MaxIdleNum,
-		},
-	)
+
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -77,25 +74,12 @@ func setupEnv(t *testing.T) {
 	block2 = &encoding.Block{}
 	err = json.Unmarshal(templateBlockTrace, block2)
 	assert.NoError(t, err)
-
-	chunk1 = &encoding.Chunk{Blocks: []*encoding.Block{block1}}
-	daChunk1, err := codecv0.NewDAChunk(chunk1, 0)
-	assert.NoError(t, err)
-	chunkHash1, err = daChunk1.Hash()
-	assert.NoError(t, err)
-
-	chunk2 = &encoding.Chunk{Blocks: []*encoding.Block{block2}}
-	daChunk2, err := codecv0.NewDAChunk(chunk2, chunk1.NumL1Messages(0))
-	assert.NoError(t, err)
-	chunkHash2, err = daChunk2.Hash()
-	assert.NoError(t, err)
 }
 
 func tearDownEnv(t *testing.T) {
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	sqlDB.Close()
-	base.Free()
 }
 
 func TestL1BlockOrm(t *testing.T) {
@@ -180,147 +164,196 @@ func TestL2BlockOrm(t *testing.T) {
 }
 
 func TestChunkOrm(t *testing.T) {
-	sqlDB, err := db.DB()
-	assert.NoError(t, err)
-	assert.NoError(t, migrate.ResetDB(sqlDB))
+	codecVersions := []encoding.CodecVersion{encoding.CodecV0, encoding.CodecV1}
+	chunk1 := &encoding.Chunk{Blocks: []*encoding.Block{block1}}
+	chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{block2}}
+	for _, codecVersion := range codecVersions {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+		var chunkHash1 common.Hash
+		var chunkHash2 common.Hash
+		if codecVersion == encoding.CodecV0 {
+			daChunk1, createErr := codecv0.NewDAChunk(chunk1, 0)
+			assert.NoError(t, createErr)
+			chunkHash1, err = daChunk1.Hash()
+			assert.NoError(t, err)
 
-	dbChunk1, err := chunkOrm.InsertChunk(context.Background(), chunk1)
-	assert.NoError(t, err)
-	assert.Equal(t, dbChunk1.Hash, chunkHash1.Hex())
+			daChunk2, createErr := codecv0.NewDAChunk(chunk2, chunk1.NumL1Messages(0))
+			assert.NoError(t, createErr)
+			chunkHash2, err = daChunk2.Hash()
+			assert.NoError(t, err)
+		} else {
+			daChunk1, createErr := codecv1.NewDAChunk(chunk1, 0)
+			assert.NoError(t, createErr)
+			chunkHash1, err = daChunk1.Hash()
+			assert.NoError(t, err)
 
-	dbChunk2, err := chunkOrm.InsertChunk(context.Background(), chunk2)
-	assert.NoError(t, err)
-	assert.Equal(t, dbChunk2.Hash, chunkHash2.Hex())
+			daChunk2, createErr := codecv1.NewDAChunk(chunk2, chunk1.NumL1Messages(0))
+			assert.NoError(t, createErr)
+			chunkHash2, err = daChunk2.Hash()
+			assert.NoError(t, err)
+		}
 
-	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 2)
-	assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
-	assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
-	assert.Equal(t, "", chunks[0].BatchHash)
-	assert.Equal(t, "", chunks[1].BatchHash)
+		dbChunk1, err := chunkOrm.InsertChunk(context.Background(), chunk1, codecVersion)
+		assert.NoError(t, err)
+		assert.Equal(t, dbChunk1.Hash, chunkHash1.Hex())
 
-	err = chunkOrm.UpdateProvingStatus(context.Background(), chunkHash1.Hex(), types.ProvingTaskVerified)
-	assert.NoError(t, err)
-	err = chunkOrm.UpdateProvingStatus(context.Background(), chunkHash2.Hex(), types.ProvingTaskAssigned)
-	assert.NoError(t, err)
+		dbChunk2, err := chunkOrm.InsertChunk(context.Background(), chunk2, codecVersion)
+		assert.NoError(t, err)
+		assert.Equal(t, dbChunk2.Hash, chunkHash2.Hex())
 
-	chunks, err = chunkOrm.GetChunksInRange(context.Background(), 0, 1)
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 2)
-	assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
-	assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
-	assert.Equal(t, types.ProvingTaskVerified, types.ProvingStatus(chunks[0].ProvingStatus))
-	assert.Equal(t, types.ProvingTaskAssigned, types.ProvingStatus(chunks[1].ProvingStatus))
+		chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
+		assert.NoError(t, err)
+		assert.Len(t, chunks, 2)
+		assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
+		assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
+		assert.Equal(t, "", chunks[0].BatchHash)
+		assert.Equal(t, "", chunks[1].BatchHash)
 
-	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 0, "test hash")
-	assert.NoError(t, err)
-	chunks, err = chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 2)
-	assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
-	assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
-	assert.Equal(t, "test hash", chunks[0].BatchHash)
-	assert.Equal(t, "", chunks[1].BatchHash)
+		err = chunkOrm.UpdateProvingStatus(context.Background(), chunkHash1.Hex(), types.ProvingTaskVerified)
+		assert.NoError(t, err)
+		err = chunkOrm.UpdateProvingStatus(context.Background(), chunkHash2.Hex(), types.ProvingTaskAssigned)
+		assert.NoError(t, err)
+
+		chunks, err = chunkOrm.GetChunksInRange(context.Background(), 0, 1)
+		assert.NoError(t, err)
+		assert.Len(t, chunks, 2)
+		assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
+		assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
+		assert.Equal(t, types.ProvingTaskVerified, types.ProvingStatus(chunks[0].ProvingStatus))
+		assert.Equal(t, types.ProvingTaskAssigned, types.ProvingStatus(chunks[1].ProvingStatus))
+
+		err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 0, "test hash")
+		assert.NoError(t, err)
+		chunks, err = chunkOrm.GetChunksGEIndex(context.Background(), 0, 0)
+		assert.NoError(t, err)
+		assert.Len(t, chunks, 2)
+		assert.Equal(t, chunkHash1.Hex(), chunks[0].Hash)
+		assert.Equal(t, chunkHash2.Hex(), chunks[1].Hash)
+		assert.Equal(t, "test hash", chunks[0].BatchHash)
+		assert.Equal(t, "", chunks[1].BatchHash)
+	}
 }
 
 func TestBatchOrm(t *testing.T) {
-	sqlDB, err := db.DB()
-	assert.NoError(t, err)
-	assert.NoError(t, migrate.ResetDB(sqlDB))
+	codecVersions := []encoding.CodecVersion{encoding.CodecV0, encoding.CodecV1}
+	chunk1 := &encoding.Chunk{Blocks: []*encoding.Block{block1}}
+	chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{block2}}
+	for _, codecVersion := range codecVersions {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
 
-	batch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1},
+		batch := &encoding.Batch{
+			Index:                      0,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk1},
+		}
+		batch1, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion)
+		assert.NoError(t, err)
+		hash1 := batch1.Hash
+
+		batch1, err = batchOrm.GetBatchByIndex(context.Background(), 0)
+		assert.NoError(t, err)
+
+		var batchHash1 string
+		if codecVersion == encoding.CodecV0 {
+			daBatch1, createErr := codecv0.NewDABatchFromBytes(batch1.BatchHeader)
+			assert.NoError(t, createErr)
+			batchHash1 = daBatch1.Hash().Hex()
+		} else {
+			daBatch1, createErr := codecv1.NewDABatchFromBytes(batch1.BatchHeader)
+			assert.NoError(t, createErr)
+			batchHash1 = daBatch1.Hash().Hex()
+		}
+		assert.Equal(t, hash1, batchHash1)
+
+		batch = &encoding.Batch{
+			Index:                      1,
+			TotalL1MessagePoppedBefore: 0,
+			ParentBatchHash:            common.Hash{},
+			Chunks:                     []*encoding.Chunk{chunk2},
+		}
+		batch2, err := batchOrm.InsertBatch(context.Background(), batch, codecVersion)
+		assert.NoError(t, err)
+		hash2 := batch2.Hash
+
+		batch2, err = batchOrm.GetBatchByIndex(context.Background(), 1)
+		assert.NoError(t, err)
+
+		var batchHash2 string
+		if codecVersion == encoding.CodecV0 {
+			daBatch2, createErr := codecv0.NewDABatchFromBytes(batch2.BatchHeader)
+			assert.NoError(t, createErr)
+			batchHash2 = daBatch2.Hash().Hex()
+		} else {
+			daBatch2, createErr := codecv1.NewDABatchFromBytes(batch2.BatchHeader)
+			assert.NoError(t, createErr)
+			batchHash2 = daBatch2.Hash().Hex()
+		}
+		assert.Equal(t, hash2, batchHash2)
+
+		count, err := batchOrm.GetBatchCount(context.Background())
+		assert.NoError(t, err)
+		assert.Equal(t, uint64(2), count)
+
+		err = batchOrm.UpdateRollupStatus(context.Background(), batchHash1, types.RollupCommitFailed)
+		assert.NoError(t, err)
+
+		pendingBatches, err := batchOrm.GetFailedAndPendingBatches(context.Background(), 100)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(pendingBatches))
+
+		rollupStatus, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{batchHash1, batchHash2})
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(rollupStatus))
+		assert.Equal(t, types.RollupCommitFailed, rollupStatus[0])
+		assert.Equal(t, types.RollupPending, rollupStatus[1])
+
+		err = batchOrm.UpdateProvingStatus(context.Background(), batchHash2, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+
+		dbProof, err := batchOrm.GetVerifiedProofByHash(context.Background(), batchHash1)
+		assert.Error(t, err)
+		assert.Nil(t, dbProof)
+
+		err = batchOrm.UpdateProvingStatus(context.Background(), batchHash2, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+		err = batchOrm.UpdateRollupStatus(context.Background(), batchHash2, types.RollupFinalized)
+		assert.NoError(t, err)
+		err = batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(context.Background(), batchHash2, types.GasOracleImported, "oracleTxHash")
+		assert.NoError(t, err)
+
+		updatedBatch, err := batchOrm.GetLatestBatch(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, updatedBatch)
+		assert.Equal(t, types.ProvingTaskVerified, types.ProvingStatus(updatedBatch.ProvingStatus))
+		assert.Equal(t, types.RollupFinalized, types.RollupStatus(updatedBatch.RollupStatus))
+		assert.Equal(t, types.GasOracleImported, types.GasOracleStatus(updatedBatch.OracleStatus))
+		assert.Equal(t, "oracleTxHash", updatedBatch.OracleTxHash)
+
+		err = batchOrm.UpdateCommitTxHashAndRollupStatus(context.Background(), batchHash2, "commitTxHash", types.RollupCommitted)
+		assert.NoError(t, err)
+		updatedBatch, err = batchOrm.GetLatestBatch(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, updatedBatch)
+		assert.Equal(t, "commitTxHash", updatedBatch.CommitTxHash)
+		assert.Equal(t, types.RollupCommitted, types.RollupStatus(updatedBatch.RollupStatus))
+
+		err = batchOrm.UpdateFinalizeTxHashAndRollupStatus(context.Background(), batchHash2, "finalizeTxHash", types.RollupFinalizeFailed)
+		assert.NoError(t, err)
+
+		updatedBatch, err = batchOrm.GetLatestBatch(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, updatedBatch)
+		assert.Equal(t, "finalizeTxHash", updatedBatch.FinalizeTxHash)
+		assert.Equal(t, types.RollupFinalizeFailed, types.RollupStatus(updatedBatch.RollupStatus))
 	}
-	batch1, err := batchOrm.InsertBatch(context.Background(), batch)
-	assert.NoError(t, err)
-	hash1 := batch1.Hash
-
-	batch1, err = batchOrm.GetBatchByIndex(context.Background(), 0)
-	assert.NoError(t, err)
-	daBatch1, err := codecv0.NewDABatchFromBytes(batch1.BatchHeader)
-	assert.NoError(t, err)
-	batchHash1 := daBatch1.Hash().Hex()
-	assert.Equal(t, hash1, batchHash1)
-
-	batch = &encoding.Batch{
-		Index:                      1,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{chunk1},
-	}
-	batch2, err := batchOrm.InsertBatch(context.Background(), batch)
-	assert.NoError(t, err)
-	hash2 := batch2.Hash
-
-	batch2, err = batchOrm.GetBatchByIndex(context.Background(), 1)
-	assert.NoError(t, err)
-	daBatch2, err := codecv0.NewDABatchFromBytes(batch2.BatchHeader)
-	assert.NoError(t, err)
-	batchHash2 := daBatch2.Hash().Hex()
-	assert.Equal(t, hash2, batchHash2)
-
-	count, err := batchOrm.GetBatchCount(context.Background())
-	assert.NoError(t, err)
-	assert.Equal(t, uint64(2), count)
-
-	err = batchOrm.UpdateRollupStatus(context.Background(), batchHash1, types.RollupCommitFailed)
-	assert.NoError(t, err)
-
-	pendingBatches, err := batchOrm.GetFailedAndPendingBatches(context.Background(), 100)
-	assert.NoError(t, err)
-	assert.Equal(t, 2, len(pendingBatches))
-
-	rollupStatus, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{batchHash1, batchHash2})
-	assert.NoError(t, err)
-	assert.Equal(t, 2, len(rollupStatus))
-	assert.Equal(t, types.RollupCommitFailed, rollupStatus[0])
-	assert.Equal(t, types.RollupPending, rollupStatus[1])
-
-	err = batchOrm.UpdateProvingStatus(context.Background(), batchHash2, types.ProvingTaskVerified)
-	assert.NoError(t, err)
-
-	dbProof, err := batchOrm.GetVerifiedProofByHash(context.Background(), batchHash1)
-	assert.Error(t, err)
-	assert.Nil(t, dbProof)
-
-	err = batchOrm.UpdateProvingStatus(context.Background(), batchHash2, types.ProvingTaskVerified)
-	assert.NoError(t, err)
-	err = batchOrm.UpdateRollupStatus(context.Background(), batchHash2, types.RollupFinalized)
-	assert.NoError(t, err)
-	err = batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(context.Background(), batchHash2, types.GasOracleImported, "oracleTxHash")
-	assert.NoError(t, err)
-
-	updatedBatch, err := batchOrm.GetLatestBatch(context.Background())
-	assert.NoError(t, err)
-	assert.NotNil(t, updatedBatch)
-	assert.Equal(t, types.ProvingTaskVerified, types.ProvingStatus(updatedBatch.ProvingStatus))
-	assert.Equal(t, types.RollupFinalized, types.RollupStatus(updatedBatch.RollupStatus))
-	assert.Equal(t, types.GasOracleImported, types.GasOracleStatus(updatedBatch.OracleStatus))
-	assert.Equal(t, "oracleTxHash", updatedBatch.OracleTxHash)
-
-	err = batchOrm.UpdateCommitTxHashAndRollupStatus(context.Background(), batchHash2, "commitTxHash", types.RollupCommitted)
-	assert.NoError(t, err)
-	updatedBatch, err = batchOrm.GetLatestBatch(context.Background())
-	assert.NoError(t, err)
-	assert.NotNil(t, updatedBatch)
-	assert.Equal(t, "commitTxHash", updatedBatch.CommitTxHash)
-	assert.Equal(t, types.RollupCommitted, types.RollupStatus(updatedBatch.RollupStatus))
-
-	err = batchOrm.UpdateFinalizeTxHashAndRollupStatus(context.Background(), batchHash2, "finalizeTxHash", types.RollupFinalizeFailed)
-	assert.NoError(t, err)
-
-	updatedBatch, err = batchOrm.GetLatestBatch(context.Background())
-	assert.NoError(t, err)
-	assert.NotNil(t, updatedBatch)
-	assert.Equal(t, "finalizeTxHash", updatedBatch.FinalizeTxHash)
-	assert.Equal(t, types.RollupFinalizeFailed, types.RollupStatus(updatedBatch.RollupStatus))
 }
 
-func TestTransactionOrm(t *testing.T) {
+func TestPendingTransactionOrm(t *testing.T) {
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))

rollup/internal/utils/utils.go

@@ -9,6 +9,10 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto"
 
+	"scroll-tech/common/types/encoding"
+	"scroll-tech/common/types/encoding/codecv0"
+	"scroll-tech/common/types/encoding/codecv1"
+
 	bridgeAbi "scroll-tech/rollup/abi"
 )
 
@@ -63,3 +67,228 @@ func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
 	}
 	return abi.ParseTopics(out, indexed, log.Topics[1:])
 }
+
+// ChunkMetrics indicates the metrics for proposing a chunk.
+type ChunkMetrics struct {
+	// common metrics
+	NumBlocks           uint64
+	TxNum               uint64
+	CrcMax              uint64
+	FirstBlockTimestamp uint64
+
+	// codecv0 metrics, default 0 for codecv1
+	L1CommitCalldataSize uint64
+	L1CommitGas          uint64
+
+	// codecv1 metrics, default 0 for codecv0
+	L1CommitBlobSize uint64
+}
+
+// CalculateChunkMetrics calculates chunk metrics.
+func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVersion) (*ChunkMetrics, error) {
+	var err error
+	metrics := &ChunkMetrics{
+		TxNum:               chunk.NumTransactions(),
+		NumBlocks:           uint64(len(chunk.Blocks)),
+		FirstBlockTimestamp: chunk.Blocks[0].Header.Time,
+	}
+	metrics.CrcMax, err = chunk.CrcMax()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get crc max: %w", err)
+	}
+	switch codecVersion {
+	case encoding.CodecV0:
+		metrics.L1CommitCalldataSize, err = codecv0.EstimateChunkL1CommitCalldataSize(chunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate chunk L1 commit calldata size: %w", err)
+		}
+		metrics.L1CommitGas, err = codecv0.EstimateChunkL1CommitGas(chunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate chunk L1 commit gas: %w", err)
+		}
+		return metrics, nil
+	case encoding.CodecV1:
+		metrics.L1CommitBlobSize, err = codecv1.EstimateChunkL1CommitBlobSize(chunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate chunk L1 commit blob size: %w", err)
+		}
+		return metrics, nil
+	default:
+		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+	}
+}
+
+// BatchMetrics indicates the metrics for proposing a batch.
+type BatchMetrics struct {
+	// common metrics
+	NumChunks           uint64
+	FirstBlockTimestamp uint64
+
+	// codecv0 metrics, default 0 for codecv1
+	L1CommitCalldataSize uint64
+	L1CommitGas          uint64
+
+	// codecv1 metrics, default 0 for codecv0
+	L1CommitBlobSize uint64
+}
+
+// CalculateBatchMetrics calculates batch metrics.
+func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetrics, error) {
+	var err error
+	metrics := &BatchMetrics{
+		NumChunks:           uint64(len(batch.Chunks)),
+		FirstBlockTimestamp: batch.Chunks[0].Blocks[0].Header.Time,
+	}
+	switch codecVersion {
+	case encoding.CodecV0:
+		metrics.L1CommitGas, err = codecv0.EstimateBatchL1CommitGas(batch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate batch L1 commit gas: %w", err)
+		}
+		metrics.L1CommitCalldataSize, err = codecv0.EstimateBatchL1CommitCalldataSize(batch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate batch L1 commit calldata size: %w", err)
+		}
+		return metrics, nil
+	case encoding.CodecV1:
+		metrics.L1CommitBlobSize, err = codecv1.EstimateBatchL1CommitBlobSize(batch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate chunk L1 commit blob size: %w", err)
+		}
+		return metrics, nil
+	default:
+		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+	}
+}
+
+// GetChunkHash retrieves the hash of a chunk.
+func GetChunkHash(chunk *encoding.Chunk, totalL1MessagePoppedBefore uint64, codecVersion encoding.CodecVersion) (common.Hash, error) {
+	switch codecVersion {
+	case encoding.CodecV0:
+		daChunk, err := codecv0.NewDAChunk(chunk, totalL1MessagePoppedBefore)
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to create codecv0 DA chunk: %w", err)
+		}
+		chunkHash, err := daChunk.Hash()
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to get codecv0 DA chunk hash: %w", err)
+		}
+		return chunkHash, nil
+	case encoding.CodecV1:
+		daChunk, err := codecv1.NewDAChunk(chunk, totalL1MessagePoppedBefore)
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to create codecv1 DA chunk: %w", err)
+		}
+		chunkHash, err := daChunk.Hash()
+		if err != nil {
+			return common.Hash{}, fmt.Errorf("failed to get codecv1 DA chunk hash: %w", err)
+		}
+		return chunkHash, nil
+	default:
+		return common.Hash{}, fmt.Errorf("unsupported codec version: %v", codecVersion)
+	}
+}
+
+// BatchMetadata represents the metadata of a batch.
+type BatchMetadata struct {
+	BatchHash      common.Hash
+	BatchBytes     []byte
+	StartChunkHash common.Hash
+	EndChunkHash   common.Hash
+}
+
+// GetBatchMetadata retrieves the metadata of a batch.
+func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetadata, error) {
+	numChunks := len(batch.Chunks)
+	totalL1MessagePoppedBeforeEndDAChunk := batch.TotalL1MessagePoppedBefore
+	for i := 0; i < numChunks-1; i++ {
+		totalL1MessagePoppedBeforeEndDAChunk += batch.Chunks[i].NumL1Messages(totalL1MessagePoppedBeforeEndDAChunk)
+	}
+
+	switch codecVersion {
+	case encoding.CodecV0:
+		daBatch, err := codecv0.NewDABatch(batch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv0 DA batch: %w", err)
+		}
+
+		batchMeta := &BatchMetadata{
+			BatchHash:  daBatch.Hash(),
+			BatchBytes: daBatch.Encode(),
+		}
+
+		startDAChunk, err := codecv0.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv0 start DA chunk: %w", err)
+		}
+
+		batchMeta.StartChunkHash, err = startDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv0 start DA chunk hash: %w", err)
+		}
+
+		endDAChunk, err := codecv0.NewDAChunk(batch.Chunks[numChunks-1], totalL1MessagePoppedBeforeEndDAChunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv0 end DA chunk: %w", err)
+		}
+
+		batchMeta.EndChunkHash, err = endDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv0 end DA chunk hash: %w", err)
+		}
+		return batchMeta, nil
+	case encoding.CodecV1:
+		daBatch, err := codecv1.NewDABatch(batch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv1 DA batch: %w", err)
+		}
+
+		batchMeta := &BatchMetadata{
+			BatchHash:  daBatch.Hash(),
+			BatchBytes: daBatch.Encode(),
+		}
+
+		startDAChunk, err := codecv1.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv1 start DA chunk: %w", err)
+		}
+
+		batchMeta.StartChunkHash, err = startDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv1 start DA chunk hash: %w", err)
+		}
+
+		endDAChunk, err := codecv1.NewDAChunk(batch.Chunks[numChunks-1], totalL1MessagePoppedBeforeEndDAChunk)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create codecv1 end DA chunk: %w", err)
+		}
+
+		batchMeta.EndChunkHash, err = endDAChunk.Hash()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codecv1 end DA chunk hash: %w", err)
+		}
+		return batchMeta, nil
+	default:
+		return nil, fmt.Errorf("unsupported codec version: %v", codecVersion)
+	}
+}
+
+// GetTotalL1MessagePoppedBeforeBatch retrieves the total L1 messages popped before the batch.
+func GetTotalL1MessagePoppedBeforeBatch(parentBatchBytes []byte, codecVersion encoding.CodecVersion) (uint64, error) {
+	switch codecVersion {
+	case encoding.CodecV0:
+		parentDABatch, err := codecv0.NewDABatchFromBytes(parentBatchBytes)
+		if err != nil {
+			return 0, fmt.Errorf("failed to create parent DA batch from bytes using codecv0, err: %w", err)
+		}
+		return parentDABatch.TotalL1MessagePopped, nil
+	case encoding.CodecV1:
+		parentDABatch, err := codecv1.NewDABatchFromBytes(parentBatchBytes)
+		if err != nil {
+			return 0, fmt.Errorf("failed to create parent DA batch from bytes using codecv1, err: %w", err)
+		}
+		return parentDABatch.TotalL1MessagePopped, nil
+	default:
+		return 0, fmt.Errorf("unsupported codec version: %v", codecVersion)
+	}
+}

rollup/mock_bridge/MockBridge.sol

@@ -1,346 +1,607 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity =0.8.24;
 
-import {BatchHeaderV0Codec} from "../../contracts/src/libraries/codec/BatchHeaderV0Codec.sol";
-import {ChunkCodecV0} from "../../contracts/src/libraries/codec/ChunkCodecV0.sol";
-import {IL1MessageQueue} from "../../contracts/src/L1/rollup/IL1MessageQueue.sol";
+import {BatchHeaderV0Codec} from "../../../contracts/src/libraries/codec/BatchHeaderV0Codec.sol";
+import {BatchHeaderV1Codec} from "../../../contracts/src/libraries/codec/BatchHeaderV1Codec.sol";
+import {ChunkCodecV0} from "../../../contracts/src/libraries/codec/ChunkCodecV0.sol";
+import {ChunkCodecV1} from "../../../contracts/src/libraries/codec/ChunkCodecV1.sol";
 
 contract MockBridge {
-  /******************************
-   * Events from L1MessageQueue *
-   ******************************/
+    /// @dev Thrown when committing a committed batch.
+    error ErrorBatchIsAlreadyCommitted();
 
-  /// @notice Emitted when a new L1 => L2 transaction is appended to the queue.
-  /// @param sender The address of account who initiates the transaction.
-  /// @param target The address of account who will recieve the transaction.
-  /// @param value The value passed with the transaction.
-  /// @param queueIndex The index of this transaction in the queue.
-  /// @param gasLimit Gas limit required to complete the message relay on L2.
-  /// @param data The calldata of the transaction.
-  event QueueTransaction(
-    address indexed sender,
-    address indexed target,
-    uint256 value,
-    uint64 queueIndex,
-    uint256 gasLimit,
-    bytes data
-  );
+    /// @dev Thrown when finalizing a verified batch.
+    error ErrorBatchIsAlreadyVerified();
 
-  /*********************************
-   * Events from L1ScrollMessenger *
-   *********************************/
+    /// @dev Thrown when committing empty batch (batch without chunks)
+    error ErrorBatchIsEmpty();
 
-  /// @notice Emitted when a cross domain message is sent.
-  /// @param sender The address of the sender who initiates the message.
-  /// @param target The address of target contract to call.
-  /// @param value The amount of value passed to the target contract.
-  /// @param messageNonce The nonce of the message.
-  /// @param gasLimit The optional gas limit passed to L1 or L2.
-  /// @param message The calldata passed to the target contract.
-  event SentMessage(
-    address indexed sender,
-    address indexed target,
-    uint256 value,
-    uint256 messageNonce,
-    uint256 gasLimit,
-    bytes message
-  );
+    /// @dev Thrown when call precompile failed.
+    error ErrorCallPointEvaluationPrecompileFailed();
 
-  /// @notice Emitted when a cross domain message is relayed successfully.
-  /// @param messageHash The hash of the message.
-  event RelayedMessage(bytes32 indexed messageHash);
+    /// @dev Thrown when the transaction has multiple blobs.
+    error ErrorFoundMultipleBlob();
 
-  /***************************
-   * Events from ScrollChain *
-   ***************************/
+    /// @dev Thrown when some fields are not zero in genesis batch.
+    error ErrorGenesisBatchHasNonZeroField();
 
-  /// @notice Emitted when a new batch is committed.
-  /// @param batchHash The hash of the batch.
-  event CommitBatch(uint256 indexed batchIndex, bytes32 indexed batchHash);
+    /// @dev Thrown when importing genesis batch twice.
+    error ErrorGenesisBatchImported();
 
-  /// @notice Emitted when a batch is finalized.
-  /// @param batchHash The hash of the batch
-  /// @param stateRoot The state root on layer 2 after this batch.
-  /// @param withdrawRoot The merkle root on layer2 after this batch.
-  event FinalizeBatch(uint256 indexed batchIndex, bytes32 indexed batchHash, bytes32 stateRoot, bytes32 withdrawRoot);
+    /// @dev Thrown when data hash in genesis batch is zero.
+    error ErrorGenesisDataHashIsZero();
 
-  /***********
-   * Structs *
-   ***********/
+    /// @dev Thrown when the parent batch hash in genesis batch is zero.
+    error ErrorGenesisParentBatchHashIsNonZero();
 
-  struct L2MessageProof {
-    // The index of the batch where the message belongs to.
-    uint256 batchIndex;
-    // Concatenation of merkle proof for withdraw merkle trie.
-    bytes merkleProof;
-  }
+    /// @dev Thrown when the l2 transaction is incomplete.
+    error ErrorIncompleteL2TransactionData();
 
-  /*************
-   * Variables *
-   *************/
+    /// @dev Thrown when the batch hash is incorrect.
+    error ErrorIncorrectBatchHash();
 
-  uint256 public messageNonce;
-  mapping(uint256 => bytes32) public committedBatches;
-  uint256 public l2BaseFee;
+    /// @dev Thrown when the batch index is incorrect.
+    error ErrorIncorrectBatchIndex();
 
-  /***********************************
-   * Functions from L2GasPriceOracle *
-   ***********************************/
+    /// @dev Thrown when the previous state root doesn't match stored one.
+    error ErrorIncorrectPreviousStateRoot();
 
-  function setL2BaseFee(uint256 _newL2BaseFee) external {
-    l2BaseFee = _newL2BaseFee;
-  }
+    /// @dev Thrown when the batch header version is invalid.
+    error ErrorInvalidBatchHeaderVersion();
 
-  /************************************
-   * Functions from L1ScrollMessenger *
-   ************************************/
+    /// @dev Thrown when no blob found in the transaction.
+    error ErrorNoBlobFound();
 
-  function sendMessage(
-    address target,
-    uint256 value,
-    bytes calldata message,
-    uint256 gasLimit
-  ) external payable {
-    bytes memory _xDomainCalldata = _encodeXDomainCalldata(msg.sender, target, value, messageNonce, message);
-    {
-      address _sender = applyL1ToL2Alias(address(this));
-      emit QueueTransaction(_sender, target, 0, uint64(messageNonce), gasLimit, _xDomainCalldata);
+    /// @dev Thrown when the number of transactions is less than number of L1 message in one block.
+    error ErrorNumTxsLessThanNumL1Msgs();
+
+    /// @dev Thrown when the given previous state is zero.
+    error ErrorPreviousStateRootIsZero();
+
+    /// @dev Thrown when the given state root is zero.
+    error ErrorStateRootIsZero();
+
+    /// @dev Thrown when a chunk contains too many transactions.
+    error ErrorTooManyTxsInOneChunk();
+
+    /// @dev Thrown when the precompile output is incorrect.
+    error ErrorUnexpectedPointEvaluationPrecompileOutput();
+
+    event CommitBatch(uint256 indexed batchIndex, bytes32 indexed batchHash);
+    event FinalizeBatch(uint256 indexed batchIndex, bytes32 indexed batchHash, bytes32 stateRoot, bytes32 withdrawRoot);
+
+    struct L2MessageProof {
+        uint256 batchIndex;
+        bytes merkleProof;
     }
 
-    emit SentMessage(msg.sender, target, value, messageNonce, gasLimit, message);
-    messageNonce += 1;
-  }
+    /// @dev Address of the point evaluation precompile used for EIP-4844 blob verification.
+    address constant POINT_EVALUATION_PRECOMPILE_ADDR = address(0x0A);
 
-  function relayMessageWithProof(
-    address _from,
-    address _to,
-    uint256 _value,
-    uint256 _nonce,
-    bytes memory _message,
-    L2MessageProof memory
-  ) external {
-    bytes memory _xDomainCalldata = _encodeXDomainCalldata(_from, _to, _value, _nonce, _message);
-    bytes32 _xDomainCalldataHash = keccak256(_xDomainCalldata);
-    emit RelayedMessage(_xDomainCalldataHash);
-  }
+    /// @dev BLS Modulus value defined in EIP-4844 and the magic value returned from a successful call to the
+    /// point evaluation precompile
+    uint256 constant BLS_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
 
-  /******************************
-   * Functions from ScrollChain *
-   ******************************/
+    uint256 public l2BaseFee;
+    uint256 public lastFinalizedBatchIndex;
+    mapping(uint256 => bytes32) public committedBatches;
+    mapping(uint256 => bytes32) public finalizedStateRoots;
+    mapping(uint256 => bytes32) public withdrawRoots;
 
-  /// @notice Import layer 2 genesis block
-  function importGenesisBatch(bytes calldata _batchHeader, bytes32 _stateRoot) external {
-  }
-
-  function commitBatch(
-    uint8 /*version*/,
-    bytes calldata _parentBatchHeader,
-    bytes[] memory chunks,
-    bytes calldata /*skippedL1MessageBitmap*/
-  ) external {
-    // check whether the batch is empty
-    uint256 _chunksLength = chunks.length;
-    require(_chunksLength > 0, "batch is empty");
-
-    // decode batch index
-    uint256 headerLength = _parentBatchHeader.length;
-    uint256 parentBatchPtr;
-    uint256 parentBatchIndex;
-    assembly {
-      parentBatchPtr := mload(0x40)
-      calldatacopy(parentBatchPtr, _parentBatchHeader.offset, headerLength)
-      mstore(0x40, add(parentBatchPtr, headerLength))
-      parentBatchIndex := shr(192, mload(add(parentBatchPtr, 1)))
+    function setL2BaseFee(uint256 _newL2BaseFee) external {
+      l2BaseFee = _newL2BaseFee;
     }
 
-    uint256 dataPtr;
-    assembly {
-      dataPtr := mload(0x40)
-      mstore(0x40, add(dataPtr, mul(_chunksLength, 32)))
-    }
+    /*****************************
+     * Public Mutating Functions *
+     *****************************/
 
-    for (uint256 i = 0; i < _chunksLength; i++) {
-      _commitChunk(dataPtr, chunks[i]);
+    /// @notice Import layer 2 genesis block
+    function importGenesisBatch(bytes calldata _batchHeader, bytes32 _stateRoot) external {
+        // check genesis batch header length
+        if (_stateRoot == bytes32(0)) revert ErrorStateRootIsZero();
 
-      unchecked {
-        dataPtr += 32;
-      }
-    }
+        // check whether the genesis batch is imported
+        if (finalizedStateRoots[0] != bytes32(0)) revert ErrorGenesisBatchImported();
 
-    bytes32 _dataHash;
-    assembly {
-      let dataLen := mul(_chunksLength, 0x20)
-      _dataHash := keccak256(sub(dataPtr, dataLen), dataLen)
-    }
+        (uint256 memPtr, bytes32 _batchHash, , ) = _loadBatchHeader(_batchHeader);
 
-    bytes memory paddedData = new bytes(89);
-    assembly {
-      mstore(add(paddedData, 57), _dataHash)
-    }
-
-    uint256 batchPtr;
-    assembly {
-      batchPtr := add(paddedData, 32)
-    }
-    bytes32 _batchHash = BatchHeaderV0Codec.computeBatchHash(batchPtr, 89);
-    committedBatches[0] = _batchHash;
-    emit CommitBatch(parentBatchIndex + 1, _batchHash);
-  }
-
-  function finalizeBatchWithProof(
-    bytes calldata batchHeader,
-    bytes32 /*prevStateRoot*/,
-    bytes32 postStateRoot,
-    bytes32 withdrawRoot,
-    bytes calldata /*aggrProof*/
-  ) external {
-    // decode batch index
-    uint256 headerLength = batchHeader.length;
-    uint256 batchPtr;
-    uint256 batchIndex;
-    assembly {
-      batchPtr := mload(0x40)
-      calldatacopy(batchPtr, batchHeader.offset, headerLength)
-      mstore(0x40, add(batchPtr, headerLength))
-      batchIndex := shr(192, mload(add(batchPtr, 1)))
-    }
-
-    bytes32 _batchHash = committedBatches[0];
-    emit FinalizeBatch(batchIndex, _batchHash, postStateRoot, withdrawRoot);
-  }
-
-  /**********************
-   * Internal Functions *
-   **********************/
-
-  /// @dev Internal function to generate the correct cross domain calldata for a message.
-  /// @param _sender Message sender address.
-  /// @param _target Target contract address.
-  /// @param _value The amount of ETH pass to the target.
-  /// @param _messageNonce Nonce for the provided message.
-  /// @param _message Message to send to the target.
-  /// @return ABI encoded cross domain calldata.
-  function _encodeXDomainCalldata(
-    address _sender,
-    address _target,
-    uint256 _value,
-    uint256 _messageNonce,
-    bytes memory _message
-  ) internal pure returns (bytes memory) {
-    return
-      abi.encodeWithSignature(
-        "relayMessage(address,address,uint256,uint256,bytes)",
-        _sender,
-        _target,
-        _value,
-        _messageNonce,
-        _message
-      );
-  }
-
-  /// @notice Utility function that converts the address in the L1 that submitted a tx to
-  /// the inbox to the msg.sender viewed in the L2
-  /// @param l1Address the address in the L1 that triggered the tx to L2
-  /// @return l2Address L2 address as viewed in msg.sender
-  function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
-    uint160 offset = uint160(0x1111000000000000000000000000000000001111);
-    unchecked {
-      l2Address = address(uint160(l1Address) + offset);
-    }
-  }
-
-  function _commitChunk(
-    uint256 memPtr,
-    bytes memory _chunk
-  ) internal pure {
-    uint256 chunkPtr;
-    uint256 startDataPtr;
-    uint256 dataPtr;
-    uint256 blockPtr;
-
-    assembly {
-      dataPtr := mload(0x40)
-      startDataPtr := dataPtr
-      chunkPtr := add(_chunk, 0x20) // skip chunkLength
-      blockPtr := add(chunkPtr, 1) // skip numBlocks
-    }
-
-    uint256 _numBlocks = ChunkCodecV0.validateChunkLength(chunkPtr, _chunk.length);
-
-    // concatenate block contexts
-    uint256 _totalTransactionsInChunk;
-    for (uint256 i = 0; i < _numBlocks; i++) {
-      dataPtr = ChunkCodecV0.copyBlockContext(chunkPtr, dataPtr, i);
-      uint256 _numTransactionsInBlock = ChunkCodecV0.getNumTransactions(blockPtr);
-      unchecked {
-        _totalTransactionsInChunk += _numTransactionsInBlock;
-        blockPtr += ChunkCodecV0.BLOCK_CONTEXT_LENGTH;
-      }
-    }
-
-    assembly {
-      mstore(0x40, add(dataPtr, mul(_totalTransactionsInChunk, 0x20))) // reserve memory for tx hashes
-      blockPtr := add(chunkPtr, 1) // reset block ptr
-    }
-
-    // concatenate tx hashes
-    uint256 l2TxPtr = ChunkCodecV0.getL2TxPtr(chunkPtr, _numBlocks);
-    while (_numBlocks > 0) {
-      // concatenate l2 transaction hashes
-      uint256 _numTransactionsInBlock = ChunkCodecV0.getNumTransactions(blockPtr);
-      for (uint256 j = 0; j < _numTransactionsInBlock; j++) {
-        bytes32 txHash;
-        (txHash, l2TxPtr) = ChunkCodecV0.loadL2TxHash(l2TxPtr);
-        assembly {
-          mstore(dataPtr, txHash)
-          dataPtr := add(dataPtr, 0x20)
+        // check all fields except `dataHash` and `lastBlockHash` are zero
+        unchecked {
+            uint256 sum = BatchHeaderV0Codec.getVersion(memPtr) +
+                BatchHeaderV0Codec.getBatchIndex(memPtr) +
+                BatchHeaderV0Codec.getL1MessagePopped(memPtr) +
+                BatchHeaderV0Codec.getTotalL1MessagePopped(memPtr);
+            if (sum != 0) revert ErrorGenesisBatchHasNonZeroField();
         }
-      }
+        if (BatchHeaderV0Codec.getDataHash(memPtr) == bytes32(0)) revert ErrorGenesisDataHashIsZero();
+        if (BatchHeaderV0Codec.getParentBatchHash(memPtr) != bytes32(0)) revert ErrorGenesisParentBatchHashIsNonZero();
 
-      unchecked {
-        _numBlocks -= 1;
-        blockPtr += ChunkCodecV0.BLOCK_CONTEXT_LENGTH;
-      }
+        committedBatches[0] = _batchHash;
+        finalizedStateRoots[0] = _stateRoot;
+
+        emit CommitBatch(0, _batchHash);
+        emit FinalizeBatch(0, _batchHash, _stateRoot, bytes32(0));
     }
 
-    // check chunk has correct length
-    require(l2TxPtr - chunkPtr == _chunk.length, "incomplete l2 transaction data");
+    function commitBatch(
+        uint8 _version,
+        bytes calldata _parentBatchHeader,
+        bytes[] memory _chunks,
+        bytes calldata
+    ) external {
+        // check whether the batch is empty
+        if (_chunks.length == 0) revert ErrorBatchIsEmpty();
 
-    // compute data hash and store to memory
-    assembly {
-      let dataHash := keccak256(startDataPtr, sub(dataPtr, startDataPtr))
-      mstore(memPtr, dataHash)
+        (, bytes32 _parentBatchHash, uint256 _batchIndex, uint256 _totalL1MessagesPoppedOverall) = _loadBatchHeader(
+            _parentBatchHeader
+        );
+        unchecked {
+            _batchIndex += 1;
+        }
+        if (committedBatches[_batchIndex] != 0) revert ErrorBatchIsAlreadyCommitted();
+
+        bytes32 _batchHash;
+        uint256 batchPtr;
+        bytes32 _dataHash;
+        uint256 _totalL1MessagesPoppedInBatch;
+        if (_version == 0) {
+            (_dataHash, _totalL1MessagesPoppedInBatch) = _commitChunksV0(
+                _totalL1MessagesPoppedOverall,
+                _chunks
+            );
+            assembly {
+                batchPtr := mload(0x40)
+                _totalL1MessagesPoppedOverall := add(_totalL1MessagesPoppedOverall, _totalL1MessagesPoppedInBatch)
+            }
+            // store entries, the order matters
+            BatchHeaderV0Codec.storeVersion(batchPtr, 0);
+            BatchHeaderV0Codec.storeBatchIndex(batchPtr, _batchIndex);
+            BatchHeaderV0Codec.storeL1MessagePopped(batchPtr, _totalL1MessagesPoppedInBatch);
+            BatchHeaderV0Codec.storeTotalL1MessagePopped(batchPtr, _totalL1MessagesPoppedOverall);
+            BatchHeaderV0Codec.storeDataHash(batchPtr, _dataHash);
+            BatchHeaderV0Codec.storeParentBatchHash(batchPtr, _parentBatchHash);
+            // compute batch hash
+            _batchHash = BatchHeaderV0Codec.computeBatchHash(
+                batchPtr,
+                BatchHeaderV0Codec.BATCH_HEADER_FIXED_LENGTH
+            );
+        } else if (_version == 1) {
+            bytes32 blobVersionedHash;
+            (blobVersionedHash, _dataHash, _totalL1MessagesPoppedInBatch) = _commitChunksV1(
+                _totalL1MessagesPoppedOverall,
+                _chunks
+            );
+            assembly {
+                batchPtr := mload(0x40)
+                _totalL1MessagesPoppedOverall := add(_totalL1MessagesPoppedOverall, _totalL1MessagesPoppedInBatch)
+            }
+            // store entries, the order matters
+            BatchHeaderV1Codec.storeVersion(batchPtr, 1);
+            BatchHeaderV1Codec.storeBatchIndex(batchPtr, _batchIndex);
+            BatchHeaderV1Codec.storeL1MessagePopped(batchPtr, _totalL1MessagesPoppedInBatch);
+            BatchHeaderV1Codec.storeTotalL1MessagePopped(batchPtr, _totalL1MessagesPoppedOverall);
+            BatchHeaderV1Codec.storeDataHash(batchPtr, _dataHash);
+            BatchHeaderV1Codec.storeBlobVersionedHash(batchPtr, blobVersionedHash);
+            BatchHeaderV1Codec.storeParentBatchHash(batchPtr, _parentBatchHash);
+            // compute batch hash
+            _batchHash = BatchHeaderV1Codec.computeBatchHash(
+                batchPtr,
+                BatchHeaderV1Codec.BATCH_HEADER_FIXED_LENGTH
+            );
+        } else {
+            revert ErrorInvalidBatchHeaderVersion();
+        }
+
+        committedBatches[_batchIndex] = _batchHash;
+        emit CommitBatch(_batchIndex, _batchHash);
     }
-  }
 
-  address private constant POINT_EVALUATION_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000000A;
-  uint256 private constant BLS_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
+    /// @dev We keep this function to upgrade to 4844 more smoothly.
+    function finalizeBatchWithProof(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot,
+        bytes calldata
+    ) external {
+        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
+        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
 
-  function verifyProof(
-    bytes32 claim,
-    bytes memory commitment,
-    bytes memory proof
-  ) external view {
-    require(commitment.length == 48, "Commitment must be 48 bytes");
-    require(proof.length == 48, "Proof must be 48 bytes");
+        // compute batch hash and verify
+        (, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
 
-    bytes32 versionedHash = blobhash(0);
+        // verify previous state root.
+        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
 
-    // Compute random challenge point.
-    uint256 point = uint256(keccak256(abi.encodePacked(versionedHash))) % BLS_MODULUS;
+        // avoid duplicated verification
+        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
 
-    bytes memory pointEvaluationCalldata = abi.encodePacked(
-      versionedHash,
-      point,
-      claim,
-      commitment,
-      proof
-    );
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
+            lastFinalizedBatchIndex = _batchIndex;
+        }
 
-    (bool success,) = POINT_EVALUATION_PRECOMPILE_ADDRESS.staticcall(pointEvaluationCalldata);
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
 
-    if (!success) {
-      revert("Proof verification failed");
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+
+    /// @dev Memory layout of `_blobDataProof`:
+    /// ```text
+    /// | z       | y       | kzg_commitment | kzg_proof |
+    /// |---------|---------|----------------|-----------|
+    /// | bytes32 | bytes32 | bytes48        | bytes48   |
+    /// ```
+    function finalizeBatchWithProof4844(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot,
+        bytes calldata _blobDataProof,
+        bytes calldata
+    ) external {
+        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
+        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
+
+        // compute batch hash and verify
+        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
+        bytes32 _blobVersionedHash = BatchHeaderV1Codec.getBlobVersionedHash(memPtr);
+
+        // Calls the point evaluation precompile and verifies the output
+        {
+            (bool success, bytes memory data) = POINT_EVALUATION_PRECOMPILE_ADDR.staticcall(
+                abi.encodePacked(_blobVersionedHash, _blobDataProof)
+            );
+            // We verify that the point evaluation precompile call was successful by testing the latter 32 bytes of the
+            // response is equal to BLS_MODULUS as defined in https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+            if (!success) revert ErrorCallPointEvaluationPrecompileFailed();
+            (, uint256 result) = abi.decode(data, (uint256, uint256));
+            if (result != BLS_MODULUS) revert ErrorUnexpectedPointEvaluationPrecompileOutput();
+        }
+
+        // verify previous state root.
+        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
+
+        // avoid duplicated verification
+        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
+
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
+            lastFinalizedBatchIndex = _batchIndex;
+        }
+
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
+
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /// @dev Internal function to commit chunks with version 0
+    /// @param _totalL1MessagesPoppedOverall The number of L1 messages popped before the list of chunks.
+    /// @param _chunks The list of chunks to commit.
+    /// @return _batchDataHash The computed data hash for the list of chunks.
+    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages poped in this batch, including skipped one.
+    function _commitChunksV0(
+        uint256 _totalL1MessagesPoppedOverall,
+        bytes[] memory _chunks
+    ) internal pure returns (bytes32 _batchDataHash, uint256 _totalL1MessagesPoppedInBatch) {
+        uint256 _chunksLength = _chunks.length;
+
+        // load `batchDataHashPtr` and reserve the memory region for chunk data hashes
+        uint256 batchDataHashPtr;
+        assembly {
+            batchDataHashPtr := mload(0x40)
+            mstore(0x40, add(batchDataHashPtr, mul(_chunksLength, 32)))
+        }
+
+        // compute the data hash for each chunk
+        for (uint256 i = 0; i < _chunksLength; i++) {
+            uint256 _totalNumL1MessagesInChunk;
+            bytes32 _chunkDataHash;
+            (_chunkDataHash, _totalNumL1MessagesInChunk) = _commitChunkV0(
+                _chunks[i],
+                _totalL1MessagesPoppedInBatch,
+                _totalL1MessagesPoppedOverall
+            );
+            unchecked {
+                _totalL1MessagesPoppedInBatch += _totalNumL1MessagesInChunk;
+                _totalL1MessagesPoppedOverall += _totalNumL1MessagesInChunk;
+            }
+            assembly {
+                mstore(batchDataHashPtr, _chunkDataHash)
+                batchDataHashPtr := add(batchDataHashPtr, 0x20)
+            }
+        }
+
+        assembly {
+            let dataLen := mul(_chunksLength, 0x20)
+            _batchDataHash := keccak256(sub(batchDataHashPtr, dataLen), dataLen)
+        }
+    }
+
+    /// @dev Internal function to commit chunks with version 1
+    /// @param _totalL1MessagesPoppedOverall The number of L1 messages popped before the list of chunks.
+    /// @param _chunks The list of chunks to commit.
+    /// @return _blobVersionedHash The blob versioned hash for the blob carried in this transaction.
+    /// @return _batchDataHash The computed data hash for the list of chunks.
+    /// @return _totalL1MessagesPoppedInBatch The total number of L1 messages poped in this batch, including skipped one.
+    function _commitChunksV1(
+        uint256 _totalL1MessagesPoppedOverall,
+        bytes[] memory _chunks
+    )
+        internal
+        view
+        returns (
+            bytes32 _blobVersionedHash,
+            bytes32 _batchDataHash,
+            uint256 _totalL1MessagesPoppedInBatch
+        )
+    {
+        {
+            bytes32 _secondBlob;
+            // Get blob's versioned hash
+            assembly {
+                _blobVersionedHash := blobhash(0)
+                _secondBlob := blobhash(1)
+            }
+            if (_blobVersionedHash == bytes32(0)) revert ErrorNoBlobFound();
+            if (_secondBlob != bytes32(0)) revert ErrorFoundMultipleBlob();
+        }
+
+        uint256 _chunksLength = _chunks.length;
+
+        // load `batchDataHashPtr` and reserve the memory region for chunk data hashes
+        uint256 batchDataHashPtr;
+        assembly {
+            batchDataHashPtr := mload(0x40)
+            mstore(0x40, add(batchDataHashPtr, mul(_chunksLength, 32)))
+        }
+
+        // compute the data hash for each chunk
+        for (uint256 i = 0; i < _chunksLength; i++) {
+            uint256 _totalNumL1MessagesInChunk;
+            bytes32 _chunkDataHash;
+            (_chunkDataHash, _totalNumL1MessagesInChunk) = _commitChunkV1(
+                _chunks[i],
+                _totalL1MessagesPoppedInBatch,
+                _totalL1MessagesPoppedOverall
+            );
+            unchecked {
+                _totalL1MessagesPoppedInBatch += _totalNumL1MessagesInChunk;
+                _totalL1MessagesPoppedOverall += _totalNumL1MessagesInChunk;
+            }
+            assembly {
+                mstore(batchDataHashPtr, _chunkDataHash)
+                batchDataHashPtr := add(batchDataHashPtr, 0x20)
+            }
+        }
+
+        // compute the data hash for current batch
+        assembly {
+            let dataLen := mul(_chunksLength, 0x20)
+            _batchDataHash := keccak256(sub(batchDataHashPtr, dataLen), dataLen)
+        }
+    }
+
+    /// @dev Internal function to load batch header from calldata to memory.
+    /// @param _batchHeader The batch header in calldata.
+    /// @return batchPtr The start memory offset of loaded batch header.
+    /// @return _batchHash The hash of the loaded batch header.
+    /// @return _batchIndex The index of this batch.
+    /// @param _totalL1MessagesPoppedOverall The number of L1 messages popped after this batch.
+    function _loadBatchHeader(bytes calldata _batchHeader)
+        internal
+        view
+        returns (
+            uint256 batchPtr,
+            bytes32 _batchHash,
+            uint256 _batchIndex,
+            uint256 _totalL1MessagesPoppedOverall
+        )
+    {
+        // load version from batch header, it is always the first byte.
+        uint256 version;
+        assembly {
+            version := shr(248, calldataload(_batchHeader.offset))
+        }
+
+        // version should be always 0 or 1 in current code
+        uint256 _length;
+        if (version == 0) {
+            (batchPtr, _length) = BatchHeaderV0Codec.loadAndValidate(_batchHeader);
+            _batchHash = BatchHeaderV0Codec.computeBatchHash(batchPtr, _length);
+            _batchIndex = BatchHeaderV0Codec.getBatchIndex(batchPtr);
+        } else if (version == 1) {
+            (batchPtr, _length) = BatchHeaderV1Codec.loadAndValidate(_batchHeader);
+            _batchHash = BatchHeaderV1Codec.computeBatchHash(batchPtr, _length);
+            _batchIndex = BatchHeaderV1Codec.getBatchIndex(batchPtr);
+        } else {
+            revert ErrorInvalidBatchHeaderVersion();
+        }
+        // only check when genesis is imported
+        if (committedBatches[_batchIndex] != _batchHash && finalizedStateRoots[0] != bytes32(0)) {
+            revert ErrorIncorrectBatchHash();
+        }
+        _totalL1MessagesPoppedOverall = BatchHeaderV0Codec.getTotalL1MessagePopped(batchPtr);
+    }
+
+    /// @dev Internal function to commit a chunk with version 0.
+    /// @param _chunk The encoded chunk to commit.
+    /// @param _totalL1MessagesPoppedInBatch The total number of L1 messages popped in the current batch before this chunk.
+    /// @param _totalL1MessagesPoppedOverall The total number of L1 messages popped in all batches including the current batch, before this chunk.
+    /// @return _dataHash The computed data hash for this chunk.
+    /// @return _totalNumL1MessagesInChunk The total number of L1 message popped in current chunk
+    function _commitChunkV0(
+        bytes memory _chunk,
+        uint256 _totalL1MessagesPoppedInBatch,
+        uint256 _totalL1MessagesPoppedOverall
+    ) internal pure returns (bytes32 _dataHash, uint256 _totalNumL1MessagesInChunk) {
+        uint256 chunkPtr;
+        uint256 startDataPtr;
+        uint256 dataPtr;
+
+        assembly {
+            dataPtr := mload(0x40)
+            startDataPtr := dataPtr
+            chunkPtr := add(_chunk, 0x20) // skip chunkLength
+        }
+
+        uint256 _numBlocks = ChunkCodecV0.validateChunkLength(chunkPtr, _chunk.length);
+
+        // concatenate block contexts, use scope to avoid stack too deep
+        {
+            uint256 _totalTransactionsInChunk;
+            for (uint256 i = 0; i < _numBlocks; i++) {
+                dataPtr = ChunkCodecV0.copyBlockContext(chunkPtr, dataPtr, i);
+                uint256 blockPtr = chunkPtr + 1 + i * ChunkCodecV0.BLOCK_CONTEXT_LENGTH;
+                uint256 _numTransactionsInBlock = ChunkCodecV0.getNumTransactions(blockPtr);
+                unchecked {
+                    _totalTransactionsInChunk += _numTransactionsInBlock;
+                }
+            }
+            assembly {
+                mstore(0x40, add(dataPtr, mul(_totalTransactionsInChunk, 0x20))) // reserve memory for tx hashes
+            }
+        }
+
+        // concatenate tx hashes
+        uint256 l2TxPtr = ChunkCodecV0.getL2TxPtr(chunkPtr, _numBlocks);
+        chunkPtr += 1;
+        while (_numBlocks > 0) {
+            // concatenate l1 message hashes
+            uint256 _numL1MessagesInBlock = ChunkCodecV0.getNumL1Messages(chunkPtr);
+
+            // concatenate l2 transaction hashes
+            uint256 _numTransactionsInBlock = ChunkCodecV0.getNumTransactions(chunkPtr);
+            if (_numTransactionsInBlock < _numL1MessagesInBlock) revert ErrorNumTxsLessThanNumL1Msgs();
+            for (uint256 j = _numL1MessagesInBlock; j < _numTransactionsInBlock; j++) {
+                bytes32 txHash;
+                (txHash, l2TxPtr) = ChunkCodecV0.loadL2TxHash(l2TxPtr);
+                assembly {
+                    mstore(dataPtr, txHash)
+                    dataPtr := add(dataPtr, 0x20)
+                }
+            }
+
+            unchecked {
+                _totalNumL1MessagesInChunk += _numL1MessagesInBlock;
+                _totalL1MessagesPoppedInBatch += _numL1MessagesInBlock;
+                _totalL1MessagesPoppedOverall += _numL1MessagesInBlock;
+
+                _numBlocks -= 1;
+                chunkPtr += ChunkCodecV0.BLOCK_CONTEXT_LENGTH;
+            }
+        }
+
+        assembly {
+            chunkPtr := add(_chunk, 0x20)
+        }
+        // check chunk has correct length
+        if (l2TxPtr - chunkPtr != _chunk.length) revert ErrorIncompleteL2TransactionData();
+
+        // compute data hash and store to memory
+        assembly {
+            _dataHash := keccak256(startDataPtr, sub(dataPtr, startDataPtr))
+        }
+    }
+
+    /// @dev Internal function to commit a chunk with version 1.
+    /// @param _chunk The encoded chunk to commit.
+    /// @param _totalL1MessagesPoppedInBatch The total number of L1 messages popped in current batch.
+    /// @param _totalL1MessagesPoppedOverall The total number of L1 messages popped in all batches including current batch.
+    /// @return _dataHash The computed data hash for this chunk.
+    /// @return _totalNumL1MessagesInChunk The total number of L1 message popped in current chunk
+    function _commitChunkV1(
+        bytes memory _chunk,
+        uint256 _totalL1MessagesPoppedInBatch,
+        uint256 _totalL1MessagesPoppedOverall
+    ) internal pure returns (bytes32 _dataHash, uint256 _totalNumL1MessagesInChunk) {
+        uint256 chunkPtr;
+        uint256 startDataPtr;
+        uint256 dataPtr;
+
+        assembly {
+            dataPtr := mload(0x40)
+            startDataPtr := dataPtr
+            chunkPtr := add(_chunk, 0x20) // skip chunkLength
+        }
+
+        uint256 _numBlocks = ChunkCodecV1.validateChunkLength(chunkPtr, _chunk.length);
+        // concatenate block contexts, use scope to avoid stack too deep
+        for (uint256 i = 0; i < _numBlocks; i++) {
+            dataPtr = ChunkCodecV1.copyBlockContext(chunkPtr, dataPtr, i);
+            uint256 blockPtr = chunkPtr + 1 + i * ChunkCodecV1.BLOCK_CONTEXT_LENGTH;
+            uint256 _numL1MessagesInBlock = ChunkCodecV1.getNumL1Messages(blockPtr);
+            unchecked {
+                _totalNumL1MessagesInChunk += _numL1MessagesInBlock;
+            }
+        }
+        assembly {
+            mstore(0x40, add(dataPtr, mul(_totalNumL1MessagesInChunk, 0x20))) // reserve memory for l1 message hashes
+            chunkPtr := add(chunkPtr, 1)
+        }
+
+        // the number of actual transactions in one chunk: non-skipped l1 messages + l2 txs
+        uint256 _totalTransactionsInChunk;
+        // concatenate tx hashes
+        while (_numBlocks > 0) {
+            // concatenate l1 message hashes
+            uint256 _numL1MessagesInBlock = ChunkCodecV1.getNumL1Messages(chunkPtr);
+            uint256 startPtr = dataPtr;
+            uint256 _numTransactionsInBlock = ChunkCodecV1.getNumTransactions(chunkPtr);
+            if (_numTransactionsInBlock < _numL1MessagesInBlock) revert ErrorNumTxsLessThanNumL1Msgs();
+            unchecked {
+                _totalTransactionsInChunk += dataPtr - startPtr; // number of non-skipped l1 messages
+                _totalTransactionsInChunk += _numTransactionsInBlock - _numL1MessagesInBlock; // number of l2 txs
+                _totalL1MessagesPoppedInBatch += _numL1MessagesInBlock;
+                _totalL1MessagesPoppedOverall += _numL1MessagesInBlock;
+
+                _numBlocks -= 1;
+                chunkPtr += ChunkCodecV1.BLOCK_CONTEXT_LENGTH;
+            }
+        }
+
+        // compute data hash and store to memory
+        assembly {
+            _dataHash := keccak256(startDataPtr, sub(dataPtr, startDataPtr))
+        }
+    }
+
+    function verifyProof(
+        bytes32 claim,
+        bytes memory commitment,
+        bytes memory proof
+    ) external view {
+        require(commitment.length == 48, "Commitment must be 48 bytes");
+        require(proof.length == 48, "Proof must be 48 bytes");
+
+        bytes32 versionedHash = blobhash(0);
+
+        // Compute random challenge point.
+        uint256 point = uint256(keccak256(abi.encodePacked(versionedHash))) % BLS_MODULUS;
+
+        bytes memory pointEvaluationCalldata = abi.encodePacked(
+            versionedHash,
+            point,
+            claim,
+            commitment,
+            proof
+        );
+
+        (bool success,) = POINT_EVALUATION_PRECOMPILE_ADDR.staticcall(pointEvaluationCalldata);
+
+        if (!success) {
+            revert("Proof verification failed");
+        }
     }
-  }
 }

rollup/tests/bridge_test.go

@@ -11,6 +11,13 @@ import (
 	"testing"
 	"time"
 
+	"scroll-tech/database/migrate"
+
+	"scroll-tech/common/database"
+	dockercompose "scroll-tech/common/docker-compose/l1"
+	tc "scroll-tech/common/testcontainers"
+	"scroll-tech/common/utils"
+
 	"github.com/gin-gonic/gin"
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
@@ -22,19 +29,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
-	dockercompose "scroll-tech/common/docker-compose/l1"
-	"scroll-tech/common/utils"
-
-	"scroll-tech/database/migrate"
-
 	bcmd "scroll-tech/rollup/cmd"
 	"scroll-tech/rollup/mock_bridge"
 )
 
 var (
-	base         *docker.App
+	testApps     *tc.TestcontainerApps
 	rollupApp    *bcmd.MockApp
 	posL1TestEnv *dockercompose.PoSL1TestEnv
 
@@ -47,11 +47,14 @@ var (
 )
 
 func setupDB(t *testing.T) *gorm.DB {
+	dsn, err := testApps.GetDBEndPoint()
+	assert.NoError(t, err)
+
 	cfg := &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
+		DSN:        dsn,
+		DriverName: "postgres",
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
 	}
 	db, err := database.InitDB(cfg)
 	assert.NoError(t, err)
@@ -62,22 +65,17 @@ func setupDB(t *testing.T) *gorm.DB {
 }
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-	defer base.Free()
-
-	rollupApp = bcmd.NewRollupApp(base, "../conf/config.json")
-	defer rollupApp.Free()
-
-	var err error
-	posL1TestEnv, err = dockercompose.NewPoSL1TestEnv()
-	if err != nil {
-		log.Crit("failed to create PoS L1 test environment", "err", err)
-	}
-	if err := posL1TestEnv.Start(); err != nil {
-		log.Crit("failed to start PoS L1 test environment", "err", err)
-	}
-	defer posL1TestEnv.Stop()
-
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		if rollupApp != nil {
+			rollupApp.Free()
+		}
+		if posL1TestEnv != nil {
+			posL1TestEnv.Stop()
+		}
+	}()
 	m.Run()
 }
 
@@ -86,19 +84,26 @@ func setupEnv(t *testing.T) {
 	glogger.Verbosity(log.LvlInfo)
 	log.Root().SetHandler(glogger)
 
-	var err error
+	var (
+		err           error
+		l1GethChainID *big.Int
+	)
+
+	posL1TestEnv, err = dockercompose.NewPoSL1TestEnv()
+	assert.NoError(t, err, "failed to create PoS L1 test environment")
+	assert.NoError(t, posL1TestEnv.Start(), "failed to start PoS L1 test environment")
+
+	testApps = tc.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL1GethContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
+	rollupApp = bcmd.NewRollupApp(testApps, "../conf/config.json")
+
 	l1Client, err = posL1TestEnv.L1Client()
 	assert.NoError(t, err)
-	chainID, err := l1Client.ChainID(context.Background())
+	l2Client, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
-	l1Auth, err = bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, chainID)
-	assert.NoError(t, err)
-	rollupApp.Config.L1Config.Endpoint = posL1TestEnv.Endpoint()
-	rollupApp.Config.L2Config.RelayerConfig.SenderConfig.Endpoint = posL1TestEnv.Endpoint()
-
-	base.RunImages(t)
-
-	l2Client, err = base.L2Client()
+	l1GethChainID, err = l1Client.ChainID(context.Background())
 	assert.NoError(t, err)
 
 	l1Cfg, l2Cfg := rollupApp.Config.L1Config, rollupApp.Config.L2Config
@@ -107,6 +112,11 @@ func setupEnv(t *testing.T) {
 	l2Cfg.Confirmations = 0
 	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
+	l1Auth, err = bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, l1GethChainID)
+	assert.NoError(t, err)
+	rollupApp.Config.L1Config.Endpoint = posL1TestEnv.Endpoint()
+	rollupApp.Config.L2Config.RelayerConfig.SenderConfig.Endpoint = posL1TestEnv.Endpoint()
+
 	port, err := rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)
 	svrPort := strconv.FormatInt(port.Int64()+40000, 10)
@@ -135,7 +145,7 @@ func prepareContracts(t *testing.T) {
 	nonce, err := l1Client.PendingNonceAt(context.Background(), l1Auth.From)
 	assert.NoError(t, err)
 	scrollChainAddress := crypto.CreateAddress(l1Auth.From, nonce)
-	tx := types.NewContractCreation(nonce, big.NewInt(0), 1000000, big.NewInt(1000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
+	tx := types.NewContractCreation(nonce, big.NewInt(0), 10000000, big.NewInt(1000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
 	signedTx, err := l1Auth.Signer(l1Auth.From, tx)
 	assert.NoError(t, err)
 	err = l1Client.SendTransaction(context.Background(), signedTx)
@@ -174,6 +184,8 @@ func TestFunction(t *testing.T) {
 	// l1 rollup and watch rollup events
 	t.Run("TestCommitAndFinalizeGenesisBatch", testCommitAndFinalizeGenesisBatch)
 	t.Run("TestCommitBatchAndFinalizeBatch", testCommitBatchAndFinalizeBatch)
+	t.Run("TestCommitBatchAndFinalizeBatch4844", testCommitBatchAndFinalizeBatch4844)
+	t.Run("TestCommitBatchAndFinalizeBatchBeforeAndPost4844", testCommitBatchAndFinalizeBatchBeforeAndPost4844)
 
 	// l1/l2 gas oracle
 	t.Run("TestImportL1GasPrice", testImportL1GasPrice)

rollup/tests/gas_oracle_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/database"
@@ -69,7 +70,7 @@ func testImportL2GasPrice(t *testing.T) {
 	prepareContracts(t)
 
 	l2Cfg := rollupApp.Config.L2Config
-	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, false, relayer.ServiceTypeL2GasOracle, nil)
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, false, relayer.ServiceTypeL2GasOracle, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -97,7 +98,7 @@ func testImportL2GasPrice(t *testing.T) {
 	}
 
 	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), batch)
+	_, err = batchOrm.InsertBatch(context.Background(), batch, encoding.CodecV0)
 	assert.NoError(t, err)
 
 	// check db status

rollup/tests/rollup_test.go

@@ -29,7 +29,7 @@ func testCommitAndFinalizeGenesisBatch(t *testing.T) {
 	prepareContracts(t)
 
 	l2Cfg := rollupApp.Config.L2Config
-	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, true, relayer.ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, relayer.ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, l2Relayer)
 	defer l2Relayer.StopSenders()
@@ -59,7 +59,7 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 
 	// Create L2Relayer
 	l2Cfg := rollupApp.Config.L2Config
-	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, false, relayer.ServiceTypeL2RollupRelayer, nil)
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, &params.ChainConfig{}, true, relayer.ServiceTypeL2RollupRelayer, nil)
 	assert.NoError(t, err)
 	defer l2Relayer.StopSenders()
 
@@ -69,17 +69,18 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 
 	// add some blocks to db
 	var blocks []*encoding.Block
-	for i := 0; i < 10; i++ {
+	for i := int64(0); i < 10; i++ {
 		header := gethTypes.Header{
-			Number:     big.NewInt(int64(i)),
+			Number:     big.NewInt(i + 1),
 			ParentHash: common.Hash{},
 			Difficulty: big.NewInt(0),
 			BaseFee:    big.NewInt(0),
+			Root:       common.HexToHash("0x1"),
 		}
 		blocks = append(blocks, &encoding.Block{
 			Header:         &header,
 			Transactions:   nil,
-			WithdrawRoot:   common.Hash{},
+			WithdrawRoot:   common.HexToHash("0x2"),
 			RowConsumption: &gethTypes.RowConsumption{},
 		})
 	}
@@ -96,6 +97,14 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 		MaxRowConsumptionPerChunk:       1048319,
 		ChunkTimeoutSec:                 300,
 	}, &params.ChainConfig{}, db, nil)
+
+	bp := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxChunkNumPerBatch:             10,
+		MaxL1CommitGasPerBatch:          50000000000,
+		MaxL1CommitCalldataSizePerBatch: 1000000,
+		BatchTimeoutSec:                 300,
+	}, &params.ChainConfig{}, db, nil)
+
 	cp.TryProposeChunk()
 
 	batchOrm := orm.NewBatch(db)
@@ -107,12 +116,6 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Len(t, chunks, 1)
 
-	bp := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunkNumPerBatch:             10,
-		MaxL1CommitGasPerBatch:          50000000000,
-		MaxL1CommitCalldataSizePerBatch: 1000000,
-		BatchTimeoutSec:                 300,
-	}, &params.ChainConfig{}, db, nil)
 	bp.TryProposeBatch()
 
 	l2Relayer.ProcessPendingBatches()
@@ -175,3 +178,256 @@ func testCommitBatchAndFinalizeBatch(t *testing.T) {
 		return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
 	}, 30*time.Second, time.Second)
 }
+
+func testCommitBatchAndFinalizeBatch4844(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	prepareContracts(t)
+
+	// Create L2Relayer
+	l2Cfg := rollupApp.Config.L2Config
+	chainConfig := &params.ChainConfig{BernoulliBlock: big.NewInt(0)}
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, chainConfig, true, relayer.ServiceTypeL2RollupRelayer, nil)
+	assert.NoError(t, err)
+	defer l2Relayer.StopSenders()
+
+	// Create L1Watcher
+	l1Cfg := rollupApp.Config.L1Config
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, 0, l1Cfg.Confirmations, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db, nil)
+
+	// add some blocks to db
+	var blocks []*encoding.Block
+	for i := int64(0); i < 10; i++ {
+		header := gethTypes.Header{
+			Number:     big.NewInt(i + 1),
+			ParentHash: common.Hash{},
+			Difficulty: big.NewInt(0),
+			BaseFee:    big.NewInt(0),
+			Root:       common.HexToHash("0x1"),
+		}
+		blocks = append(blocks, &encoding.Block{
+			Header:         &header,
+			Transactions:   nil,
+			WithdrawRoot:   common.HexToHash("0x2"),
+			RowConsumption: &gethTypes.RowConsumption{},
+		})
+	}
+
+	l2BlockOrm := orm.NewL2Block(db)
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), blocks)
+	assert.NoError(t, err)
+
+	cp := watcher.NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:             100,
+		MaxTxNumPerChunk:                10000,
+		MaxL1CommitGasPerChunk:          1,
+		MaxL1CommitCalldataSizePerChunk: 1,
+		MaxRowConsumptionPerChunk:       1048319,
+		ChunkTimeoutSec:                 300,
+	}, chainConfig, db, nil)
+
+	bp := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxChunkNumPerBatch:             10,
+		MaxL1CommitGasPerBatch:          1,
+		MaxL1CommitCalldataSizePerBatch: 1,
+		BatchTimeoutSec:                 300,
+	}, chainConfig, db, nil)
+
+	cp.TryProposeChunk()
+
+	batchOrm := orm.NewBatch(db)
+	unbatchedChunkIndex, err := batchOrm.GetFirstUnbatchedChunkIndex(context.Background())
+	assert.NoError(t, err)
+
+	chunkOrm := orm.NewChunk(db)
+	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), unbatchedChunkIndex, 0)
+	assert.NoError(t, err)
+	assert.Len(t, chunks, 1)
+
+	bp.TryProposeBatch()
+
+	l2Relayer.ProcessPendingBatches()
+	batch, err := batchOrm.GetLatestBatch(context.Background())
+	assert.NoError(t, err)
+	assert.NotNil(t, batch)
+
+	// fetch rollup events
+	assert.Eventually(t, func() bool {
+		err = l1Watcher.FetchContractEvent()
+		assert.NoError(t, err)
+		var statuses []types.RollupStatus
+		statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+		return err == nil && len(statuses) == 1 && types.RollupCommitted == statuses[0]
+	}, 30*time.Second, time.Second)
+
+	assert.Eventually(t, func() bool {
+		batch, err = batchOrm.GetLatestBatch(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, batch)
+		assert.NotEmpty(t, batch.CommitTxHash)
+		var receipt *gethTypes.Receipt
+		receipt, err = l1Client.TransactionReceipt(context.Background(), common.HexToHash(batch.CommitTxHash))
+		return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
+	}, 30*time.Second, time.Second)
+
+	// add dummy proof
+	proof := &message.BatchProof{
+		Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
+	}
+	err = batchOrm.UpdateProofByHash(context.Background(), batch.Hash, proof, 100)
+	assert.NoError(t, err)
+	err = batchOrm.UpdateProvingStatus(context.Background(), batch.Hash, types.ProvingTaskVerified)
+	assert.NoError(t, err)
+
+	// process committed batch and check status
+	l2Relayer.ProcessCommittedBatches()
+
+	statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(statuses))
+	assert.Equal(t, types.RollupFinalizing, statuses[0])
+
+	// fetch rollup events
+	assert.Eventually(t, func() bool {
+		err = l1Watcher.FetchContractEvent()
+		assert.NoError(t, err)
+		var statuses []types.RollupStatus
+		statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+		return err == nil && len(statuses) == 1 && types.RollupFinalized == statuses[0]
+	}, 30*time.Second, time.Second)
+
+	assert.Eventually(t, func() bool {
+		batch, err = batchOrm.GetLatestBatch(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, batch)
+		assert.NotEmpty(t, batch.FinalizeTxHash)
+		var receipt *gethTypes.Receipt
+		receipt, err = l1Client.TransactionReceipt(context.Background(), common.HexToHash(batch.FinalizeTxHash))
+		return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
+	}, 30*time.Second, time.Second)
+}
+
+func testCommitBatchAndFinalizeBatchBeforeAndPost4844(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	prepareContracts(t)
+
+	// Create L2Relayer
+	l2Cfg := rollupApp.Config.L2Config
+	chainConfig := &params.ChainConfig{BernoulliBlock: big.NewInt(5)}
+	l2Relayer, err := relayer.NewLayer2Relayer(context.Background(), l2Client, db, l2Cfg.RelayerConfig, chainConfig, true, relayer.ServiceTypeL2RollupRelayer, nil)
+	assert.NoError(t, err)
+	defer l2Relayer.StopSenders()
+
+	// Create L1Watcher
+	l1Cfg := rollupApp.Config.L1Config
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, 0, l1Cfg.Confirmations, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db, nil)
+
+	// add some blocks to db
+	var blocks []*encoding.Block
+	for i := int64(0); i < 10; i++ {
+		header := gethTypes.Header{
+			Number:     big.NewInt(i + 1),
+			ParentHash: common.Hash{},
+			Difficulty: big.NewInt(0),
+			BaseFee:    big.NewInt(0),
+			Root:       common.HexToHash("0x1"),
+		}
+		blocks = append(blocks, &encoding.Block{
+			Header:         &header,
+			Transactions:   nil,
+			WithdrawRoot:   common.HexToHash("0x2"),
+			RowConsumption: &gethTypes.RowConsumption{},
+		})
+	}
+
+	l2BlockOrm := orm.NewL2Block(db)
+	err = l2BlockOrm.InsertL2Blocks(context.Background(), blocks)
+	assert.NoError(t, err)
+
+	cp := watcher.NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
+		MaxBlockNumPerChunk:             100,
+		MaxTxNumPerChunk:                10000,
+		MaxL1CommitGasPerChunk:          50000000000,
+		MaxL1CommitCalldataSizePerChunk: 1000000,
+		MaxRowConsumptionPerChunk:       1048319,
+		ChunkTimeoutSec:                 300,
+	}, chainConfig, db, nil)
+
+	bp := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
+		MaxChunkNumPerBatch:             10,
+		MaxL1CommitGasPerBatch:          50000000000,
+		MaxL1CommitCalldataSizePerBatch: 1000000,
+		BatchTimeoutSec:                 300,
+	}, chainConfig, db, nil)
+
+	cp.TryProposeChunk()
+	cp.TryProposeChunk()
+	bp.TryProposeBatch()
+	bp.TryProposeBatch()
+
+	for i := uint64(0); i < 2; i++ {
+		l2Relayer.ProcessPendingBatches()
+		batchOrm := orm.NewBatch(db)
+		batch, err := batchOrm.GetBatchByIndex(context.Background(), i+1)
+		assert.NoError(t, err)
+		assert.NotNil(t, batch)
+
+		// fetch rollup events
+		assert.Eventually(t, func() bool {
+			err = l1Watcher.FetchContractEvent()
+			assert.NoError(t, err)
+			var statuses []types.RollupStatus
+			statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+			return err == nil && len(statuses) == 1 && types.RollupCommitted == statuses[0]
+		}, 30*time.Second, time.Second)
+
+		assert.Eventually(t, func() bool {
+			batch, err = batchOrm.GetBatchByIndex(context.Background(), i+1)
+			assert.NoError(t, err)
+			assert.NotNil(t, batch)
+			assert.NotEmpty(t, batch.CommitTxHash)
+			var receipt *gethTypes.Receipt
+			receipt, err = l1Client.TransactionReceipt(context.Background(), common.HexToHash(batch.CommitTxHash))
+			return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
+		}, 30*time.Second, time.Second)
+
+		// add dummy proof
+		proof := &message.BatchProof{
+			Proof: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
+		}
+		err = batchOrm.UpdateProofByHash(context.Background(), batch.Hash, proof, 100)
+		assert.NoError(t, err)
+		err = batchOrm.UpdateProvingStatus(context.Background(), batch.Hash, types.ProvingTaskVerified)
+		assert.NoError(t, err)
+
+		// process committed batch and check status
+		l2Relayer.ProcessCommittedBatches()
+
+		statuses, err := batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+		assert.NoError(t, err)
+		assert.Equal(t, 1, len(statuses))
+		assert.Equal(t, types.RollupFinalizing, statuses[0])
+
+		// fetch rollup events
+		assert.Eventually(t, func() bool {
+			err = l1Watcher.FetchContractEvent()
+			assert.NoError(t, err)
+			var statuses []types.RollupStatus
+			statuses, err = batchOrm.GetRollupStatusByHashList(context.Background(), []string{batch.Hash})
+			return err == nil && len(statuses) == 1 && types.RollupFinalized == statuses[0]
+		}, 30*time.Second, time.Second)
+
+		assert.Eventually(t, func() bool {
+			batch, err = batchOrm.GetBatchByIndex(context.Background(), i+1)
+			assert.NoError(t, err)
+			assert.NotNil(t, batch)
+			assert.NotEmpty(t, batch.FinalizeTxHash)
+			var receipt *gethTypes.Receipt
+			receipt, err = l1Client.TransactionReceipt(context.Background(), common.HexToHash(batch.FinalizeTxHash))
+			return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
+		}, 30*time.Second, time.Second)
+	}
+}

tests/integration-test/contracts_test.go

@@ -20,11 +20,11 @@ var (
 	greeterAddress = common.HexToAddress("0x7363726f6c6c6c20000000000000000000000015")
 )
 
-func TestERC20(t *testing.T) {
-	base.RunL2Geth(t)
+func testERC20(t *testing.T) {
+	assert.NoError(t, testApps.StartL2GethContainer())
 	time.Sleep(time.Second * 3)
 
-	l2Cli, err := base.L2Client()
+	l2Cli, err := testApps.GetL2GethClient()
 	assert.Nil(t, err)
 
 	token, err := erc20.NewERC20Mock(erc20Address, l2Cli)
@@ -32,7 +32,9 @@ func TestERC20(t *testing.T) {
 	privKey, err := crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121212"))
 	assert.NoError(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(privKey, base.L2gethImg.ChainID())
+	chainID, err := l2Cli.ChainID(context.Background())
+	assert.NoError(t, err)
+	auth, err := bind.NewKeyedTransactorWithChainID(privKey, chainID)
 	assert.NoError(t, err)
 
 	authBls0, err := token.BalanceOf(nil, auth.From)
@@ -45,7 +47,8 @@ func TestERC20(t *testing.T) {
 	value := big.NewInt(1000)
 	tx, err := token.Transfer(auth, erc20Address, value)
 	assert.NoError(t, err)
-	bind.WaitMined(context.Background(), l2Cli, tx)
+	_, err = bind.WaitMined(context.Background(), l2Cli, tx)
+	assert.NoError(t, err)
 
 	authBls1, err := token.BalanceOf(nil, auth.From)
 	assert.NoError(t, err)
@@ -58,12 +61,14 @@ func TestERC20(t *testing.T) {
 	assert.Equal(t, tokenBls1.Int64(), tokenBls0.Add(tokenBls0, value).Int64())
 }
 
-func TestGreeter(t *testing.T) {
-	base.RunL2Geth(t)
-	l2Cli, err := base.L2Client()
+func testGreeter(t *testing.T) {
+	assert.NoError(t, testApps.StartL2GethContainer())
+	l2Cli, err := testApps.GetL2GethClient()
 	assert.Nil(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, base.L2gethImg.ChainID())
+	chainID, err := l2Cli.ChainID(context.Background())
+	assert.NoError(t, err)
+	auth, err := bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, chainID)
 	assert.NoError(t, err)
 
 	token, err := greeter.NewGreeter(greeterAddress, l2Cli)

tests/integration-test/go.mod

@@ -3,7 +3,7 @@ module scroll-tech/integration-test
 go 1.21
 
 require (
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
 	gorm.io/gorm v1.25.5
 )

tests/integration-test/go.sum

@@ -94,8 +94,8 @@ 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.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935 h1:bHBt6sillaT4o/9RjxkVX8pWwvEmu37uWBw4XbCjfzY=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20240314095130-4553f5f26935/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8=
 github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE=
 github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

tests/integration-test/integration_test.go

@@ -10,52 +10,63 @@ import (
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
 
-	"scroll-tech/integration-test/orm"
-
-	rapp "scroll-tech/prover/cmd/app"
-
-	"scroll-tech/database/migrate"
-
-	capp "scroll-tech/coordinator/cmd/api/app"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/utils"
 	"scroll-tech/common/version"
-
+	capp "scroll-tech/coordinator/cmd/api/app"
+	"scroll-tech/database/migrate"
+	"scroll-tech/integration-test/orm"
+	rapp "scroll-tech/prover/cmd/app"
 	bcmd "scroll-tech/rollup/cmd"
 )
 
 var (
-	base      *docker.App
+	testApps  *testcontainers.TestcontainerApps
 	rollupApp *bcmd.MockApp
 )
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-	rollupApp = bcmd.NewRollupApp(base, "../../rollup/conf/config.json")
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		if rollupApp != nil {
+			rollupApp.Free()
+		}
+	}()
 	m.Run()
-	rollupApp.Free()
-	base.Free()
 }
 
-func TestCoordinatorProverInteraction(t *testing.T) {
-	// Start postgres docker containers
-	base.RunL2Geth(t)
-	base.RunDBImage(t)
+func setupEnv(t *testing.T) {
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL1GethContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
+	rollupApp = bcmd.NewRollupApp(testApps, "../../rollup/conf/config.json")
+}
 
-	// Init data
-	dbCfg := &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+func TestFunction(t *testing.T) {
+	setupEnv(t)
+	t.Run("TestCoordinatorProverInteraction", testCoordinatorProverInteraction)
+	t.Run("TestProverReLogin", testProverReLogin)
+	t.Run("TestERC20", testERC20)
+	t.Run("TestGreeter", testGreeter)
+}
 
-	db, err := database.InitDB(dbCfg)
+func setupDB(t *testing.T) *gorm.DB {
+	db, err := testApps.GetGormDBClient()
 	assert.NoError(t, err)
+	sqlDB, err := db.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(sqlDB))
+	return db
+}
+
+func testCoordinatorProverInteraction(t *testing.T) {
+	db := setupDB(t)
 
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -66,7 +77,7 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	l2BlockOrm := orm.NewL2Block(db)
 
 	// Connect to l2geth client
-	l2Client, err := base.L2Client()
+	l2Client, err := testApps.GetL2GethClient()
 	if err != nil {
 		log.Fatalf("Failed to connect to the l2geth client: %v", err)
 	}
@@ -111,10 +122,9 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	assert.NoError(t, err)
 	t.Log(version.Version)
 
-	base.Timestamp = time.Now().Nanosecond()
-	coordinatorApp := capp.NewCoordinatorApp(base, "../../coordinator/conf/config.json", "./genesis.json")
-	chunkProverApp := rapp.NewProverApp(base, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
-	batchProverApp := rapp.NewProverApp(base, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	coordinatorApp := capp.NewCoordinatorApp(testApps, "../../coordinator/conf/config.json", "./genesis.json")
+	chunkProverApp := rapp.NewProverApp(testApps, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	batchProverApp := rapp.NewProverApp(testApps, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
 	defer coordinatorApp.Free()
 	defer chunkProverApp.Free()
 	defer batchProverApp.Free()
@@ -139,17 +149,16 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	coordinatorApp.WaitExit()
 }
 
-func TestProverReLogin(t *testing.T) {
-	// Start postgres docker containers.
-	base.RunL2Geth(t)
-	base.RunDBImage(t)
+func testProverReLogin(t *testing.T) {
+	client, err := testApps.GetGormDBClient()
+	assert.NoError(t, err)
+	db, err := client.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db))
 
-	assert.NoError(t, migrate.ResetDB(base.DBClient(t)))
-
-	base.Timestamp = time.Now().Nanosecond()
-	coordinatorApp := capp.NewCoordinatorApp(base, "../../coordinator/conf/config.json", "./genesis.json")
-	chunkProverApp := rapp.NewProverApp(base, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
-	batchProverApp := rapp.NewProverApp(base, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	coordinatorApp := capp.NewCoordinatorApp(testApps, "../../coordinator/conf/config.json", "./genesis.json")
+	chunkProverApp := rapp.NewProverApp(testApps, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	batchProverApp := rapp.NewProverApp(testApps, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
 	defer coordinatorApp.Free()
 	defer chunkProverApp.Free()
 	defer batchProverApp.Free()

tests/integration-test/orm/l2_block.go

@@ -4,9 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"scroll-tech/common/types/encoding"
 	"time"
 
+	"scroll-tech/common/types/encoding"
+
 	"github.com/scroll-tech/go-ethereum/log"
 	"gorm.io/gorm"
 )