upgrade zkvm-prover

Cargo.toml

@@ -17,12 +17,12 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.5.8"
 
 [workspace.dependencies]
-scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", branch = "feat/0.5.1", package = "scroll-zkvm-prover" }
-scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", branch = "feat/0.5.1", package = "scroll-zkvm-verifier" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", branch = "feat/0.5.1" }
+scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "0498edb", package = "scroll-zkvm-prover" }
+scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "0498edb", package = "scroll-zkvm-verifier" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "0498edb" }
 
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3", features = ["scroll"] }
-sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3" }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/upgrade", features = ["scroll"] }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/upgrade" }
 
 metrics = "0.23.0"
 metrics-util = "0.17"
@@ -46,18 +46,18 @@ once_cell = "1.20"
 base64 = "0.22"
 
 [patch.crates-io]
-revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-bytecode = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-context = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-context-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-database = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-database-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-handler = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-revm-state = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-bytecode = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-context = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-context-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-database = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-database-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-handler = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
+revm-state = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74" }
 
 ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.15.0" }
 alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v1.2.0" }
@@ -65,4 +65,4 @@ alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch =
 [profile.maxperf]
 inherits = "release"
 lto = "fat"
-codegen-units = 1
+codegen-units = 1

bridge-history-api/go.mod

@@ -11,14 +11,14 @@ require (
 	github.com/pressly/goose/v3 v3.16.0
 	github.com/prometheus/client_golang v1.19.0
 	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	golang.org/x/sync v0.11.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
 
-replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
+replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c // It's a hotfix for the header hash incompatibility issue, pls change this with caution
 
 require (
 	dario.cat/mergo v1.0.0 // indirect

bridge-history-api/go.sum

@@ -311,8 +311,8 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
 github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 h1:u371VK8eOU2Z/0SVf5KDI3eJc8msHSpJbav4do/8n38=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c h1:IpEBKM6O+xOK2qZVZztGxcobFXkKMb5hAkBEVzfXjVg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

common/version/version.go

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

coordinator/Makefile

@@ -1,4 +1,4 @@
-.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator libzkp
+.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator
 
 IMAGE_VERSION=latest
 REPO_ROOT_DIR=./..

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -86,10 +86,6 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		var tmpBatchTask *orm.Batch
 
 		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeBatch) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
 			tmpBatchTask, getTaskError = bp.batchOrm.GetBatchByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
 			if getTaskError != nil {
 				log.Error("failed to get batch has assigned to prover", "taskID", taskCtx.hasAssignedTask.TaskID, "err", getTaskError)
@@ -99,14 +95,6 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped batch. ProverName: %s, ProverVersion: %s",
 					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
 			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpBatchTask, getTaskError = bp.batchOrm.GetBatchByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected batch", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBatchTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
 		}
 
 		if tmpBatchTask == nil {

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -84,10 +84,6 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		var tmpBundleTask *orm.Bundle
 
 		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeBundle) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
 			tmpBundleTask, getTaskError = bp.bundleOrm.GetBundleByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
 			if getTaskError != nil {
 				log.Error("failed to get bundle has assigned to prover", "taskID", taskCtx.hasAssignedTask.TaskID, "err", getTaskError)
@@ -97,14 +93,6 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped bundle. ProverName: %s, ProverVersion: %s",
 					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
 			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpBundleTask, getTaskError = bp.bundleOrm.GetBundleByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected bundle", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpBundleTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
 		}
 
 		if tmpBundleTask == nil {
@@ -246,14 +234,9 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		return nil, fmt.Errorf("failed to get batch proofs for bundle task id:%s, no batch found", task.TaskID)
 	}
 
-	var prevStateRoot common.Hash
-	// this would be common in test cases: the first batch has empty parent
-	if batches[0].Index > 1 {
-		parentBatch, err := bp.batchOrm.GetBatchByHash(ctx, batches[0].ParentBatchHash)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get parent batch for batch task id:%s err:%w", task.TaskID, err)
-		}
-		prevStateRoot = common.HexToHash(parentBatch.StateRoot)
+	parentBatch, err := bp.batchOrm.GetBatchByHash(ctx, batches[0].ParentBatchHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get parent batch for batch task id:%s err:%w", task.TaskID, err)
 	}
 
 	var batchProofs []*message.OpenVMBatchProof
@@ -272,7 +255,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 
 	taskDetail.BundleInfo = &message.OpenVMBundleInfo{
 		ChainID:       bp.cfg.L2.ChainID,
-		PrevStateRoot: prevStateRoot,
+		PrevStateRoot: common.HexToHash(parentBatch.StateRoot),
 		PostStateRoot: common.HexToHash(batches[len(batches)-1].StateRoot),
 		WithdrawRoot:  common.HexToHash(batches[len(batches)-1].WithdrawRoot),
 		NumBatches:    uint32(len(batches)),

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -80,12 +80,7 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	for i := 0; i < 5; i++ {
 		var getTaskError error
 		var tmpChunkTask *orm.Chunk
-
 		if taskCtx.hasAssignedTask != nil {
-			if taskCtx.hasAssignedTask.TaskType != int16(message.ProofTypeChunk) {
-				return nil, fmt.Errorf("prover with publicKey %s is already assigned a task. ProverName: %s, ProverVersion: %s", taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
-			}
-
 			log.Debug("retrieved assigned task chunk", "taskID", taskCtx.hasAssignedTask.TaskID, "prover", taskCtx.ProverName)
 			tmpChunkTask, getTaskError = cp.chunkOrm.GetChunkByHash(ctx.Copy(), taskCtx.hasAssignedTask.TaskID)
 			if getTaskError != nil {
@@ -96,14 +91,6 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 				return nil, fmt.Errorf("prover with publicKey %s is already assigned a dropped chunk. ProverName: %s, ProverVersion: %s",
 					taskCtx.PublicKey, taskCtx.ProverName, taskCtx.ProverVersion)
 			}
-		} else if getTaskParameter.TaskID != "" {
-			tmpChunkTask, getTaskError = cp.chunkOrm.GetChunkByHash(ctx.Copy(), getTaskParameter.TaskID)
-			if getTaskError != nil {
-				log.Error("failed to get expected chunk", "taskID", getTaskParameter.TaskID, "err", getTaskError)
-				return nil, ErrCoordinatorInternalFailure
-			} else if tmpChunkTask == nil {
-				return nil, fmt.Errorf("Expected task (%s) is already dropped", getTaskParameter.TaskID)
-			}
 		}
 
 		if tmpChunkTask == nil {
@@ -234,7 +221,7 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	// Get block hashes.
 	blockHashes, dbErr := cp.blockOrm.GetL2BlockHashesByChunkHash(ctx, task.TaskID)
 	if dbErr != nil || len(blockHashes) == 0 {
-		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%v", task.TaskID, dbErr)
+		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%w", task.TaskID, dbErr)
 	}
 
 	var taskDetailBytes []byte

coordinator/internal/logic/verifier/verifier.go

@@ -5,12 +5,10 @@ package verifier
 import (
 	"encoding/base64"
 	"encoding/json"
-	"fmt"
 	"io"
 	"os"
 	"path"
 	"path/filepath"
-	"strings"
 
 	"github.com/scroll-tech/go-ethereum/log"
 
@@ -119,16 +117,6 @@ func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName
 	return libzkp.VerifyBundleProof(string(buf), forkName), nil
 }
 
-/*
-add vk of imcompatilbe circuit app here to avoid we had used them unexpectedly
-25/07/15: 0.5.0rc0 is no longer compatible since a breaking change
-*/
-const blocked_vks = `
-	rSJNNBpsxBdKlstbIIU/aYc7bHau98Qb2yjZMc5PmDhmGOolp5kYRbvF/VcWcO5HN5ujGs6S00W8pZcCoNQRLQ==,
-	2Lo7Cebm6SFtcsYXipkcMxIBmVY7UpoMXik/Msm7t2nyvi9EaNGsSnDnaCurscYEF+IcdjPUtVtY9EcD7IKwWg==,
-	D6YFHwTLZF/U2zpYJPQ3LwJZRm85yA5Vq2iFBqd3Mk4iwOUpS8sbOp3vg2+NDxhhKphgYpuUlykpdsoRhEt+cw==,
-`
-
 func (v *Verifier) loadOpenVMVks(cfg config.AssetConfig) error {
 
 	vkFileName := cfg.Vkfile
@@ -150,16 +138,6 @@ func (v *Verifier) loadOpenVMVks(cfg config.AssetConfig) error {
 	if err := json.Unmarshal(byt, &dump); err != nil {
 		return err
 	}
-	if strings.Contains(blocked_vks, dump.Chunk) {
-		return fmt.Errorf("loaded blocked chunk vk %s", dump.Chunk)
-	}
-	if strings.Contains(blocked_vks, dump.Batch) {
-		return fmt.Errorf("loaded blocked batch vk %s", dump.Batch)
-	}
-	if strings.Contains(blocked_vks, dump.Bundle) {
-		return fmt.Errorf("loaded blocked bundle vk %s", dump.Bundle)
-	}
-
 	v.OpenVMVkMap[dump.Chunk] = struct{}{}
 	v.OpenVMVkMap[dump.Batch] = struct{}{}
 	v.OpenVMVkMap[dump.Bundle] = struct{}{}

crates/gpu_override/.cargo/config.toml

@@ -13,33 +13,33 @@ openvm-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-gpu.git", branch =
 openvm-transpiler = { git = "ssh://git@github.com/scroll-tech/openvm-gpu.git", branch = "patch-v1.2.1-rc.1-pipe", default-features = false }
 
 [patch."https://github.com/openvm-org/stark-backend.git"]
-openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
-openvm-stark-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
+openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "sync/upstream-250702", features = ["gpu"] }
+openvm-stark-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "sync/upstream-250702", features = ["gpu"] }
 
 [patch."https://github.com/Plonky3/Plonky3.git"]
-p3-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-field = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-commit = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-matrix = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
+p3-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-field = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-commit = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-matrix = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
 p3-baby-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", features = [
     "nightly-features",
-], tag = "v0.2.1" }
-p3-koala-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-util = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-challenger = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-dft = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-fri = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-goldilocks = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-keccak = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-keccak-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-blake3 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-mds = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-merkle-tree = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-monty-31 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-poseidon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-poseidon2 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
-p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
-p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.1" }
+], rev = "450ec18" }
+p3-koala-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-util = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-challenger = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-dft = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-fri = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-goldilocks = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-keccak = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-keccak-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-blake3 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-mds = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-merkle-tree = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-monty-31 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-poseidon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-poseidon2 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }
+p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
+p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", rev = "450ec18" }

