fix(rollup-relayer): upgrade boundary message queue hash initialization (#1706 )

circuit-0.5.2 (#1705 )
Co-authored-by: georgehao <georgehao@users.noreply.github.com>
2026-01-11 23:18:07 -05:00 · 2025-07-23 18:51:56 +08:00 · 2025-07-23 14:16:16 +08:00 · 2025-07-23 10:52:08 +08:00 · 2025-07-21 20:26:39 +08:00 · 2025-07-18 16:41:59 +08:00
24 changed files with 11887 additions and 511 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/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", rev = "0dd7b19", package = "scroll-zkvm-prover" }
-scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "0dd7b19", package = "scroll-zkvm-verifier" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "0dd7b19" }
+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" }

-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" }
+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" }

 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-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" }
+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" }

 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
--- a/common/version/version.go
+++ b/common/version/version.go
@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )

-var tag = "v4.5.30"
+var tag = "v4.5.34"

 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
--- a/coordinator/Makefile
+++ b/coordinator/Makefile
@@ -1,4 +1,4 @@
-.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator
+.PHONY: lint docker clean coordinator coordinator_skip_libzkp mock_coordinator libzkp

 IMAGE_VERSION=latest
 REPO_ROOT_DIR=./..
--- a/coordinator/internal/logic/provertask/batch_prover_task.go
+++ b/coordinator/internal/logic/provertask/batch_prover_task.go
@@ -86,6 +86,10 @@ 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)
@@ -95,6 +99,14 @@ 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 {
--- a/coordinator/internal/logic/provertask/bundle_prover_task.go
+++ b/coordinator/internal/logic/provertask/bundle_prover_task.go
@@ -84,6 +84,10 @@ 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)
@@ -93,6 +97,14 @@ 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 {
@@ -234,9 +246,14 @@ 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)
 	}

-	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 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)
 	}

 	var batchProofs []*message.OpenVMBatchProof
@@ -255,7 +272,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov

 	taskDetail.BundleInfo = &message.OpenVMBundleInfo{
 		ChainID:       bp.cfg.L2.ChainID,
-		PrevStateRoot: common.HexToHash(parentBatch.StateRoot),
+		PrevStateRoot: prevStateRoot,
 		PostStateRoot: common.HexToHash(batches[len(batches)-1].StateRoot),
 		WithdrawRoot:  common.HexToHash(batches[len(batches)-1].WithdrawRoot),
 		NumBatches:    uint32(len(batches)),
--- a/coordinator/internal/logic/provertask/chunk_prover_task.go
+++ b/coordinator/internal/logic/provertask/chunk_prover_task.go
@@ -80,7 +80,12 @@ 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 {
@@ -91,6 +96,14 @@ 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 {
@@ -221,7 +234,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:%w", task.TaskID, dbErr)
+		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%v", task.TaskID, dbErr)
 	}

 	var taskDetailBytes []byte
--- a/coordinator/internal/logic/verifier/verifier.go
+++ b/coordinator/internal/logic/verifier/verifier.go
@@ -5,10 +5,12 @@ package verifier
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"io"
 	"os"
 	"path"
 	"path/filepath"
+	"strings"

 	"github.com/scroll-tech/go-ethereum/log"

@@ -117,6 +119,16 @@ 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
@@ -138,6 +150,16 @@ 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{}{}
--- a/crates/gpu_override/.cargo/config.toml
+++ b/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 = "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"] }
+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"] }

 [patch."https://github.com/Plonky3/Plonky3.git"]
-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-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-baby-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", features = [
    "nightly-features",
-], 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" }
+], 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" }
--- a/crates/gpu_override/Cargo.lock
+++ b/crates/gpu_override/Cargo.lock
--- a/crates/gpu_override/Makefile
+++ b/crates/gpu_override/Makefile
@@ -0,0 +1,21 @@
+.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
--- a/crates/gpu_override/print_plonky3gpu_version.sh
+++ b/crates/gpu_override/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")

--- a/crates/l2geth/src/rpc_client.rs
+++ b/crates/l2geth/src/rpc_client.rs
@@ -108,38 +108,42 @@ impl ChunkInterpreter for RpcClient<'_> {
                .get_block_by_hash(block_hash)
                .full()
                .await?
-                .ok_or_else(|| eyre::eyre!("Block not found"))?;
+                .ok_or_else(|| eyre::eyre!("Block {block_hash} 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 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()
+            let mut witness_builder = WitnessBuilder::new()
                .block(block)
                .chain_id(chain_id)
-                .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()?;
+                .execution_witness(provider.debug_execution_witness(number.into()).await?);

-            Ok(witness)
+            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()?)
        }

        tracing::debug!("fetch witness for {block_hash}");
