tmp

Author: lispc

Cargo.lock

@@ -169,12 +169,14 @@ type OpenVMProof struct {
 	PublicValues []byte `json:"public_values"`
 }
 
-// Proof for flatten VM stark proof (v0.9.0+)
+// 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:"proofs"`
-	PublicValues []byte           `json:"public_values"`
-	UserPvsProof []byte           `json:"user_pvs_proof"`
-	Stat         *OpenVMProofStat `json:"stat,omitempty"`
+	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
@@ -254,10 +256,10 @@ func (ap *OpenVMBatchProof) SanityCheck() error {
 			return errors.New("vk not ready")
 		}
 		pf := ap.StarkProof
-		if pf.Proof == nil {
+		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

@@ -3,7 +3,7 @@ package api
 import (
 	"errors"
 	"fmt"
-	"math/rand"
+	"sort"
 
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
@@ -79,7 +79,9 @@ func (ptc *GetTaskController) incGetTaskAccessCounter(ctx *gin.Context) error {
 	return nil
 }
 
-// GetTasks get assigned chunk/batch task
+// GetTasks get assigned chunk/batch/bundle task, trying proof types in priority
+// order: Bundle > Batch > Chunk. This lets the pipeline finalize the earliest
+// ready bundle before proving unrelated chunks/batches further ahead.
 func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 	var getTaskParameter coordinatorType.GetTaskParameter
 	if err := ctx.ShouldBind(&getTaskParameter); err != nil {
@@ -99,35 +101,36 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 		}
 	}
 
-	proofType := ptc.proofType(&getTaskParameter)
-	proverTask, isExist := ptc.proverTasks[proofType]
-	if !isExist {
-		nerr := fmt.Errorf("parameter wrong proof type:%v", proofType)
-		types.RenderFailure(ctx, types.ErrCoordinatorParameterInvalidNo, nerr)
-		return
-	}
+	proofTypes := ptc.prioritizedProofTypes(&getTaskParameter)
 
 	if err := ptc.incGetTaskAccessCounter(ctx); err != nil {
 		log.Warn("get_task access counter inc failed", "error", err.Error())
 	}
 
-	result, err := proverTask.Assign(ctx, &getTaskParameter)
-	if err != nil {
-		nerr := fmt.Errorf("return prover task err:%w", err)
-		types.RenderFailure(ctx, types.ErrCoordinatorGetTaskFailure, nerr)
-		return
-	}
+	for _, proofType := range proofTypes {
+		proverTask, isExist := ptc.proverTasks[proofType]
+		if !isExist {
+			continue
+		}
 
-	if result == nil {
-		nerr := errors.New("get empty prover task")
-		types.RenderFailure(ctx, types.ErrCoordinatorEmptyProofData, nerr)
-		return
+		result, err := proverTask.Assign(ctx, &getTaskParameter)
+		if err != nil {
+			nerr := fmt.Errorf("return prover task err:%w", err)
+			types.RenderFailure(ctx, types.ErrCoordinatorGetTaskFailure, nerr)
+			return
+		}
+
+		if result != nil {
+			types.RenderSuccess(ctx, result)
+			return
+		}
 	}
 
-	types.RenderSuccess(ctx, result)
+	nerr := errors.New("get empty prover task")
+	types.RenderFailure(ctx, types.ErrCoordinatorEmptyProofData, nerr)
 }
 
-func (ptc *GetTaskController) proofType(para *coordinatorType.GetTaskParameter) message.ProofType {
+func (ptc *GetTaskController) prioritizedProofTypes(para *coordinatorType.GetTaskParameter) []message.ProofType {
 	var proofTypes []message.ProofType
 	for _, proofType := range para.TaskTypes {
 		proofTypes = append(proofTypes, message.ProofType(proofType))
@@ -141,8 +144,9 @@ func (ptc *GetTaskController) proofType(para *coordinatorType.GetTaskParameter)
 		}
 	}
 
-	rand.Shuffle(len(proofTypes), func(i, j int) {
-		proofTypes[i], proofTypes[j] = proofTypes[j], proofTypes[i]
+	// Bundle (3) > Batch (2) > Chunk (1)
+	sort.Slice(proofTypes, func(i, j int) bool {
+		return proofTypes[i] > proofTypes[j]
 	})
-	return proofTypes[0]
+	return proofTypes
 }

coordinator/internal/controller/api/get_task.go

@@ -211,13 +211,25 @@ func (o *Batch) GetAttemptsByHash(ctx context.Context, hash string) (int16, int1
 func (o *Batch) CheckIfBundleBatchProofsAreReady(ctx context.Context, bundleHash string) (bool, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&Batch{})
+	db = db.Where("bundle_hash = ?", bundleHash)
+
+	var totalCount int64
+	if err := db.Count(&totalCount).Error; err != nil {
+		return false, fmt.Errorf("Batch.CheckIfBundleBatchProofsAreReady error: %w, bundle hash: %v", err, bundleHash)
+	}
+	if totalCount == 0 {
+		return false, nil
+	}
+
+	db = o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
 	db = db.Where("bundle_hash = ? AND proving_status != ?", bundleHash, types.ProvingTaskVerified)
 
-	var count int64
-	if err := db.Count(&count).Error; err != nil {
-		return false, fmt.Errorf("Chunk.CheckIfBundleBatchProofsAreReady error: %w, bundle hash: %v", err, bundleHash)
+	var unreadyCount int64
+	if err := db.Count(&unreadyCount).Error; err != nil {
+		return false, fmt.Errorf("Batch.CheckIfBundleBatchProofsAreReady error: %w, bundle hash: %v", err, bundleHash)
 	}
-	return count == 0, nil
+	return unreadyCount == 0, nil
 }
 
 // GetBatchByHash retrieves the given batch.

coordinator/internal/orm/batch.go

@@ -171,13 +171,25 @@ func (o *Chunk) GetProvingStatusByHash(ctx context.Context, hash string) (types.
 func (o *Chunk) CheckIfBatchChunkProofsAreReady(ctx context.Context, batchHash string) (bool, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&Chunk{})
+	db = db.Where("batch_hash = ?", batchHash)
+
+	var totalCount int64
+	if err := db.Count(&totalCount).Error; err != nil {
+		return false, fmt.Errorf("Chunk.CheckIfBatchChunkProofsAreReady error: %w, batch hash: %v", err, batchHash)
+	}
+	if totalCount == 0 {
+		return false, nil
+	}
+
+	db = o.db.WithContext(ctx)
+	db = db.Model(&Chunk{})
 	db = db.Where("batch_hash = ? AND proving_status != ?", batchHash, types.ProvingTaskVerified)
 
-	var count int64
-	if err := db.Count(&count).Error; err != nil {
+	var unreadyCount int64
+	if err := db.Count(&unreadyCount).Error; err != nil {
 		return false, fmt.Errorf("Chunk.CheckIfBatchChunkProofsAreReady error: %w, batch hash: %v", err, batchHash)
 	}
-	return count == 0, nil
+	return unreadyCount == 0, nil
 }
 
 // GetChunkByHash retrieves the given chunk.

coordinator/internal/orm/chunk.go

@@ -23,6 +23,14 @@ futures-util = "0.3"
 reqwest = { version = "0.12", features = ["gzip", "stream"] }
 hex = "0.4.3"
 
+# OpenVM v2+ deferred STARK verification helpers for batch/bundle proving.
+openvm-circuit = { git = "https://github.com/openvm-org/openvm.git", tag = "v2.0.0" }
+openvm-continuations = { git = "https://github.com/openvm-org/openvm.git", tag = "v2.0.0" }
+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" }
+openvm-verify-stark-circuit = { git = "https://github.com/openvm-org/openvm.git", tag = "v2.0.0" }
+openvm-verify-stark-host = { git = "https://github.com/openvm-org/openvm.git", tag = "v2.0.0" }
+
 rand = "0.8.5"
 tokio = "1.37.0"
 async-trait = "0.1"

crates/prover-bin/Cargo.toml

@@ -0,0 +1,110 @@
+use eyre::Result;
+use openvm_circuit::system::memory::merkle::public_values::UserPublicValuesProof;
+use openvm_sdk::SC;
+use openvm_stark_sdk::openvm_stark_backend::{codec::Decode, proof::Proof};
+use openvm_verify_stark_host::{
+    deferral::DeferralMerkleProofs,
+    vk::{VerificationBaseline, VmStarkVerifyingKey},
+    VmStarkProof,
+};
+use openvm_sdk::DeferralInput;
+use scroll_zkvm_types::proof::StarkProof;
+use std::io::Cursor;
+
+/// Compute deferred STARK verification data required by OpenVM v2+ aggregation circuits.
+///
+/// For batch/bundle proving the guest reads `input_commits` from stdin and the host must
+/// additionally supply `DeferralInput`s and `DeferralState`s to the SDK prover. This function
+/// derives all three from the child STARK proofs, the child aggregation VK and the parent's
+/// deferral cached commit.
+pub fn compute_deferral_data(
+    child_agg_vk: &openvm_stark_sdk::openvm_stark_backend::keygen::types::MultiStarkVerifyingKey<SC>,
+    parent_deferral_cached_commit: openvm_continuations::CommitBytes,
+    proofs: &[&StarkProof],
+) -> Result<(Vec<[u8; 32]>, Vec<DeferralInput>, Vec<openvm_circuit::arch::deferral::DeferralState>)> {
+    let mvk = (*child_agg_vk).clone();
+
+    let (vm_proofs, baselines): (Vec<VmStarkProof>, Vec<VerificationBaseline>) = proofs
+        .iter()
+        .map(|p| decode_stark_proof(p))
+        .collect::<Result<Vec<_>>>()?
+        .into_iter()
+        .unzip();
+
+    let baseline = baselines
+        .first()
+        .cloned()
+        .ok_or_else(|| eyre::eyre!("no child proofs to compute deferral data"))?;
+    for (i, b) in baselines.iter().enumerate().skip(1) {
+        if b.app_exe_commit != baseline.app_exe_commit || b.app_vk_commit != baseline.app_vk_commit
+        {
+            eyre::bail!(
+                "child proof {i} has a different verification baseline; all child proofs must use the same app exe/vk commitment"
+            );
+        }
+    }
+
+    let vk = VmStarkVerifyingKey { mvk, baseline };
+
+    let cached_commit: openvm_stark_sdk::config::baby_bear_poseidon2::Digest =
+        parent_deferral_cached_commit.into();
+
+    let raw_results = openvm_verify_stark_circuit::extension::get_raw_deferral_results(
+        &vk,
+        &vm_proofs,
+        cached_commit,
+    )
+    .map_err(|e| eyre::eyre!("get_raw_deferral_results failed: {e}"))?;
+
+    let input_commits: Vec<[u8; 32]> = raw_results
+        .iter()
+        .map(|r| {
+            r.input
+                .as_slice()
+                .try_into()
+                .expect("input commit must be 32 bytes")
+        })
+        .collect();
+
+    let deferral_inputs = vec![DeferralInput::from_inputs(&vm_proofs)];
+
+    let deferral_state = openvm_verify_stark_circuit::extension::get_deferral_state(
+        &vk,
+        &vm_proofs,
+        cached_commit,
+        0,
+    )
+    .map_err(|e| eyre::eyre!("get_deferral_state failed: {e}"))?;
+
+    Ok((input_commits, deferral_inputs, vec![deferral_state]))
+}
+
+fn decode_stark_proof(proof: &StarkProof) -> Result<(VmStarkProof, VerificationBaseline)> {
+    let inner = Proof::<SC>::decode_from_bytes(&proof.proof)
+        .map_err(|e| eyre::eyre!("decode proof failed: {e}"))?;
+    let user_pvs_proof =
+        UserPublicValuesProof::decode::<SC, _>(&mut Cursor::new(&proof.user_pvs_proof))
+            .map_err(|e| eyre::eyre!("decode user_pvs_proof failed: {e}"))?;
+    let deferral_merkle_proofs = if proof.deferral_merkle_proofs.is_empty() {
+        None
+    } else {
+        Some(
+            DeferralMerkleProofs::decode(&mut Cursor::new(&proof.deferral_merkle_proofs))
+                .map_err(|e| eyre::eyre!("decode deferral_merkle_proofs failed: {e}"))?,
+        )
+    };
+    let baseline = if proof.baseline.is_empty() {
+        eyre::bail!("stark proof missing verification baseline");
+    } else {
+        serde_json::from_slice(&proof.baseline)
+            .map_err(|e| eyre::eyre!("decode baseline failed: {e}"))?
+    };
+    Ok((
+        VmStarkProof {
+            inner,
+            user_pvs_proof,
+            deferral_merkle_proofs,
+        },
+        baseline,
+    ))
+}

crates/prover-bin/src/deferral.rs

@@ -1,4 +1,5 @@
 mod dumper;
+mod deferral;
 mod prover;
 mod types;
 mod zk_circuits_handler;