feat(prover): upgrade zkvm-prover to bf887150 (OpenVM v2.0, guest v0.9.0) with halo2-gpu SNARK acceleration

- Bump scroll-zkvm-prover/verifier/types pins ed3b964 -> bf887150 (OpenVM
  v1.6 -> v2.0.0); rust-toolchain nightly-2025-08-18 -> nightly-2025-11-20.
- prover-bin: OpenVM v2 deferred STARK verification for batch/bundle
  aggregation — new deferral module computes input_commits / DeferralInputs /
  DeferralStates from child proofs; handlers enable_deferral against child
  circuits (bundle also initializes batch-over-chunk) and release child GPU
  SDKs after setup to avoid VRAM starvation of the halo2-gpu SNARK phase.
- prover-bin: download pre-built agg_vk.bin circuit asset and new
  child_circuit_vks config; new halo2-gpu cargo feature + prover_halo2gpu
  make target for GPU SNARK (bundle) proving.
- libzkp: read batch circuit agg_vk.bin for root-proof verification; tasks
  carry input_commits; drop pre-v0.9.0 universal task compatibility shim.
- common/coordinator: adopt v0.9.0 StarkProof wire format (proof /
  user_pvs_proof / baseline / deferral_merkle_proofs) in message types,
  proof receiver, mock verifier and tests.
- Point prover/e2e circuit base_url at scroll-zkvm/releases/v0.9.0/.

Author: lispc

Cargo.lock

@@ -17,9 +17,9 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.7.12"
 
 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ed3b964" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ed3b964" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ed3b964" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "bf887150bb671af9b17dd53e92b7f2bbf01ec745" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "bf887150bb671af9b17dd53e92b7f2bbf01ec745" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "bf887150bb671af9b17dd53e92b7f2bbf01ec745" }
 
 sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2", features = ["scroll", "rkyv"] }
 sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2" }

Cargo.toml