--- a/crates/libzkp/Cargo.toml
+++ b/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
+sbv-primitives = {workspace = true, features = ["scroll-compress-ratio", "scroll"]}
 base64.workspace = true
 serde.workspace = true
 serde_derive.workspace = true
--- a/crates/libzkp/src/lib.rs
+++ b/crates/libzkp/src/lib.rs
@@ -30,7 +30,7 @@ pub fn checkout_chunk_task(
 pub fn gen_universal_task(
    task_type: i32,
    task_json: &str,
-    fork_name: &str,
+    fork_name_str: &str,
    expected_vk: &[u8],
    interpreter: Option<impl ChunkInterpreter>,
 ) -> eyre::Result<(B256, String, String)> {
@@ -48,19 +48,40 @@ pub fn gen_universal_task(

    let (pi_hash, metadata, mut u_task) = match task_type {
        x if x == TaskType::Chunk as i32 => {
-            let task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) =
-                gen_universal_chunk_task(task, fork_name.into(), interpreter)?;
+            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}"))??;
            (pi_hash, AnyMetaData::Chunk(metadata), u_task)
        }
        x if x == TaskType::Batch as i32 => {
-            let task = serde_json::from_str::<BatchProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) = gen_universal_batch_task(task, fork_name.into())?;
+            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}"))??;
            (pi_hash, AnyMetaData::Batch(metadata), u_task)
        }
        x if x == TaskType::Bundle as i32 => {
-            let task = serde_json::from_str::<BundleProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) = gen_universal_bundle_task(task, fork_name.into())?;
+            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}"))??;
            (pi_hash, AnyMetaData::Bundle(metadata), u_task)
        }
        _ => return Err(eyre::eyre!("unrecognized task type {task_type}")),
@@ -111,24 +132,6 @@ pub fn verify_proof(proof: Vec<u8>, fork_name: &str, task_type: TaskType) -> eyr
    let verifier = verifier::get_verifier(fork_name)?;

    let ret = verifier.lock().unwrap().verify(task_type, &proof)?;
-
-    if let Ok(debug_value) = std::env::var("ZKVM_DEBUG_PROOF") {
-        use std::time::{SystemTime, UNIX_EPOCH};
-        if !ret && debug_value.to_lowercase() == "true" {
-            // Dump req.input to a temporary file
-            let timestamp = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap_or_default()
-                .as_secs();
-            let filename = format!("/tmp/proof_{}.json", timestamp);
-            if let Err(e) = std::fs::write(&filename, &proof) {
-                eprintln!("Failed to write proof to file {}: {}", filename, e);
-            } else {
-                println!("Dumped failed proof to {}", filename);
-            }
-        }
-    }
-
    Ok(ret)
 }

--- a/crates/libzkp/src/tasks.rs
+++ b/crates/libzkp/src/tasks.rs
@@ -9,7 +9,10 @@ pub use chunk::{ChunkProvingTask, ChunkTask};
 pub use chunk_interpreter::ChunkInterpreter;
 pub use scroll_zkvm_types::task::ProvingTask;

-use crate::proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata};
+use crate::{
+    proofs::{self, BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
+    utils::panic_catch,
+};
 use sbv_primitives::B256;
 use scroll_zkvm_types::public_inputs::{ForkName, MultiVersionPublicInputs};

@@ -20,25 +23,14 @@ fn check_aggregation_proofs<Metadata>(
 where
    Metadata: proofs::ProofMetadata,
 {
-    use std::panic::{self, AssertUnwindSafe};
-
-    panic::catch_unwind(AssertUnwindSafe(|| {
+    panic_catch(|| {
        for w in proofs.windows(2) {
            w[1].metadata
                .pi_hash_info()
                .validate(w[0].metadata.pi_hash_info(), fork_name);
        }
-    }))
-    .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)
-    })?;
+    })
+    .map_err(|e| eyre::eyre!("Chunk data validation failed: {}", e))?;

    Ok(())
 }
--- a/crates/libzkp/src/tasks/batch.rs
+++ b/crates/libzkp/src/tasks/batch.rs
@@ -4,8 +4,9 @@ use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
    batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, Envelope, EnvelopeV6,
-        EnvelopeV7, PointEvalWitness, ReferenceHeader, ToArchievedWitness, N_BLOB_BYTES,
+        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8, BatchInfo, BatchWitness,
+        Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, PointEvalWitness, ReferenceHeader,
+        ToArchievedWitness, N_BLOB_BYTES,
    },
    public_inputs::ForkName,
    task::ProvingTask,