crates/gpu_override/Makefile

@@ -1,21 +0,0 @@
-.PHONY: build update clean
-
-ZKVM_COMMIT ?= freebuild
-PLONKY3_GPU_VERSION=$(shell ./print_plonky3gpu_version.sh | sed -n '2p')
-$(info PLONKY3_GPU_VERSION is ${PLONKY3_GPU_VERSION})
-
-GIT_REV ?= $(shell git rev-parse --short HEAD)
-GO_TAG ?= $(shell grep "var tag = " ../../common/version/version.go | cut -d "\"" -f2)
-ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_GPU_VERSION}
-$(info ZK_GPU_VERSION is ${ZK_VERSION})
-
-clean:
-	cargo clean -Z unstable-options --release -p prover --lockfile-path ./Cargo.lock
-
-# build gpu prover, never touch lock file
-build:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build -Z unstable-options --release -p prover --lockfile-path ./Cargo.lock
-
-# update Cargo.lock while override config has been updated
-#update:
-#	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build -Z unstable-options --release -p prover --lockfile-path ./Cargo.lock

crates/l2geth/src/rpc_client.rs

@@ -108,42 +108,38 @@ impl ChunkInterpreter for RpcClient<'_> {
                 .get_block_by_hash(block_hash)
                 .full()
                 .await?
-                .ok_or_else(|| eyre::eyre!("Block {block_hash} not found"))?;
+                .ok_or_else(|| eyre::eyre!("Block not found"))?;
 
             let number = block.header.number;
-            let parent_hash = block.header.parent_hash;
             if number == 0 {
                 eyre::bail!("no number in header or use block 0");
             }
 
-            let mut witness_builder = WitnessBuilder::new()
+            let prev_state_root = if let Some(witness) = prev_witness {
+                if witness.header.number != number - 1 {
+                    eyre::bail!(
+                        "the ref witness is not the previous block, expected {} get {}",
+                        number - 1,
+                        witness.header.number,
+                    );
+                }
+                witness.header.state_root
+            } else {
+                provider
+                    .scroll_disk_root((number - 1).into())
+                    .await?
+                    .disk_root
+            };
+
+            let witness = WitnessBuilder::new()
                 .block(block)
                 .chain_id(chain_id)
-                .execution_witness(provider.debug_execution_witness(number.into()).await?);
+                .execution_witness(provider.debug_execution_witness(number.into()).await?)
+                .state_root(provider.scroll_disk_root(number.into()).await?.disk_root)?
+                .prev_state_root(prev_state_root)
+                .build()?;
 
-            let prev_state_root = match prev_witness {
-                Some(witness) => {
-                    if witness.header.number != number - 1 {
-                        eyre::bail!(
-                            "the ref witness is not the previous block, expected {} get {}",
-                            number - 1,
-                            witness.header.number,
-                        );
-                    }
-                    witness.header.state_root
-                }
-                None => {
-                    let parent_block = provider
-                        .get_block_by_hash(parent_hash)
-                        .await?
-                        .expect("parent block should exist");
-
-                    parent_block.header.state_root
-                }
-            };
-            witness_builder = witness_builder.prev_state_root(prev_state_root);
-
-            Ok(witness_builder.build()?)
+            Ok(witness)
         }
 
         tracing::debug!("fetch witness for {block_hash}");

crates/libzkp/Cargo.toml

@@ -9,7 +9,7 @@ scroll-zkvm-types.workspace = true
 scroll-zkvm-verifier-euclid.workspace = true
 
 alloy-primitives.workspace = true #depress the effect of "native-keccak"
-sbv-primitives = {workspace = true, features = ["scroll-compress-ratio", "scroll"]}
+sbv-primitives.workspace = true
 base64.workspace = true
 serde.workspace = true
 serde_derive.workspace = true

crates/libzkp/src/lib.rs

@@ -5,7 +5,7 @@ pub use verifier::{TaskType, VerifierConfig};
 mod utils;
 
 use sbv_primitives::B256;
-use scroll_zkvm_types::util::vec_as_base64;
+use scroll_zkvm_types::{public_inputs::ForkName, util::vec_as_base64};
 use serde::{Deserialize, Serialize};
 use serde_json::value::RawValue;
 use std::path::Path;