@@ -165,9 +165,18 @@ type OpenVMProofStat struct {
 
 // Proof for flatten VM proof
 type OpenVMProof struct {
-	Proof        []byte           `json:"proofs"`
-	PublicValues []byte           `json:"public_values"`
-	Stat         *OpenVMProofStat `json:"stat,omitempty"`
+	Proof        []byte `json:"proofs"`
+	PublicValues []byte `json:"public_values"`
+}
+
+// Proof for flatten VM stark proof (v0.9.0+).
+// Mirrors scroll_zkvm_types::proof::StarkProof used by the OpenVM v2 prover.
+type OpenVMStarkProof struct {
+	Proof                []byte           `json:"proof"`
+	UserPvsProof         []byte           `json:"user_pvs_proof"`
+	Baseline             []byte           `json:"baseline,omitempty"`
+	DeferralMerkleProofs []byte           `json:"deferral_merkle_proofs,omitempty"`
+	Stat                 *OpenVMProofStat `json:"stat,omitempty"`
 }
 
 // Proof for flatten EVM proof
@@ -183,13 +192,13 @@ type OpenVMChunkProof struct {
 		TotalGasUsed uint64     `json:"chunk_total_gas"`
 	} `json:"metadata"`
 
-	VmProof    *OpenVMProof `json:"proof"`
-	Vk         []byte       `json:"vk,omitempty"`
-	GitVersion string       `json:"git_version,omitempty"`
+	StarkProof *OpenVMStarkProof `json:"proof"`
+	Vk         []byte            `json:"vk,omitempty"`
+	GitVersion string            `json:"git_version,omitempty"`
 }
 
 func (p *OpenVMChunkProof) Proof() []byte {
-	proofJson, err := json.Marshal(p.VmProof)
+	proofJson, err := json.Marshal(p.StarkProof)
 	if err != nil {
 		panic(fmt.Sprint("marshaling error", err))
 	}
@@ -217,13 +226,13 @@ type OpenVMBatchProof struct {
 		BatchHash common.Hash      `json:"batch_hash"`
 	} `json:"metadata"`
 
-	VmProof    *OpenVMProof `json:"proof"`
-	Vk         []byte       `json:"vk,omitempty"`
-	GitVersion string       `json:"git_version,omitempty"`
+	StarkProof *OpenVMStarkProof `json:"proof"`
+	Vk         []byte            `json:"vk,omitempty"`
+	GitVersion string            `json:"git_version,omitempty"`
 }
 
 func (p *OpenVMBatchProof) Proof() []byte {
-	proofJson, err := json.Marshal(p.VmProof)
+	proofJson, err := json.Marshal(p.StarkProof)
 	if err != nil {
 		panic(fmt.Sprint("marshaling error", err))
 	}
@@ -240,17 +249,17 @@ func (ap *OpenVMBatchProof) SanityCheck() error {
 		return errors.New("batch info not ready")
 	}
 
-	if ap.VmProof == nil {
+	if ap.StarkProof == nil {
 		return errors.New("proof not ready")
 	} else {
 		if len(ap.Vk) == 0 {
 			return errors.New("vk not ready")
 		}
-		pf := ap.VmProof
-		if pf.Proof == nil {
+		pf := ap.StarkProof
+		if len(pf.Proof) == 0 {
 			return errors.New("proof data not ready")
 		}
-		if len(pf.PublicValues) == 0 {
+		if len(pf.UserPvsProof) == 0 {
 			return errors.New("proof public value not ready")
 		}
 	}

common/types/message/message.go

@@ -232,7 +232,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)
-		if stat := chunkProof.VmProof.Stat; stat != nil {
+		if stat := chunkProof.StarkProof.Stat; stat != nil {
 			if g, _ := m.proverSpeed.GetMetricWithLabelValues("chunk", "exec"); g != nil && stat.ExecutionTimeMills > 0 {
 				g.Set(float64(stat.TotalCycle) / float64(stat.ExecutionTimeMills*1000))
 			}
@@ -252,7 +252,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 			return unmarshalErr
 		}
 		success, verifyErr = m.verifier.VerifyBatchProof(batchProof, hardForkName)
-		if stat := batchProof.VmProof.Stat; stat != nil {
+		if stat := batchProof.StarkProof.Stat; stat != nil {
 			if g, _ := m.proverSpeed.GetMetricWithLabelValues("batch", "exec"); g != nil && stat.ExecutionTimeMills > 0 {
 				g.Set(float64(stat.TotalCycle) / float64(stat.ExecutionTimeMills*1000))
 			}

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -21,15 +21,15 @@ func NewVerifier(cfg *config.VerifierConfig, _ bool) (*Verifier, error) {
 
 // VerifyChunkProof return a mock verification result for a ChunkProof.
 func (v *Verifier) VerifyChunkProof(proof *message.OpenVMChunkProof, forkName string) (bool, error) {
-	if proof.VmProof != nil && string(proof.VmProof.Proof) == InvalidTestProof {
+	if proof.StarkProof != nil && string(proof.StarkProof.Proof) == InvalidTestProof {
 		return false, nil
 	}
 	return true, nil
 }
 
 // VerifyBatchProof return a mock verification result for a BatchProof.
 func (v *Verifier) VerifyBatchProof(proof *message.OpenVMBatchProof, forkName string) (bool, error) {
-	if proof.VmProof != nil && string(proof.VmProof.Proof) == InvalidTestProof {
+	if proof.StarkProof != nil && string(proof.StarkProof.Proof) == InvalidTestProof {
 		return false, nil
 	}
 	return true, nil

coordinator/internal/logic/verifier/mock.go

@@ -687,7 +687,7 @@ func testTimeoutProof(t *testing.T) {
 	assert.NoError(t, err)
 	err = chunkOrm.UpdateBatchHashInRange(context.Background(), 0, 100, batch.Hash)
 	assert.NoError(t, err)
-	encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{}, MetaData: struct {
+	encodeData, err := json.Marshal(message.OpenVMChunkProof{StarkProof: &message.OpenVMStarkProof{}, MetaData: struct {
 		ChunkInfo    *message.ChunkInfo `json:"chunk_info"`
 		TotalGasUsed uint64             `json:"chunk_total_gas"`
 	}{ChunkInfo: &message.ChunkInfo{}}})

coordinator/test/api_test.go

@@ -229,7 +229,7 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 		case message.ProofTypeChunk:
 			fallthrough
 		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{})
+			encodeData, err := json.Marshal(&message.OpenVMStarkProof{})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
@@ -245,7 +245,7 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 		case message.ProofTypeChunk:
 			fallthrough
 		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)})
+			encodeData, err := json.Marshal(&message.OpenVMStarkProof{Proof: []byte(verifier.InvalidTestProof), UserPvsProof: []byte{0x01}})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData

coordinator/test/mock_prover.go

@@ -7,6 +7,8 @@ edition.workspace = true
 [dependencies]
 scroll-zkvm-types = { workspace = true, features = ["scroll"] }
 scroll-zkvm-verifier.workspace = true
+openvm-sdk = { git = "https://github.com/openvm-org/openvm.git", tag = "v2.0.0" }
+openvm-stark-sdk = { git = "https://github.com/openvm-org/stark-backend.git", tag = "v2.0.0" }
 
 alloy-primitives.workspace = true #depress the effect of "native-keccak"
 sbv-primitives = {workspace = true, features = ["scroll-compress-info", "scroll"]}

crates/libzkp/Cargo.toml

@@ -55,43 +55,8 @@ pub fn checkout_chunk_task(
 
 /// Convert the universal task json into compatible form for old prover
 pub fn univ_task_compatibility_fix(task_json: &str) -> eyre::Result<String> {
-    use scroll_zkvm_types::proof::VmInternalStarkProof;
-
-    let task: tasks::ProvingTask = serde_json::from_str(task_json)?;
-    let aggregated_proofs: Vec<VmInternalStarkProof> = task
-        .aggregated_proofs
-        .into_iter()
-        .map(|proof| VmInternalStarkProof {
-            proofs: proof.proofs,
-            public_values: proof.public_values,
-        })
-        .collect();
-
-    #[derive(Serialize)]
-    struct CompatibleProvingTask {
-        /// seralized witness which should be written into stdin first
-        pub serialized_witness: Vec<Vec<u8>>,
-        /// aggregated proof carried by babybear fields, should be written into stdin
-        /// followed `serialized_witness`
-        pub aggregated_proofs: Vec<VmInternalStarkProof>,
-        /// Fork name specify
-        pub fork_name: String,
-        /// The vk of app which is expcted to prove this task
-        pub vk: Vec<u8>,
-        /// An identifier assigned by coordinator, it should be kept identify for the
-        /// same task (for example, using chunk, batch and bundle hashes)
-        pub identifier: String,
-    }
-
-    let compatible_u_task = CompatibleProvingTask {
-        serialized_witness: task.serialized_witness,
-        aggregated_proofs,
-        fork_name: task.fork_name,
-        vk: task.vk,
-        identifier: task.identifier,
-    };
-
-    Ok(serde_json::to_string(&compatible_u_task)?)
+    // v0.9.0+ provers consume the new ProvingTask format directly; no translation needed.
+    Ok(task_json.to_string())
 }
 
 /// Generate required staff for proving tasks

crates/libzkp/src/lib.rs

@@ -131,6 +131,7 @@ impl BatchProvingTask {
                 .collect(),
             serialized_witness: vec![serialized_witness],
             vk: Vec::new(),
+            input_commits: Vec::new(),
         };
 
         Ok((proving_task, metadata, batch_pi_hash))