@@ -23,37 +24,35 @@ use utils::{base64, point_eval};
 #[serde(untagged)]
 pub enum BatchHeaderV {
    V6(BatchHeaderV6),
-    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),
-        }
-    }
+    V7_8(BatchHeaderV7),
 }

 impl BatchHeaderV {
    pub fn batch_hash(&self) -> B256 {
        match self {
            BatchHeaderV::V6(h) => h.batch_hash(),
-            BatchHeaderV::V7(h) => h.batch_hash(),
+            BatchHeaderV::V7_8(h) => h.batch_hash(),
        }
    }

    pub fn must_v6_header(&self) -> &BatchHeaderV6 {
        match self {
            BatchHeaderV::V6(h) => h,
-            BatchHeaderV::V7(_) => panic!("try to pick v7 header"),
+            _ => panic!("try to pick other header type"),
        }
    }

    pub fn must_v7_header(&self) -> &BatchHeaderV7 {
        match self {
-            BatchHeaderV::V7(h) => h,
-            BatchHeaderV::V6(_) => panic!("try to pick v6 header"),
+            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"),
        }
    }
 }
@@ -120,20 +119,28 @@ impl BatchProvingTask {
                    EnvelopeV6::from_slice(self.blob_bytes.as_slice())
                        .challenge_digest(versioned_hash)
                }
-                BatchHeaderV::V7(_) => {
-                    match fork_name {
-                        ForkName::EuclidV2 => (),
-                        _ => unreachable!("hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
-                                [ForkName::EuclidV2],
-                            ),
-                    }
+                BatchHeaderV::V7_8(_) => {
                    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
                    };
-                    EnvelopeV7::from_slice(padded_blob_bytes.as_slice())
-                        .challenge_digest(versioned_hash)
+
+                    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],
+                        ),
+                    }
                }
            };

@@ -159,7 +166,11 @@ impl BatchProvingTask {
            kzg_proof: kzg_proof.into_inner(),
        };

-        let reference_header = self.batch_header.clone().into();
+        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()),
+        };

        BatchWitness {
            fork_name,
--- a/crates/libzkp_c/src/lib.rs
+++ b/crates/libzkp_c/src/lib.rs
@@ -9,6 +9,16 @@ use std::sync::OnceLock;

 static LOG_SETTINGS: OnceLock<Result<(), String>> = OnceLock::new();

+fn enable_dump() -> bool {
+    static ZKVM_DEBUG_DUMP: OnceLock<bool> = OnceLock::new();
+    *ZKVM_DEBUG_DUMP.get_or_init(|| {
+        std::env::var("ZKVM_DEBUG")
+            .or_else(|_| std::env::var("ZKVM_DEBUG_PROOF"))
+            .map(|s| s.to_lowercase() == "true")
+            .unwrap_or(false)
+    })
+}
+
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn init_tracing() {
@@ -52,6 +62,7 @@ pub unsafe extern "C" fn init_l2geth(config: *const c_char) {

 fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
    let fork_name_str = c_char_to_str(fork_name);
+    let proof_str = proof;
    let proof = c_char_to_vec(proof);

    match libzkp::verify_proof(proof, fork_name_str, task_type) {
@@ -59,7 +70,24 @@ fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskT
            tracing::error!("{:?} verify failed, error: {:#}", task_type, e);
            false as c_char
        }
-        Ok(result) => result as c_char,
+        Ok(result) => {
+            if !result && enable_dump() {
+                use std::time::{SystemTime, UNIX_EPOCH};
+                // Dump req.input to a temporary file
+                let timestamp = SystemTime::now()
+                    .duration_since(UNIX_EPOCH)
+                    .unwrap_or_default()
+                    .as_secs();
+                let filename = format!("/tmp/proof_{}.json", timestamp);
+                let cstr = unsafe { std::ffi::CStr::from_ptr(proof_str) };
+                if let Err(e) = std::fs::write(&filename, cstr.to_bytes()) {
+                    eprintln!("Failed to write proof to file {}: {}", filename, e);
+                } else {
+                    println!("Dumped failed proof to {}", filename);
+                }
+            }
+            result as c_char
+        }
    }
 }

@@ -167,6 +195,22 @@ pub unsafe extern "C" fn gen_universal_task(
            expected_pi_hash,
        }
    } else {
+        if enable_dump() {
+            use std::time::{SystemTime, UNIX_EPOCH};
+            // Dump req.input to a temporary file
+            let timestamp = SystemTime::now()
+                .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);
+            if let Err(e) = std::fs::write(&filename, task_json.as_bytes()) {
+                eprintln!("Failed to write task to file {}: {}", filename, e);
+            } else {
+                println!("Dumped failed task to {}", filename);
+            }
+        }
+
        tracing::error!("gen_universal_task failed, error: {:#}", ret.unwrap_err());
        failed_handling_result()
    }