@@ -49,39 +49,27 @@ pub fn gen_universal_task(
     let (pi_hash, metadata, mut u_task) = match task_type {
         x if x == TaskType::Chunk as i32 => {
             let mut task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
-            // normailze fork name field in task
-            task.fork_name = task.fork_name.to_lowercase();
-            // always respect the fork_name_str (which has been normalized) being passed
-            // if the fork_name wrapped in task is not match, consider it a malformed task
-            if fork_name_str != task.fork_name.as_str() {
-                eyre::bail!("fork name in chunk task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
-            }
-            let (pi_hash, metadata, u_task) = utils::panic_catch(move || {
-                gen_universal_chunk_task(task, fork_name_str.into(), interpreter)
-            })
-            .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
+            let fork_name = ForkName::from(task.fork_name.to_lowercase().as_str());
+            task.fork_name = fork_name.to_string();
+            assert_eq!(fork_name_str, task.fork_name.as_str());
+            let (pi_hash, metadata, u_task) =
+                gen_universal_chunk_task(task, fork_name, interpreter)?;
             (pi_hash, AnyMetaData::Chunk(metadata), u_task)
         }
         x if x == TaskType::Batch as i32 => {
             let mut task = serde_json::from_str::<BatchProvingTask>(task_json)?;
-            task.fork_name = task.fork_name.to_lowercase();
-            if fork_name_str != task.fork_name.as_str() {
-                eyre::bail!("fork name in batch task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
-            }
-            let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_batch_task(task, fork_name_str.into()))
-                    .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
+            let fork_name = ForkName::from(task.fork_name.to_lowercase().as_str());
+            task.fork_name = fork_name.to_string();
+            assert_eq!(fork_name_str, task.fork_name.as_str());
+            let (pi_hash, metadata, u_task) = gen_universal_batch_task(task, fork_name)?;
             (pi_hash, AnyMetaData::Batch(metadata), u_task)
         }
         x if x == TaskType::Bundle as i32 => {
             let mut task = serde_json::from_str::<BundleProvingTask>(task_json)?;
-            task.fork_name = task.fork_name.to_lowercase();
-            if fork_name_str != task.fork_name.as_str() {
-                eyre::bail!("fork name in bundle task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
-            }
-            let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_bundle_task(task, fork_name_str.into()))
-                    .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
+            let fork_name = ForkName::from(task.fork_name.to_lowercase().as_str());
+            task.fork_name = fork_name.to_string();
+            assert_eq!(fork_name_str, task.fork_name.as_str());
+            let (pi_hash, metadata, u_task) = gen_universal_bundle_task(task, fork_name)?;
             (pi_hash, AnyMetaData::Bundle(metadata), u_task)
         }
         _ => return Err(eyre::eyre!("unrecognized task type {task_type}")),

crates/libzkp/src/tasks.rs

@@ -9,10 +9,7 @@ pub use chunk::{ChunkProvingTask, ChunkTask};
 pub use chunk_interpreter::ChunkInterpreter;
 pub use scroll_zkvm_types::task::ProvingTask;
 
-use crate::{
-    proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
-    utils::panic_catch,
-};
+use crate::proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata};
 use sbv_primitives::B256;
 use scroll_zkvm_types::public_inputs::{ForkName, MultiVersionPublicInputs};
 
@@ -23,14 +20,25 @@ fn check_aggregation_proofs<Metadata>(
 where
     Metadata: proofs::ProofMetadata,
 {
-    panic_catch(|| {
+    use std::panic::{self, AssertUnwindSafe};
+
+    panic::catch_unwind(AssertUnwindSafe(|| {
         for w in proofs.windows(2) {
             w[1].metadata
                 .pi_hash_info()
                 .validate(w[0].metadata.pi_hash_info(), fork_name);
         }
-    })
-    .map_err(|e| eyre::eyre!("Chunk data validation failed: {}", e))?;
+    }))
+    .map_err(|e| {
+        let error_msg = if let Some(string) = e.downcast_ref::<String>() {
+            string.clone()
+        } else if let Some(str) = e.downcast_ref::<&str>() {
+            str.to_string()
+        } else {
+            "Unknown validation error occurred".to_string()
+        };
+        eyre::eyre!("Chunk data validation failed: {}", error_msg)
+    })?;
 
     Ok(())
 }

crates/libzkp/src/tasks/batch.rs

@@ -4,9 +4,8 @@ use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
     batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8, BatchInfo, BatchWitness,
-        Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, PointEvalWitness, ReferenceHeader,
-        ToArchievedWitness, N_BLOB_BYTES,
+        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, Envelope, EnvelopeV6,
+        EnvelopeV7, PointEvalWitness, ReferenceHeader, ToArchievedWitness, N_BLOB_BYTES,
     },
     public_inputs::ForkName,
     task::ProvingTask,
@@ -24,35 +23,37 @@ use utils::{base64, point_eval};
 #[serde(untagged)]
 pub enum BatchHeaderV {
     V6(BatchHeaderV6),
-    V7_8(BatchHeaderV7),
+    V7(BatchHeaderV7),
+}
+
+impl From<BatchHeaderV> for ReferenceHeader {
+    fn from(value: BatchHeaderV) -> Self {
+        match value {
+            BatchHeaderV::V6(h) => ReferenceHeader::V6(h),
+            BatchHeaderV::V7(h) => ReferenceHeader::V7(h),
+        }
+    }
 }
 
 impl BatchHeaderV {
     pub fn batch_hash(&self) -> B256 {
         match self {
             BatchHeaderV::V6(h) => h.batch_hash(),
-            BatchHeaderV::V7_8(h) => h.batch_hash(),
+            BatchHeaderV::V7(h) => h.batch_hash(),
         }
     }
 
     pub fn must_v6_header(&self) -> &BatchHeaderV6 {
         match self {
             BatchHeaderV::V6(h) => h,
-            _ => panic!("try to pick other header type"),
+            BatchHeaderV::V7(_) => panic!("try to pick v7 header"),
         }
     }
 
     pub fn must_v7_header(&self) -> &BatchHeaderV7 {
         match self {
-            BatchHeaderV::V7_8(h) => h,
-            _ => panic!("try to pick other header type"),
-        }
-    }
-
-    pub fn must_v8_header(&self) -> &BatchHeaderV8 {
-        match self {
-            BatchHeaderV::V7_8(h) => h,
-            _ => panic!("try to pick other header type"),
+            BatchHeaderV::V7(h) => h,
+            BatchHeaderV::V6(_) => panic!("try to pick v6 header"),
         }
     }
 }
@@ -119,28 +120,20 @@ impl BatchProvingTask {
                     EnvelopeV6::from_slice(self.blob_bytes.as_slice())
                         .challenge_digest(versioned_hash)
                 }
-                BatchHeaderV::V7_8(_) => {
+                BatchHeaderV::V7(_) => {
+                    match fork_name {
+                        ForkName::EuclidV2 => (),
+                        _ => unreachable!("hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
+                                [ForkName::EuclidV2],
+                            ),
+                    }
                     let padded_blob_bytes = {
                         let mut padded_blob_bytes = self.blob_bytes.to_vec();
                         padded_blob_bytes.resize(N_BLOB_BYTES, 0);
                         padded_blob_bytes
                     };
-
-                    match fork_name {
-                        ForkName::EuclidV2 => {
-                            <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
-                        }
-                        ForkName::Feynman => {
-                            <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
-                        }
-                        f => unreachable!(
-                            "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
-                            f,
-                            [ForkName::EuclidV2, ForkName::Feynman],
-                        ),
-                    }
+                    EnvelopeV7::from_slice(padded_blob_bytes.as_slice())
+                        .challenge_digest(versioned_hash)
                 }
             };
 
@@ -166,11 +159,7 @@ impl BatchProvingTask {
             kzg_proof: kzg_proof.into_inner(),
         };
 
-        let reference_header = match fork_name {
-            ForkName::EuclidV1 => ReferenceHeader::V6(*self.batch_header.must_v6_header()),
-            ForkName::EuclidV2 => ReferenceHeader::V7(*self.batch_header.must_v7_header()),
-            ForkName::Feynman => ReferenceHeader::V8(*self.batch_header.must_v8_header()),
-        };
+        let reference_header = self.batch_header.clone().into();
 
         BatchWitness {
             fork_name,

crates/libzkp_c/src/lib.rs

@@ -64,6 +64,7 @@ fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskT
     let fork_name_str = c_char_to_str(fork_name);
     let proof_str = proof;
     let proof = c_char_to_vec(proof);
+    tracing::info!("verify proof for fork {fork_name_str}, type {task_type}");
 
     match libzkp::verify_proof(proof, fork_name_str, task_type) {
         Err(e) => {
@@ -178,10 +179,13 @@ pub unsafe extern "C" fn gen_universal_task(
         &[]
     };
 
+    let fork_name_str = c_char_to_str(fork_name);
+    tracing::info!("generate universtal task for fork {fork_name_str}, type {task_type}");
+
     let ret = libzkp::gen_universal_task(
         task_type,
         &task_json,
-        c_char_to_str(fork_name),
+        fork_name_str,
         expected_vk,
         interpreter,
     );
@@ -202,8 +206,7 @@ pub unsafe extern "C" fn gen_universal_task(
                 .duration_since(UNIX_EPOCH)
                 .unwrap_or_default()
                 .as_secs();
-            let c_str = unsafe { std::ffi::CStr::from_ptr(fork_name) };
-            let filename = format!("/tmp/task_{}_{}.json", c_str.to_str().unwrap(), timestamp);
+            let filename = format!("/tmp/task_{}_{}.json", fork_name_str, timestamp);
             if let Err(e) = std::fs::write(&filename, task_json.as_bytes()) {
                 eprintln!("Failed to write task to file {}: {}", filename, e);
             } else {

crates/prover-bin/src/main.rs

@@ -5,10 +5,9 @@ mod zk_circuits_handler;
 use clap::{ArgAction, Parser, Subcommand};
 use prover::{LocalProver, LocalProverConfig};
 use scroll_proving_sdk::{
-    prover::{types::ProofType, ProverBuilder},
+    prover::ProverBuilder,
     utils::{get_version, init_tracing},
 };
-use std::{fs::File, io::BufReader, path::Path};
 
 #[derive(Parser, Debug)]
 #[command(disable_version_flag = true)]
@@ -39,17 +38,6 @@ enum Commands {
         /// path to save the verifier's asset
         asset_path: String,
     },
-    Handle {
-        /// path to save the verifier's asset
-        task_path: String,
-    },
-}
-
-#[derive(Debug, serde::Deserialize)]
-struct HandleSet {
-    chunks: Vec<String>,
-    batches: Vec<String>,
-    bundles: Vec<String>,
 }
 
 #[tokio::main]
@@ -74,40 +62,6 @@ async fn main() -> eyre::Result<()> {
             println!("dump assets for {fork_name} into {asset_path}");
             local_prover.dump_verifier_assets(&fork_name, asset_path.as_ref())?;
         }
-        Some(Commands::Handle { task_path }) => {
-            let file = File::open(Path::new(&task_path))?;
-            let reader = BufReader::new(file);
-            let handle_set: HandleSet = serde_json::from_reader(reader)?;
-
-            let prover = ProverBuilder::new(sdk_config, local_prover)
-                .build()
-                .await
-                .map_err(|e| eyre::eyre!("build prover fail: {e}"))?;
-
-            let prover = std::sync::Arc::new(prover);
-            println!("Handling task set 1: chunks ...");
-            assert!(
-                prover
-                    .clone()
-                    .one_shot(&handle_set.chunks, ProofType::Chunk)
-                    .await
-            );
-            println!("Done! Handling task set 2: batches ...");
-            assert!(
-                prover
-                    .clone()
-                    .one_shot(&handle_set.batches, ProofType::Batch)
-                    .await
-            );
-            println!("Done! Handling task set 3: bundles ...");
-            assert!(
-                prover
-                    .clone()
-                    .one_shot(&handle_set.bundles, ProofType::Bundle)
-                    .await
-            );
-            println!("All done!");
-        }
         None => {
             let prover = ProverBuilder::new(sdk_config, local_prover)
                 .build()

crates/prover-bin/src/prover.rs

@@ -203,10 +203,6 @@ impl LocalProver {
             .get(hard_fork_name)
             .ok_or_else(|| eyre::eyre!("no corresponding config for fork {hard_fork_name}"))?;
 
-        if !config.vks.is_empty() {
-            eyre::bail!("clean vks cache first or we will have wrong dumped vk");
-        }
-
         let workspace_path = &config.workspace_path;
         let universal_prover = EuclidV2Handler::new(config);
         let _ = universal_prover

go.work.sum

@@ -1083,7 +1083,9 @@ github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25
 github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
 github.com/holiman/uint256 v1.3.0/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/huin/goupnp v1.0.2/go.mod h1:0dxJBVBHqTMjIUMkESDTNgOOx/Mw5wYIfyFmdzSamkM=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150 h1:vlNjIqmUZ9CMAWsbURYl3a6wZbw7q5RHVvlXTNS/Bs8=
+github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/hydrogen18/memlistener v1.0.0/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE=
 github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
 github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
@@ -1120,6 +1122,7 @@ github.com/intel/goresctrl v0.3.0 h1:K2D3GOzihV7xSBedGxONSlaw/un1LZgWsc9IfqipN4c
 github.com/intel/goresctrl v0.3.0/go.mod h1:fdz3mD85cmP9sHD8JUlrNWAxvwM86CrbmVXltEKd7zk=
 github.com/iris-contrib/jade v1.1.4/go.mod h1:EDqR+ur9piDl6DUgs6qRrlfzmlx/D5UybogqrXvJTBE=
 github.com/iris-contrib/schema v0.0.6/go.mod h1:iYszG0IOsuIsfzjymw1kMzTL8YQcCWlm65f3wX8J5iA=
+github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e h1:UvSe12bq+Uj2hWd8aOlwPmoZ+CITRFrdit+sDGfAg8U=
 github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e/go.mod h1:G1CVv03EnqU1wYL2dFwXxW2An0az9JTl/ZsqXQeBlkU=
 github.com/jedisct1/go-minisign v0.0.0-20230811132847-661be99b8267/go.mod h1:h1nSAbGFqGVzn6Jyl1R/iCcBUHN4g+gW1u9CoBTrb9E=
@@ -1225,6 +1228,7 @@ github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaO
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
@@ -1236,6 +1240,7 @@ github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNx
 github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
 github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
@@ -1413,8 +1418,6 @@ github.com/scroll-tech/go-ethereum v1.10.14-0.20240821074444-b3fa00861e5e/go.mod
 github.com/scroll-tech/go-ethereum v1.10.14-0.20241010064814-3d88e870ae22/go.mod h1:r9FwtxCtybMkTbWYCyBuevT9TW3zHmOTHqD082Uh+Oo=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250206083728-ea43834c198f/go.mod h1:Ik3OBLl7cJxPC+CFyCBYNXBPek4wpdzkWehn/y5qLM8=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20250225152658-bcfdb48dd939/go.mod h1:AgU8JJxC7+nfs7R7ma35AU7dMAGW7wCw3dRZRefIKyQ=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 h1:u371VK8eOU2Z/0SVf5KDI3eJc8msHSpJbav4do/8n38=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
@@ -1451,6 +1454,7 @@ github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0
 github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns=
 github.com/spiffe/go-spiffe/v2 v2.1.1 h1:RT9kM8MZLZIsPTH+HKQEP5yaAk3yd/VBzlINaRjXs8k=
 github.com/spiffe/go-spiffe/v2 v2.1.1/go.mod h1:5qg6rpqlwIub0JAiF1UK9IMD6BpPTmvG6yfSgDBs5lg=
+github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
 github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980 h1:lIOOHPEbXzO3vnmx2gok1Tfs31Q8GQqKLc8vVqyQq/I=
 github.com/stefanberger/go-pkcs11uri v0.0.0-20201008174630-78d3cae3a980/go.mod h1:AO3tvPzVZ/ayst6UlUKUv6rcPQInYe3IknH3jYhAKu8=
 github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU=
@@ -1477,6 +1481,7 @@ github.com/tonistiigi/go-archvariant v1.0.0 h1:5LC1eDWiBNflnTF1prCiX09yfNHIxDC/a
 github.com/tonistiigi/go-archvariant v1.0.0/go.mod h1:TxFmO5VS6vMq2kvs3ht04iPXtu2rUT/erOnGFYfk5Ho=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926 h1:G3dpKMzFDjgEh2q1Z7zUUtKa8ViPtH+ocF0bE0g00O8=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
+github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs=
 github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo=
 github.com/urfave/cli v1.22.12 h1:igJgVw1JdKH+trcLWLeLwZjU9fEfPesQ+9/e4MQ44S8=
 github.com/urfave/cli v1.22.12/go.mod h1:sSBEIC79qR6OvcmsD4U3KABeOTxDqQtdDnaFuUN30b8=
@@ -1711,6 +1716,7 @@ golang.org/x/oauth2 v0.18.0 h1:09qnuIAgzdx1XplqJvW6CQqMCtGZykZWcXzPMPUusvI=
 golang.org/x/oauth2 v0.18.0/go.mod h1:Wf7knwG0MPoWIMMBgFlEaSUDaKskp0dCfrlJRJXbBi8=
 golang.org/x/perf v0.0.0-20230113213139-801c7ef9e5c5/go.mod h1:UBKtEnL8aqnd+0JHqZ+2qoMDwtuy6cYhhKNoHLBiTQc=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -1735,9 +1741,11 @@ golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1803,6 +1811,7 @@ golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.2.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

rollup/cmd/blob_uploader/app/app.go

@@ -70,7 +70,7 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
 	}
 
-	go utils.Loop(subCtx, 1*time.Second, blobUploader.UploadBlobToS3)
+	go utils.Loop(subCtx, 2*time.Second, blobUploader.UploadBlobToS3)
 
 	// Finish start all blob-uploader functions.
 	log.Info("Start blob-uploader successfully", "version", version.Version)

rollup/cmd/rollup_relayer/app/app.go

@@ -107,7 +107,7 @@ func action(ctx *cli.Context) error {
 	}
 
 	chunkProposer := watcher.NewChunkProposer(subCtx, cfg.L2Config.ChunkProposerConfig, minCodecVersion, genesis.Config, db, registry)
-	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, minCodecVersion, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)
+	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, minCodecVersion, genesis.Config, db, registry)
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, minCodecVersion, genesis.Config, db, registry)
 
 	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, registry)

rollup/conf/config.json

@@ -3,7 +3,7 @@
     "endpoint": "https://rpc.ankr.com/eth",
     "start_height": 0,
     "relayer_config": {
-      "gas_price_oracle_contract_address": "0x0000000000000000000000000000000000000000",
+      "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
       "sender_config": {
         "endpoint": "https://rpc.scroll.io",
         "escalate_blocks": 1,
@@ -36,8 +36,8 @@
     "endpoint": "https://rpc.scroll.io",
     "l2_message_queue_address": "0x0000000000000000000000000000000000000000",
     "relayer_config": {
-      "validium_mode": false,
       "rollup_contract_address": "0x0000000000000000000000000000000000000000",
+      "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
       "sender_config": {
         "endpoint": "https://rpc.ankr.com/eth",
         "escalate_blocks": 1,
@@ -123,4 +123,4 @@
     "maxOpenNum": 200,
     "maxIdleNum": 20
   }
-}
+}

rollup/internal/config/relayer.go

@@ -53,8 +53,6 @@ type ChainMonitor struct {
 // RelayerConfig loads relayer configuration items.
 // What we need to pay attention to is that
 type RelayerConfig struct {
-	// ValidiumMode indicates if the relayer is in validium mode.
-	ValidiumMode bool `json:"validium_mode"`
 	// RollupContractAddress store the rollup contract address.
 	RollupContractAddress common.Address `json:"rollup_contract_address,omitempty"`
 	// GasPriceOracleContractAddress store the scroll messenger contract address.
@@ -75,6 +73,8 @@ type RelayerConfig struct {
 
 	// Indicates if bypass features specific to testing environments are enabled.
 	EnableTestEnvBypassFeatures bool `json:"enable_test_env_bypass_features"`
+	// The timeout in seconds for finalizing a batch without proof, only used when EnableTestEnvBypassFeatures is true.
+	FinalizeBatchWithoutProofTimeoutSec uint64 `json:"finalize_batch_without_proof_timeout_sec"`
 	// The timeout in seconds for finalizing a bundle without proof, only used when EnableTestEnvBypassFeatures is true.
 	FinalizeBundleWithoutProofTimeoutSec uint64 `json:"finalize_bundle_without_proof_timeout_sec"`
 }

rollup/internal/controller/blob_uploader/blob_uploader.go

@@ -167,7 +167,7 @@ func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, er
 			Chunks:                     chunks,
 		}
 
-	case encoding.CodecV7, encoding.CodecV8:
+	case encoding.CodecV7:
 		encodingBatch = &encoding.Batch{
 			Index:                  dbBatch.Index,
 			ParentBatchHash:        common.HexToHash(dbBatch.ParentBatchHash),

rollup/internal/controller/blob_uploader/s3_sender.go

@@ -25,6 +25,8 @@ type S3Uploader struct {
 func NewS3Uploader(cfg *config.AWSS3Config) (*S3Uploader, error) {
 	// load AWS config
 	var opts []func(*awsconfig.LoadOptions) error
+	opts = append(opts, awsconfig.WithRegion(cfg.Region))
+
 	// if AccessKey && SecretKey provided, use it
 	if cfg.AccessKey != "" && cfg.SecretKey != "" {
 		opts = append(opts, awsconfig.WithCredentialsProvider(
@@ -36,10 +38,6 @@ func NewS3Uploader(cfg *config.AWSS3Config) (*S3Uploader, error) {
 		)
 	}
 
-	if cfg.Region != "" {
-		opts = append(opts, awsconfig.WithRegion(cfg.Region))
-	}
-
 	awsCfg, err := awsconfig.LoadDefaultConfig(context.Background(), opts...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load default config: %w", err)

rollup/internal/controller/relayer/l2_relayer.go

@@ -79,7 +79,6 @@ type Layer2Relayer struct {
 	commitSender   *sender.Sender
 	finalizeSender *sender.Sender
 	l1RollupABI    *abi.ABI
-	validiumABI    *abi.ABI
 
 	l2GasOracleABI *abi.ABI
 
@@ -173,7 +172,6 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		commitSender:   commitSender,
 		finalizeSender: finalizeSender,
 		l1RollupABI:    bridgeAbi.ScrollChainABI,
-		validiumABI:    bridgeAbi.ValidiumABI,
 
 		l2GasOracleABI: bridgeAbi.L2GasPriceOracleABI,
 		batchStrategy:  strategy,
@@ -241,11 +239,10 @@ func (r *Layer2Relayer) initializeGenesis() error {
 			TotalL1MessagePoppedBefore: 0,
 			ParentBatchHash:            common.Hash{},
 			Chunks:                     []*encoding.Chunk{chunk},
-			Blocks:                     chunk.Blocks,
 		}
 
 		var dbBatch *orm.Batch
-		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, rutils.BatchMetrics{ValidiumMode: r.cfg.ValidiumMode}, dbTX)
+		dbBatch, err = r.batchOrm.InsertBatch(r.ctx, batch, encoding.CodecV0, rutils.BatchMetrics{}, dbTX)
 		if err != nil {
 			return fmt.Errorf("failed to insert batch: %v", err)
 		}
@@ -277,23 +274,10 @@ func (r *Layer2Relayer) initializeGenesis() error {
 }
 
 func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte, stateRoot common.Hash) error {
-	var calldata []byte
-	var packErr error
-
-	if r.cfg.ValidiumMode {
-		// validium mode: only pass batchHeader
-		calldata, packErr = r.validiumABI.Pack("importGenesisBatch", batchHeader)
-		if packErr != nil {
-			return fmt.Errorf("failed to pack validium importGenesisBatch with batch header: %v. error: %v", common.Bytes2Hex(batchHeader), packErr)
-		}
-		log.Info("Validium importGenesis", "calldata", common.Bytes2Hex(calldata))
-	} else {
-		// rollup mode: pass batchHeader and stateRoot
-		calldata, packErr = r.l1RollupABI.Pack("importGenesisBatch", batchHeader, stateRoot)
-		if packErr != nil {
-			return fmt.Errorf("failed to pack rollup importGenesisBatch with batch header: %v and state root: %v. error: %v", common.Bytes2Hex(batchHeader), stateRoot, packErr)
-		}
-		log.Info("Rollup importGenesis", "calldata", common.Bytes2Hex(calldata), "stateRoot", stateRoot)
+	// encode "importGenesisBatch" transaction calldata
+	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
@@ -301,7 +285,7 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 	if err != nil {
 		return fmt.Errorf("failed to send import genesis batch tx to L1, error: %v", err)
 	}
-	log.Info("importGenesisBatch transaction sent", "contract", r.cfg.RollupContractAddress, "txHash", txHash, "batchHash", batchHash, "validium", r.cfg.ValidiumMode)
+	log.Info("importGenesisBatch transaction sent", "contract", r.cfg.RollupContractAddress, "txHash", txHash, "batchHash", batchHash)
 
 	// wait for confirmation
 	// we assume that no other transactions are sent before initializeGenesis completes
@@ -326,23 +310,20 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 			if !confirmation.IsSuccessful {
 				return errors.New("import genesis batch tx failed")
 			}
-			log.Info("Successfully committed genesis batch on L1", "txHash", confirmation.TxHash.String(), "validium", r.cfg.ValidiumMode)
+			log.Info("Successfully committed genesis batch on L1", "txHash", confirmation.TxHash.String())
 			return nil
 		}
 	}
 }
 
 // ProcessPendingBatches processes the pending batches by sending commitBatch transactions to layer 1.
-// Pending batches are submitted if one of the following conditions is met:
+// Pending batchess are submitted if one of the following conditions is met:
 // - the first batch is too old -> forceSubmit
 // - backlogCount > r.cfg.BatchSubmission.BacklogMax -> forceSubmit
 // - we have at least minBatches AND price hits a desired target price
 func (r *Layer2Relayer) ProcessPendingBatches() {
-	// Get effective batch limits based on whether validium mode is enabled.
-	minBatches, maxBatches := r.getEffectiveBatchLimits()
-
 	// get pending batches from database in ascending order by their index.
-	dbBatches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, maxBatches)
+	dbBatches, err := r.batchOrm.GetFailedAndPendingBatches(r.ctx, r.cfg.BatchSubmission.MaxBatches)
 	if err != nil {
 		log.Error("Failed to fetch pending L2 batches", "err", err)
 		return
@@ -451,21 +432,21 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 			break
 		}
 
-		if batchesToSubmitLen < maxBatches {
+		if batchesToSubmitLen < r.cfg.BatchSubmission.MaxBatches {
 			batchesToSubmit = append(batchesToSubmit, &dbBatchWithChunks{
 				Batch:  dbBatch,
 				Chunks: dbChunks,
 			})
 		}
 
-		if len(batchesToSubmit) >= maxBatches {
+		if len(batchesToSubmit) >= r.cfg.BatchSubmission.MaxBatches {
 			break
 		}
 	}
 
 	// we only submit batches if we have a timeout or if we have enough batches to submit
-	if !forceSubmit && len(batchesToSubmit) < minBatches {
-		log.Debug("Not enough batches to submit", "count", len(batchesToSubmit), "minBatches", minBatches, "maxBatches", maxBatches)
+	if !forceSubmit && len(batchesToSubmit) < r.cfg.BatchSubmission.MinBatches {
+		log.Debug("Not enough batches to submit", "count", len(batchesToSubmit), "minBatches", r.cfg.BatchSubmission.MinBatches, "maxBatches", r.cfg.BatchSubmission.MaxBatches)
 		return
 	}
 
@@ -485,22 +466,10 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	codecVersion := encoding.CodecVersion(firstBatch.CodecVersion)
 	switch codecVersion {
 	case encoding.CodecV7, encoding.CodecV8:
-		if r.cfg.ValidiumMode {
-			if len(batchesToSubmit) != 1 {
-				log.Error("validium mode only supports committing one batch at a time", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "batches count", len(batchesToSubmit))
-				return
-			}
-			calldata, maxBlockHeight, totalGasUsed, err = r.constructCommitBatchPayloadValidium(batchesToSubmit[0])
-			if err != nil {
-				log.Error("failed to construct validium payload", "codecVersion", codecVersion, "index", batchesToSubmit[0].Batch.Index, "err", err)
-				return
-			}
-		} else {
-			calldata, blobs, maxBlockHeight, totalGasUsed, err = r.constructCommitBatchPayloadCodecV7(batchesToSubmit, firstBatch, lastBatch)
-			if err != nil {
-				log.Error("failed to construct normal payload", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "err", err)
-				return
-			}
+		calldata, blobs, maxBlockHeight, totalGasUsed, err = r.constructCommitBatchPayloadCodecV7(batchesToSubmit, firstBatch, lastBatch)
+		if err != nil {
+			log.Error("failed to construct constructCommitBatchPayloadCodecV7 payload for V7", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "err", err)
+			return
 		}
 	default:
 		log.Error("unsupported codec version in ProcessPendingBatches", "codecVersion", codecVersion, "start index", firstBatch, "end index", lastBatch.Index)
@@ -553,14 +522,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	log.Info("Sent the commitBatches tx to layer1", "batches count", len(batchesToSubmit), "start index", firstBatch.Index, "start hash", firstBatch.Hash, "end index", lastBatch.Index, "end hash", lastBatch.Hash, "tx hash", txHash.String())
 }
 
-// getEffectiveBatchLimits returns the effective min and max batch limits based on whether validium mode is enabled.
-func (r *Layer2Relayer) getEffectiveBatchLimits() (int, int) {
-	if r.cfg.ValidiumMode {
-		return 1, 1 // minBatches=1, maxBatches=1
-	}
-	return r.cfg.BatchSubmission.MinBatches, r.cfg.BatchSubmission.MaxBatches
-}
-
 func (r *Layer2Relayer) contextIDFromBatches(codecVersion encoding.CodecVersion, batches []*dbBatchWithChunks) string {
 	contextIDs := []string{fmt.Sprintf("v%d", codecVersion)}
 	for _, batch := range batches {
@@ -729,16 +690,9 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 	var calldata []byte
 	switch encoding.CodecVersion(bundle.CodecVersion) {
 	case encoding.CodecV7, encoding.CodecV8:
-		if r.cfg.ValidiumMode {
-			calldata, err = r.constructFinalizeBundlePayloadValidium(dbBatch, endChunk, aggProof)
-			if err != nil {
-				return fmt.Errorf("failed to construct validium finalizeBundle payload, codec version: %v, bundle index: %v, last batch index: %v, err: %w", dbBatch.CodecVersion, bundle.Index, dbBatch.Index, err)
-			}
-		} else {
-			calldata, err = r.constructFinalizeBundlePayloadCodecV7(dbBatch, endChunk, aggProof)
-			if err != nil {
-				return fmt.Errorf("failed to construct normal finalizeBundle payload, codec version: %v, bundle index: %v, last batch index: %v, err: %w", dbBatch.CodecVersion, bundle.Index, dbBatch.Index, err)
-			}
+		calldata, err = r.constructFinalizeBundlePayloadCodecV7(dbBatch, endChunk, aggProof)
+		if err != nil {
+			return fmt.Errorf("failed to construct finalizeBundle payload codecv7, bundle index: %v, last batch index: %v, err: %w", bundle.Index, dbBatch.Index, err)
 		}
 	default:
 		return fmt.Errorf("unsupported codec version in finalizeBundle, bundle index: %v, version: %d", bundle.Index, bundle.CodecVersion)
@@ -997,35 +951,6 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*db
 	return calldata, blobs, maxBlockHeight, totalGasUsed, nil
 }
 
-func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithChunks) ([]byte, uint64, uint64, error) {
-	// Calculate metrics
-	var maxBlockHeight uint64
-	var totalGasUsed uint64
-	for _, c := range batch.Chunks {
-		if c.EndBlockNumber > maxBlockHeight {
-			maxBlockHeight = c.EndBlockNumber
-		}
-		totalGasUsed += c.TotalL2TxGas
-	}
-
-	// Get the commitment from the batch data: for validium mode, we use the last L2 block hash as the commitment to the off-chain data
-	// Get the last chunk from the batch to find the end block hash
-	// TODO: This is a temporary solution, we might use a larger commitment in the future
-	if len(batch.Chunks) == 0 {
-		return nil, 0, 0, fmt.Errorf("last batch has no chunks")
-	}
-
-	lastChunk := batch.Chunks[len(batch.Chunks)-1]
-	commitment := common.HexToHash(lastChunk.EndBlockHash)
-	version := encoding.CodecVersion(batch.Batch.CodecVersion)
-	calldata, err := r.validiumABI.Pack("commitBatch", version, common.HexToHash(batch.Batch.ParentBatchHash), common.HexToHash(batch.Batch.StateRoot), common.HexToHash(batch.Batch.WithdrawRoot), commitment[:])
-	if err != nil {
-		return nil, 0, 0, fmt.Errorf("failed to pack commitBatch: %w", err)
-	}
-	log.Info("Validium commitBatch", "maxBlockHeight", maxBlockHeight, "commitment", commitment.Hex())
-	return calldata, maxBlockHeight, totalGasUsed, nil
-}
-
 func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch, endChunk *orm.Chunk, aggProof *message.OpenVMBundleProof) ([]byte, error) {
 	if aggProof != nil { // finalizeBundle with proof.
 		calldata, packErr := r.l1RollupABI.Pack(
@@ -1042,8 +967,7 @@ func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch
 		return calldata, nil
 	}
 
-	log.Info("Packing finalizeBundlePostEuclidV2NoProof", "batchHeaderLength", len(dbBatch.BatchHeader), "codecVersion", dbBatch.CodecVersion, "totalL1Messages", endChunk.TotalL1MessagesPoppedBefore+endChunk.TotalL1MessagesPoppedInChunk, "stateRoot", dbBatch.StateRoot, "withdrawRoot", dbBatch.WithdrawRoot)
-
+	fmt.Println("packing finalizeBundlePostEuclidV2NoProof", len(dbBatch.BatchHeader), dbBatch.CodecVersion, dbBatch.BatchHeader, new(big.Int).SetUint64(endChunk.TotalL1MessagesPoppedBefore+endChunk.TotalL1MessagesPoppedInChunk), common.HexToHash(dbBatch.StateRoot), common.HexToHash(dbBatch.WithdrawRoot))
 	// finalizeBundle without proof.
 	calldata, packErr := r.l1RollupABI.Pack(
 		"finalizeBundlePostEuclidV2NoProof",
@@ -1058,26 +982,6 @@ func (r *Layer2Relayer) constructFinalizeBundlePayloadCodecV7(dbBatch *orm.Batch
 	return calldata, nil
 }
 
-func (r *Layer2Relayer) constructFinalizeBundlePayloadValidium(dbBatch *orm.Batch, endChunk *orm.Chunk, aggProof *message.OpenVMBundleProof) ([]byte, error) {
-	log.Info("Packing validium finalizeBundle", "batchHeaderLength", len(dbBatch.BatchHeader), "codecVersion", dbBatch.CodecVersion, "totalL1Messages", endChunk.TotalL1MessagesPoppedBefore+endChunk.TotalL1MessagesPoppedInChunk, "stateRoot", dbBatch.StateRoot, "withdrawRoot", dbBatch.WithdrawRoot, "withProof", aggProof != nil)
-
-	var proof []byte
-	if aggProof != nil {
-		proof = aggProof.Proof()
-	}
-
-	calldata, packErr := r.validiumABI.Pack(
-		"finalizeBundle",
-		dbBatch.BatchHeader,
-		new(big.Int).SetUint64(endChunk.TotalL1MessagesPoppedBefore+endChunk.TotalL1MessagesPoppedInChunk),
-		proof,
-	)
-	if packErr != nil {
-		return nil, fmt.Errorf("failed to pack validium finalizeBundle: %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/sender/sender.go

@@ -63,7 +63,7 @@ type FeeData struct {
 	gasLimit uint64
 }
 
-// Sender Transaction sender to send transaction to l1/l2
+// Sender Transaction sender to send transaction to l1/l2 geth
 type Sender struct {
 	config            *config.SenderConfig
 	gethClient        *gethclient.Client
@@ -105,7 +105,13 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 		return nil, fmt.Errorf("failed to create transaction signer, err: %w", err)
 	}
 
-	// Create sender instance first and then initialize nonce
+	// Set pending nonce
+	nonce, err := client.PendingNonceAt(ctx, transactionSigner.GetAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get pending nonce for address %s, err: %w", transactionSigner.GetAddr(), err)
+	}
+	transactionSigner.SetNonce(nonce)
+
 	sender := &Sender{
 		ctx:                   ctx,
 		config:                config,
@@ -121,13 +127,8 @@ func NewSender(ctx context.Context, config *config.SenderConfig, signerConfig *c
 		service:               service,
 		senderType:            senderType,
 	}
-
-	// Initialize nonce using the new method
-	if err := sender.resetNonce(); err != nil {
-		return nil, fmt.Errorf("failed to reset nonce: %w", err)
-	}
-
 	sender.metrics = initSenderMetrics(reg)
+
 	go sender.loop(ctx)
 
 	return sender, nil
@@ -241,10 +242,7 @@ func (s *Sender) SendTransaction(contextID string, target *common.Address, data
 		// Check if contain nonce, and reset nonce
 		// only reset nonce when it is not from resubmit
 		if strings.Contains(err.Error(), "nonce too low") {
-			if err := s.resetNonce(); err != nil {
-				log.Warn("failed to reset nonce after failed send transaction", "address", s.transactionSigner.GetAddr().String(), "err", err)
-				return common.Hash{}, 0, fmt.Errorf("failed to reset nonce after failed send transaction, err: %w", err)
-			}
+			s.resetNonce(context.Background())
 		}
 		return common.Hash{}, 0, fmt.Errorf("failed to send transaction, err: %w", err)
 	}
@@ -329,46 +327,14 @@ func (s *Sender) createTx(feeData *FeeData, target *common.Address, data []byte,
 	return signedTx, nil
 }
 
-// initializeNonce initializes the nonce by taking the maximum of database nonce and pending nonce.
-func (s *Sender) initializeNonce() (uint64, error) {
-	// Get maximum nonce from database
-	dbNonce, err := s.pendingTransactionOrm.GetMaxNonceBySenderAddress(s.ctx, s.transactionSigner.GetAddr().Hex())
-	if err != nil {
-		return 0, fmt.Errorf("failed to get max nonce from database for address %s, err: %w", s.transactionSigner.GetAddr().Hex(), err)
-	}
-
-	// Get pending nonce from the client
-	pendingNonce, err := s.client.PendingNonceAt(s.ctx, s.transactionSigner.GetAddr())
-	if err != nil {
-		return 0, fmt.Errorf("failed to get pending nonce for address %s, err: %w", s.transactionSigner.GetAddr().Hex(), err)
-	}
-
-	// Take the maximum of pending nonce and (db nonce + 1)
-	// Database stores the used nonce, so the next available nonce should be dbNonce + 1
-	// When dbNonce is -1 (no records), dbNonce + 1 = 0, which is correct
-	nextDbNonce := uint64(dbNonce + 1)
-	var finalNonce uint64
-	if pendingNonce > nextDbNonce {
-		finalNonce = pendingNonce
-	} else {
-		finalNonce = nextDbNonce
-	}
-
-	log.Info("nonce initialization", "address", s.transactionSigner.GetAddr().Hex(), "maxDbNonce", dbNonce, "nextDbNonce", nextDbNonce, "pendingNonce", pendingNonce, "finalNonce", finalNonce)
-
-	return finalNonce, nil
-}
-
 // resetNonce reset nonce if send signed tx failed.
-func (s *Sender) resetNonce() error {
-	nonce, err := s.initializeNonce()
+func (s *Sender) resetNonce(ctx context.Context) {
+	nonce, err := s.client.PendingNonceAt(ctx, s.transactionSigner.GetAddr())
 	if err != nil {
-		log.Error("failed to reset nonce", "address", s.transactionSigner.GetAddr().String(), "err", err)
-		return fmt.Errorf("failed to reset nonce, err: %w", err)
+		log.Warn("failed to reset nonce", "address", s.transactionSigner.GetAddr().String(), "err", err)
+		return
 	}
-	log.Info("reset nonce", "address", s.transactionSigner.GetAddr().String(), "nonce", nonce)
 	s.transactionSigner.SetNonce(nonce)
-	return nil
 }
 
 func (s *Sender) createReplacingTransaction(tx *gethTypes.Transaction, baseFee, blobBaseFee uint64) (*gethTypes.Transaction, error) {
@@ -646,16 +612,6 @@ func (s *Sender) checkPendingTransaction() {
 			}
 
 			if err := s.client.SendTransaction(s.ctx, newSignedTx); err != nil {
-				if strings.Contains(err.Error(), "nonce too low") {
-					// When we receive a 'nonce too low' error but cannot find the transaction receipt, it indicates another transaction with this nonce has already been processed, so this transaction will never be mined and should be marked as failed.
-					log.Warn("nonce too low detected, marking all non-confirmed transactions with same nonce as failed", "nonce", originalTx.Nonce(), "address", s.transactionSigner.GetAddr().Hex(), "txHash", originalTx.Hash().Hex(), "newTxHash", newSignedTx.Hash().Hex(), "err", err)
-					txHashes := []string{originalTx.Hash().Hex(), newSignedTx.Hash().Hex()}
-					if updateErr := s.pendingTransactionOrm.UpdateTransactionStatusByTxHashes(s.ctx, txHashes, types.TxStatusConfirmedFailed); updateErr != nil {
-						log.Error("failed to update transaction status", "hashes", txHashes, "err", updateErr)
-						return
-					}
-					return
-				}
 				// SendTransaction failed, need to rollback the previous database changes
 				if rollbackErr := s.db.Transaction(func(tx *gorm.DB) error {
 					// Restore original transaction status back to pending

rollup/internal/controller/watcher/batch_proposer.go

@@ -32,7 +32,6 @@ type BatchProposer struct {
 	cfg *config.BatchProposerConfig
 
 	replayMode      bool
-	validiumMode    bool
 	minCodecVersion encoding.CodecVersion
 	chainCfg        *params.ChainConfig
 
@@ -54,7 +53,7 @@ type BatchProposer struct {
 }
 
 // NewBatchProposer creates a new BatchProposer instance.
-func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minCodecVersion encoding.CodecVersion, chainCfg *params.ChainConfig, db *gorm.DB, validiumMode bool, reg prometheus.Registerer) *BatchProposer {
+func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minCodecVersion encoding.CodecVersion, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BatchProposer {
 	log.Info("new batch proposer", "batchTimeoutSec", cfg.BatchTimeoutSec, "maxBlobSize", maxBlobSize, "maxUncompressedBatchBytesSize", cfg.MaxUncompressedBatchBytesSize)
 
 	p := &BatchProposer{
@@ -64,8 +63,7 @@ func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minC
 		chunkOrm:        orm.NewChunk(db),
 		l2BlockOrm:      orm.NewL2Block(db),
 		cfg:             cfg,
-		replayMode:      false, // default is false, set to true when using proposer tool
-		validiumMode:    validiumMode,
+		replayMode:      false,
 		minCodecVersion: minCodecVersion,
 		chainCfg:        chainCfg,
 
@@ -173,7 +171,7 @@ func (p *BatchProposer) updateDBBatchInfo(batch *encoding.Batch, codecVersion en
 
 		// recalculate batch metrics after truncation
 		var calcErr error
-		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecVersion, p.validiumMode)
+		metrics, calcErr = utils.CalculateBatchMetrics(batch, codecVersion)
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics, batch index: %v, error: %w", batch.Index, calcErr)
 		}
@@ -289,7 +287,7 @@ func (p *BatchProposer) proposeBatch() error {
 		batch.Blocks = append(batch.Blocks, chunk.Blocks...)
 		batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i].PostL1MessageQueueHash)
 
-		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version(), p.validiumMode)
+		metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version())
 		if calcErr != nil {
 			return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 		}
@@ -314,7 +312,7 @@ func (p *BatchProposer) proposeBatch() error {
 			batch.PostL1MessageQueueHash = common.HexToHash(dbChunks[i-1].PostL1MessageQueueHash)
 			batch.Blocks = batch.Blocks[:len(batch.Blocks)-len(lastChunk.Blocks)]
 
-			metrics, err = utils.CalculateBatchMetrics(&batch, codec.Version(), p.validiumMode)
+			metrics, err = utils.CalculateBatchMetrics(&batch, codec.Version())
 			if err != nil {
 				return fmt.Errorf("failed to calculate batch metrics: %w", err)
 			}
@@ -324,7 +322,7 @@ func (p *BatchProposer) proposeBatch() error {
 		}
 	}
 
-	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version(), p.validiumMode)
+	metrics, calcErr := utils.CalculateBatchMetrics(&batch, codec.Version())
 	if calcErr != nil {
 		return fmt.Errorf("failed to calculate batch metrics: %w", calcErr)
 	}

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -100,7 +100,7 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 				DarwinV2Time:   new(uint64),
 				EuclidTime:     new(uint64),
 				EuclidV2Time:   new(uint64),
-			}, db, false /* rollup mode */, nil)
+			}, db, nil)
 			bp.TryProposeBatch()
 
 			batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
@@ -178,7 +178,7 @@ func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
 		MaxChunksPerBatch:             math.MaxInt32,
 		BatchTimeoutSec:               math.MaxUint32,
 		MaxUncompressedBatchBytesSize: math.MaxUint64,
-	}, encoding.CodecV7, chainConfig, db, false /* rollup mode */, nil)
+	}, encoding.CodecV7, chainConfig, db, nil)
 
 	for i := 0; i < 2; i++ {
 		bp.TryProposeBatch()
@@ -246,7 +246,7 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
 		MaxChunksPerBatch:             45,
 		BatchTimeoutSec:               math.MaxUint32,
 		MaxUncompressedBatchBytesSize: math.MaxUint64,
-	}, encoding.CodecV7, chainConfig, db, false /* rollup mode */, nil)
+	}, encoding.CodecV7, chainConfig, db, nil)
 	bp.TryProposeBatch()
 
 	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
@@ -335,7 +335,7 @@ func testBatchProposerUncompressedBatchBytesLimitCodecV8(t *testing.T) {
 		MaxChunksPerBatch:             math.MaxInt32,  // No chunk count limit
 		BatchTimeoutSec:               math.MaxUint32, // No timeout limit
 		MaxUncompressedBatchBytesSize: 4 * 1024,       // 4KiB limit
-	}, encoding.CodecV8, chainConfig, db, false /* rollup mode */, nil)
+	}, encoding.CodecV8, chainConfig, db, nil)
 
 	bp.TryProposeBatch()
 

rollup/internal/controller/watcher/bundle_proposer_test.go

@@ -103,7 +103,7 @@ func testBundleProposerLimitsCodecV7(t *testing.T) {
 				MaxChunksPerBatch:             math.MaxInt32,
 				BatchTimeoutSec:               0,
 				MaxUncompressedBatchBytesSize: math.MaxUint64,
-			}, encoding.CodecV7, chainConfig, db, false /* rollup mode */, nil)
+			}, encoding.CodecV7, chainConfig, db, nil)
 
 			cp.TryProposeChunk()  // chunk1 contains block1
 			bap.TryProposeBatch() // batch1 contains chunk1

rollup/internal/controller/watcher/chunk_proposer.go

@@ -268,9 +268,13 @@ func (p *ChunkProposer) proposeChunk() error {
 		return fmt.Errorf("failed to get parent chunk: %w", err)
 	}
 
-	// Currently rollup-relayer only supports >= v7 codec version, it checks the minimum codec version after start.
-	// In EuclidV2 transition, empty PostL1MessageQueueHash will be naturally initialized to the first chunk's PrevL1MessageQueueHash.
 	chunk.PrevL1MessageQueueHash = common.HexToHash(parentChunk.PostL1MessageQueueHash)
+
+	// previous chunk is not CodecV7, this means this is the first chunk of the fork.
+	if encoding.CodecVersion(parentChunk.CodecVersion) < codecVersion {
+		chunk.PrevL1MessageQueueHash = common.Hash{}
+	}
+
 	chunk.PostL1MessageQueueHash = chunk.PrevL1MessageQueueHash
 
 	var previousPostL1MessageQueueHash common.Hash

rollup/internal/controller/watcher/l2_watcher.go

@@ -88,9 +88,9 @@ func (w *L2WatcherClient) getAndStoreBlocks(ctx context.Context, from, to uint64
 	var blocks []*encoding.Block
 	for number := from; number <= to; number++ {
 		log.Debug("retrieving block", "height", number)
-		block, err := w.BlockByNumber(ctx, new(big.Int).SetUint64(number))
+		block, err := w.GetBlockByNumberOrHash(ctx, rpc.BlockNumberOrHashWithNumber(rpc.BlockNumber(number)))
 		if err != nil {
-			return fmt.Errorf("failed to BlockByNumber: %v. number: %v", err, number)
+			return fmt.Errorf("failed to GetBlockByNumberOrHash: %v. number: %v", err, number)
 		}
 
 		var count int

rollup/internal/controller/watcher/proposer_tool.go

@@ -125,7 +125,7 @@ func NewProposerTool(ctx context.Context, cancel context.CancelFunc, cfg *config
 
 	chunkProposer := NewChunkProposer(ctx, cfg.L2Config.ChunkProposerConfig, minCodecVersion, chainCfg, db, nil)
 	chunkProposer.SetReplayDB(dbForReplay)
-	batchProposer := NewBatchProposer(ctx, cfg.L2Config.BatchProposerConfig, minCodecVersion, chainCfg, db, false /* rollup mode */, nil)
+	batchProposer := NewBatchProposer(ctx, cfg.L2Config.BatchProposerConfig, minCodecVersion, chainCfg, db, nil)
 	batchProposer.SetReplayDB(dbForReplay)
 	bundleProposer := NewBundleProposer(ctx, cfg.L2Config.BundleProposerConfig, minCodecVersion, chainCfg, db, nil)
 

rollup/internal/orm/batch.go

@@ -285,7 +285,7 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, codecVer
 		startChunkIndex = parentBatch.EndChunkIndex + 1
 	}
 
-	batchMeta, err := rutils.GetBatchMetadata(batch, codecVersion, metrics.ValidiumMode)
+	batchMeta, err := rutils.GetBatchMetadata(batch, codecVersion)
 	if err != nil {
 		log.Error("failed to get batch metadata", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
 			"parent hash", batch.ParentBatchHash.Hex(), "number of chunks", numChunks, "err", err)

rollup/internal/orm/blob_upload.go

@@ -115,8 +115,7 @@ func (o *BlobUpload) InsertOrUpdateBlobUpload(ctx context.Context, batchIndex ui
 		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload query error: %w, batch index: %v, batch_hash: %v, platform: %v", err, batchIndex, batchHash, platform)
 	}
 
-	if err := db.Model(&existing).Where("batch_index = ? AND batch_hash = ? AND platform = ? AND deleted_at IS NULL",
-		batchIndex, batchHash, int16(platform)).Update("status", int16(status)).Error; err != nil {
+	if err := db.Model(&existing).Update("status", int16(status)).Error; err != nil {
 		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload update error: %w, batch index: %v, batch_hash: %v, platform: %v", err, batchIndex, batchHash, platform)
 	}
 

rollup/internal/orm/orm_test.go

@@ -597,61 +597,3 @@ func TestPendingTransactionOrm(t *testing.T) {
 	err = pendingTransactionOrm.DeleteTransactionByTxHash(context.Background(), common.HexToHash("0x123"))
 	assert.Error(t, err) // Should return error for non-existent transaction
 }
-
-func TestPendingTransaction_GetMaxNonceBySenderAddress(t *testing.T) {
-	sqlDB, err := db.DB()
-	assert.NoError(t, err)
-	assert.NoError(t, migrate.ResetDB(sqlDB))
-
-	// When there are no transactions for this sender address, should return -1
-	maxNonce, err := pendingTransactionOrm.GetMaxNonceBySenderAddress(context.Background(), "0xdeadbeef")
-	assert.NoError(t, err)
-	assert.Equal(t, int64(-1), maxNonce)
-
-	// Insert two transactions with different nonces for the same sender address
-	senderMeta := &SenderMeta{
-		Name:    "testName",
-		Service: "testService",
-		Address: common.HexToAddress("0xdeadbeef"),
-		Type:    types.SenderTypeCommitBatch,
-	}
-
-	tx0 := gethTypes.NewTx(&gethTypes.DynamicFeeTx{
-		Nonce:      1,
-		To:         &common.Address{},
-		Data:       []byte{},
-		Gas:        21000,
-		AccessList: gethTypes.AccessList{},
-		Value:      big.NewInt(0),
-		ChainID:    big.NewInt(1),
-		GasTipCap:  big.NewInt(0),
-		GasFeeCap:  big.NewInt(1),
-		V:          big.NewInt(0),
-		R:          big.NewInt(0),
-		S:          big.NewInt(0),
-	})
-	tx1 := gethTypes.NewTx(&gethTypes.DynamicFeeTx{
-		Nonce:      3,
-		To:         &common.Address{},
-		Data:       []byte{},
-		Gas:        22000,
-		AccessList: gethTypes.AccessList{},
-		Value:      big.NewInt(0),
-		ChainID:    big.NewInt(1),
-		GasTipCap:  big.NewInt(1),
-		GasFeeCap:  big.NewInt(2),
-		V:          big.NewInt(0),
-		R:          big.NewInt(0),
-		S:          big.NewInt(0),
-	})
-
-	err = pendingTransactionOrm.InsertPendingTransaction(context.Background(), "test", senderMeta, tx0, 0)
-	assert.NoError(t, err)
-	err = pendingTransactionOrm.InsertPendingTransaction(context.Background(), "test", senderMeta, tx1, 0)
-	assert.NoError(t, err)
-
-	// Now the max nonce for this sender should be 3
-	maxNonce, err = pendingTransactionOrm.GetMaxNonceBySenderAddress(context.Background(), senderMeta.Address.String())
-	assert.NoError(t, err)
-	assert.Equal(t, int64(3), maxNonce)
-}

rollup/internal/orm/pending_transaction.go

@@ -3,7 +3,6 @@ package orm
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
@@ -192,25 +191,6 @@ func (o *PendingTransaction) UpdateTransactionStatusByTxHash(ctx context.Context
 	return nil
 }
 
-// UpdateTransactionStatusByTxHashes updates the status of multiple transactions by their hashes in one SQL statement
-func (o *PendingTransaction) UpdateTransactionStatusByTxHashes(ctx context.Context, txHashes []string, status types.TxStatus, dbTX ...*gorm.DB) error {
-	if len(txHashes) == 0 {
-		return nil
-	}
-	db := o.db
-	if len(dbTX) > 0 && dbTX[0] != nil {
-		db = dbTX[0]
-	}
-	db = db.WithContext(ctx)
-	db = db.Model(&PendingTransaction{})
-	db = db.Where("hash IN ?", txHashes)
-	if err := db.Update("status", status).Error; err != nil {
-		return fmt.Errorf("failed to update transaction status for hashes %v to status %d: %w", txHashes, status, err)
-	}
-
-	return nil
-}
-
 // UpdateOtherTransactionsAsFailedByNonce updates the status of all transactions to TxStatusConfirmedFailed for a specific nonce and sender address, excluding a specified transaction hash.
 func (o *PendingTransaction) UpdateOtherTransactionsAsFailedByNonce(ctx context.Context, senderAddress string, nonce uint64, hash common.Hash, dbTX ...*gorm.DB) error {
 	db := o.db
@@ -227,27 +207,3 @@ func (o *PendingTransaction) UpdateOtherTransactionsAsFailedByNonce(ctx context.
 	}
 	return nil
 }
-
-// GetMaxNonceBySenderAddress retrieves the maximum nonce for a specific sender address.
-// Returns -1 if no transactions are found for the given address.
-func (o *PendingTransaction) GetMaxNonceBySenderAddress(ctx context.Context, senderAddress string) (int64, error) {
-	var result struct {
-		Nonce int64 `gorm:"column:nonce"`
-	}
-
-	err := o.db.WithContext(ctx).
-		Model(&PendingTransaction{}).
-		Select("nonce").
-		Where("sender_address = ?", senderAddress).
-		Order("nonce DESC").
-		First(&result).Error
-
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return -1, nil
-		}
-		return -1, fmt.Errorf("failed to get max nonce by sender address, address: %s, err: %w", senderAddress, err)
-	}
-
-	return result.Nonce, nil
-}

rollup/internal/utils/utils.go

@@ -1,13 +1,11 @@
 package utils
 
 import (
-	"encoding/binary"
 	"fmt"
 	"time"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/crypto"
 )
 
 // ChunkMetrics indicates the metrics for proposing a chunk.
@@ -62,18 +60,15 @@ type BatchMetrics struct {
 	L1CommitBlobSize                   uint64
 	L1CommitUncompressedBatchBytesSize uint64
 
-	ValidiumMode bool // default false: rollup mode
-
 	// timing metrics
 	EstimateBlobSizeTime time.Duration
 }
 
 // CalculateBatchMetrics calculates batch metrics.
-func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVersion, validiumMode bool) (*BatchMetrics, error) {
+func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetrics, error) {
 	metrics := &BatchMetrics{
 		NumChunks:           uint64(len(batch.Chunks)),
 		FirstBlockTimestamp: batch.Chunks[0].Blocks[0].Header.Time,
-		ValidiumMode:        validiumMode,
 	}
 
 	codec, err := encoding.CodecFromVersion(codecVersion)
@@ -124,59 +119,8 @@ type BatchMetadata struct {
 	ChallengeDigest    common.Hash
 }
 
-// encodeBatchHeaderValidium encodes batch header for validium mode and returns both encoded bytes and hash
-func encodeBatchHeaderValidium(b *encoding.Batch, codecVersion encoding.CodecVersion) ([]byte, common.Hash, error) {
-	if b == nil {
-		return nil, common.Hash{}, fmt.Errorf("batch is nil, version: %v, index: %v", codecVersion, b.Index)
-	}
-
-	if len(b.Blocks) == 0 {
-		return nil, common.Hash{}, fmt.Errorf("batch contains no blocks, version: %v, index: %v", codecVersion, b.Index)
-	}
-
-	// For validium mode, use the last block hash as commitment to the off-chain data
-	// TODO: This is a temporary solution, we might use a larger commitment in the future
-	lastBlock := b.Blocks[len(b.Blocks)-1]
-	commitment := lastBlock.Header.Hash()
-
-	// Batch header field sizes
-	const (
-		versionSize      = 1
-		indexSize        = 8
-		parentHashSize   = 32
-		stateRootSize    = 32
-		withdrawRootSize = 32
-		commitmentSize   = 32 // TODO: 32 bytes for now, might use larger commitment in the future
-
-		// Total size of validium batch header
-		validiumBatchHeaderSize = versionSize + indexSize + parentHashSize + stateRootSize + withdrawRootSize + commitmentSize
-	)
-
-	batchBytes := make([]byte, validiumBatchHeaderSize)
-
-	// Define offsets for each field
-	var (
-		versionOffset      = 0
-		indexOffset        = versionOffset + versionSize
-		parentHashOffset   = indexOffset + indexSize
-		stateRootOffset    = parentHashOffset + parentHashSize
-		withdrawRootOffset = stateRootOffset + stateRootSize
-		commitmentOffset   = withdrawRootOffset + withdrawRootSize
-	)
-
-	batchBytes[versionOffset] = uint8(codecVersion)                                                                        // version
-	binary.BigEndian.PutUint64(batchBytes[indexOffset:indexOffset+indexSize], b.Index)                                     // batch index
-	copy(batchBytes[parentHashOffset:parentHashOffset+parentHashSize], b.ParentBatchHash[0:parentHashSize])                // parentBatchHash
-	copy(batchBytes[stateRootOffset:stateRootOffset+stateRootSize], b.StateRoot().Bytes()[0:stateRootSize])                // postStateRoot
-	copy(batchBytes[withdrawRootOffset:withdrawRootOffset+withdrawRootSize], b.WithdrawRoot().Bytes()[0:withdrawRootSize]) // postWithdrawRoot
-	copy(batchBytes[commitmentOffset:commitmentOffset+commitmentSize], commitment[0:commitmentSize])                       // data commitment
-
-	hash := crypto.Keccak256Hash(batchBytes)
-	return batchBytes, hash, nil
-}
-
 // GetBatchMetadata retrieves the metadata of a batch.
-func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion, validiumMode bool) (*BatchMetadata, error) {
+func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion) (*BatchMetadata, error) {
 	codec, err := encoding.CodecFromVersion(codecVersion)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get codec from version: %v, err: %w", codecVersion, err)
@@ -195,17 +139,9 @@ func GetBatchMetadata(batch *encoding.Batch, codecVersion encoding.CodecVersion,
 		ChallengeDigest: daBatch.ChallengeDigest(),
 	}
 
-	// If this function is used in Validium, we encode the batch header differently.
-	if validiumMode {
-		batchMeta.BatchBytes, batchMeta.BatchHash, err = encodeBatchHeaderValidium(batch, codecVersion)
-		if err != nil {
-			return nil, fmt.Errorf("failed to encode batch header for validium, version: %v, index: %v, err: %w", codecVersion, batch.Index, err)
-		}
-	}
-
 	batchMeta.BatchBlobDataProof, err = daBatch.BlobDataProofForPointEvaluation()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get blob data proof, version: %v, index: %v, err: %w", codecVersion, batch.Index, err)
+		return nil, fmt.Errorf("failed to get blob data proof, version: %v, err: %w", codecVersion, err)
 	}
 
 	numChunks := len(batch.Chunks)

rollup/tests/rollup_test.go

@@ -128,7 +128,7 @@ func testCommitBatchAndFinalizeBundleCodecV7(t *testing.T) {
 		MaxChunksPerBatch:             math.MaxInt32,
 		BatchTimeoutSec:               300,
 		MaxUncompressedBatchBytesSize: math.MaxUint64,
-	}, encoding.CodecV7, chainConfig, db, false /* rollup mode */, nil)
+	}, encoding.CodecV7, chainConfig, db, nil)
 
 	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{
 		MaxBatchNumPerBundle: 2,

zkvm-prover/Makefile

@@ -3,7 +3,7 @@
 RUST_MIN_STACK ?= 16777216
 export RUST_MIN_STACK
 
-CIRCUIT_STUFF = .work/euclid/chunk/app.vmexe .work/feynman/chunk/app.vmexe
+CIRCUIT_STUFF = .work/chunk/app.vmexe .work/batch/app.vmexe .work/bundle/app.vmexe
 
 ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
     PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
@@ -21,7 +21,7 @@ endif
 ZKVM_COMMIT=$(shell echo ${ZKVM_VERSION} | cut -d " " -f2)
 $(info ZKVM_COMMIT is ${ZKVM_COMMIT})
 
-$(info PLONKY3_VERSION is ${PLONKY3_VERSION})
+#PLONKY3_GPU_VERSION=$(shell ./print_plonky3gpu_version.sh | sed -n '2p')
 
 GIT_REV=$(shell git rev-parse --short HEAD)
 GO_TAG=$(shell grep "var tag = " ../common/version/version.go | cut -d "\"" -f2)
@@ -33,15 +33,25 @@ else
 endif
 
 ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_VERSION}
+#ifeq (${PLONKY3_GPU_VERSION},)
+#	# use plonky3 with CPU
+#    ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_VERSION}
+#else
+#	# use gpu
+#    ZK_VERSION=${ZKVM_COMMIT}-${PLONKY3_GPU_VERSION}
+#endif
 
-E2E_HANDLE_SET = ../tests/prover-e2e/testset.json
-DUMP_DIR = .work
+prover_gpu:
+	cd ../crates/gpu_override && cargo tree >/dev/null
+	$(eval PLONKY3_GPU_VERSION:=$(shell ./print_plonky3gpu_version.sh | sed -n '2p'))
+	$(eval ZK_VERSION:=${ZKVM_COMMIT}-${PLONKY3_GPU_VERSION})
+	@echo "Updated ZK_VERSION to ${ZK_VERSION} after prover_gpu"
 
-prover:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZKVM_COMMIT=${ZKVM_COMMIT} $(MAKE) -C ../crates/gpu_override build
+prover: prover_gpu
+	cd ../crates/gpu_override && GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release -p prover
 
 prover_cpu:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --locked --release -p prover
+	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release -p prover
 
 
 tests_binary:
@@ -54,15 +64,7 @@ lint:
 	cargo fmt --all
 
 $(CIRCUIT_STUFF):
-	@echo "Download stuff with download-release.sh, and put them into correct directory";
-	@exit 1;
+	bash .work/download-release.sh
 
 test_run: $(CIRCUIT_STUFF)
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo run --release -p prover -- --config ./config.json
-
-test_e2e_run: $(CIRCUIT_STUFF) ${E2E_HANDLE_SET}
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo run --release -p prover -- --config ./config.json handle ${E2E_HANDLE_SET}
-
-gen_verifier_stuff:
-	mkdir -p ${DUMP_DIR}
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo run --release -p prover -- --config ./config.json --forkname feynman dump ${DUMP_DIR}
+	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo run --release -p prover -- --config ./config.json

zkvm-prover/download-release.sh

@@ -3,7 +3,7 @@
 # Define version mapping
 declare -A VERSION_MAP
 VERSION_MAP["euclid"]="0.4.3"
-VERSION_MAP["feynman"]="0.5.0rc1"
+VERSION_MAP["feynman"]="0.5.0rc0"
 
 # release version
 if [ -z "${SCROLL_ZKVM_VERSION}" ]; then

zkvm-prover/print_plonky3gpu_version.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-config_file=.cargo/config.toml
+config_file=~/.cargo/config.toml
 plonky3_gpu_path=$(grep 'path.*plonky3-gpu' "$config_file" | cut -d'"' -f2 | head -n 1)
 plonky3_gpu_path=$(dirname "$plonky3_gpu_path")
 

zkvm-prover/release-verifier-stuff.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-# release version
-SCROLL_ZKVM_STUFFDIR ?= `realpath .work`
-SCROLL_ZKVM_VERSION ?= 0.5.0rc1
-DIR_OUTPUT="releases/${SCROLL_ZKVM_VERSION}/verifier"
-
-STUFF_FILES=('root-verifier-committed-exe' 'root-verifier-vm-config' 'verifier.bin' 'openVmVk.json')
-
-for stuff_file in "${STUFF_FILES[@]}"; do
-  SRC="${SCROLL_ZKVM_STUFFDIR}/${stuff_file}"
-  TARGET="${DIR_OUTPUT}/${stuff_file}"
-  aws --profile default s3 cp $SRC s3://circuit-release/scroll-zkvm/$TARGET
-done