--- a/crates/prover-bin/src/main.rs
+++ b/crates/prover-bin/src/main.rs
@@ -5,9 +5,10 @@ mod zk_circuits_handler;
 use clap::{ArgAction, Parser, Subcommand};
 use prover::{LocalProver, LocalProverConfig};
 use scroll_proving_sdk::{
-    prover::ProverBuilder,
+    prover::{types::ProofType, ProverBuilder},
    utils::{get_version, init_tracing},
 };
+use std::{fs::File, io::BufReader, path::Path};

 #[derive(Parser, Debug)]
 #[command(disable_version_flag = true)]
@@ -38,6 +39,17 @@ 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]
@@ -62,6 +74,40 @@ 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()
--- a/crates/prover-bin/src/prover.rs
+++ b/crates/prover-bin/src/prover.rs
@@ -203,6 +203,10 @@ 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
--- a/rollup/internal/controller/watcher/chunk_proposer.go
+++ b/rollup/internal/controller/watcher/chunk_proposer.go
@@ -268,13 +268,9 @@ 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
--- a/zkvm-prover/Makefile
+++ b/zkvm-prover/Makefile
@@ -3,7 +3,7 @@
 RUST_MIN_STACK ?= 16777216
 export RUST_MIN_STACK

-CIRCUIT_STUFF = .work/chunk/app.vmexe .work/batch/app.vmexe .work/bundle/app.vmexe
+CIRCUIT_STUFF = .work/euclid/chunk/app.vmexe .work/feynman/chunk/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})

-#PLONKY3_GPU_VERSION=$(shell ./print_plonky3gpu_version.sh | sed -n '2p')
+$(info PLONKY3_VERSION is ${PLONKY3_VERSION})

 GIT_REV=$(shell git rev-parse --short HEAD)
 GO_TAG=$(shell grep "var tag = " ../common/version/version.go | cut -d "\"" -f2)
@@ -33,25 +33,15 @@ 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

-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"
+E2E_HANDLE_SET = ../tests/prover-e2e/testset.json
+DUMP_DIR = .work

-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:
+	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZKVM_COMMIT=${ZKVM_COMMIT} $(MAKE) -C ../crates/gpu_override build

 prover_cpu:
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --release -p prover
+	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo build --locked --release -p prover


 tests_binary:
@@ -64,7 +54,15 @@ lint:
 	cargo fmt --all

 $(CIRCUIT_STUFF):
-	bash .work/download-release.sh
+	@echo "Download stuff with download-release.sh, and put them into correct directory";
+	@exit 1;

 test_run: $(CIRCUIT_STUFF)
-	GO_TAG=${GO_TAG} GIT_REV=${GIT_REV} ZK_VERSION=${ZK_VERSION} cargo run --release -p prover -- --config ./config.json
+	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}
--- a/zkvm-prover/download-release.sh
+++ b/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.0rc0"
+VERSION_MAP["feynman"]="0.5.0rc1"

 # release version
 if [ -z "${SCROLL_ZKVM_VERSION}" ]; then
--- a/zkvm-prover/release-verifier-stuff.sh
+++ b/zkvm-prover/release-verifier-stuff.sh
@@ -0,0 +1,14 @@
+#!/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
Author	SHA1	Message	Date
colin	db80b47820	fix(rollup-relayer): upgrade boundary message queue hash initialization (#1706 )	2025-07-23 18:51:56 +08:00
Zhang Zhuo	daa1387208	circuit-0.5.2 (#1705 ) Co-authored-by: georgehao <georgehao@users.noreply.github.com>	2025-07-23 14:16:16 +08:00
Zhang Zhuo	67b05558e2	upgrade circuit to 0.5.2 (#1703 ) Co-authored-by: Rohit Narurkar <rohit.narurkar@proton.me> Co-authored-by: georgehao <georgehao@users.noreply.github.com>	2025-07-23 10:52:08 +08:00
Ho	1e447b0fef	[Fix] building failure in gpu image (#1702 )	2025-07-21 20:26:39 +08:00
georgehao	f7c6ecadf4	bump to v4.5.31 (#1700 )	2025-07-18 16:41:59 +08:00
Ho	9d94f943e5	[Upgrade] feynman 0.5.0rc1 (#1699 )	2025-07-18 15:57:31 +08:00