openvm_sdk/prover/
stark.rs

1use std::sync::Arc;
2
3use openvm_circuit::arch::{
4    instructions::exe::VmExe, Executor, MeteredExecutor, PreflightExecutor, VirtualMachineError,
5    VmBuilder, VmExecutionConfig,
6};
7use openvm_continuations::verifier::internal::types::VmStarkProof;
8#[cfg(feature = "evm-prove")]
9use openvm_continuations::{verifier::root::types::RootVmVerifierInput, RootSC};
10use openvm_native_circuit::NativeConfig;
11#[cfg(feature = "evm-prove")]
12use openvm_stark_backend::proof::Proof;
13use openvm_stark_sdk::engine::StarkFriEngine;
14
15use crate::{
16    commit::AppExecutionCommit,
17    config::AggregationTreeConfig,
18    keygen::{AggProvingKey, AppProvingKey},
19    prover::{agg::AggStarkProver, app::AppProver},
20    StdIn, F, SC,
21};
22
23/// This prover contains an [`app_prover`](StarkProver::app_prover) internally.
24pub struct StarkProver<E, VB, NativeBuilder>
25where
26    E: StarkFriEngine<SC = SC>,
27    VB: VmBuilder<E>,
28    NativeBuilder: VmBuilder<E, VmConfig = NativeConfig>,
29{
30    pub app_prover: AppProver<E, VB>,
31    pub agg_prover: AggStarkProver<E, NativeBuilder>,
32}
33impl<E, VB, NativeBuilder> StarkProver<E, VB, NativeBuilder>
34where
35    E: StarkFriEngine<SC = SC>,
36    VB: VmBuilder<E>,
37    <VB::VmConfig as VmExecutionConfig<F>>::Executor:
38        Executor<F> + MeteredExecutor<F> + PreflightExecutor<F, <VB as VmBuilder<E>>::RecordArena>,
39    NativeBuilder: VmBuilder<E, VmConfig = NativeConfig> + Clone,
40    <NativeConfig as VmExecutionConfig<F>>::Executor:
41        PreflightExecutor<F, <NativeBuilder as VmBuilder<E>>::RecordArena>,
42{
43    pub fn new(
44        app_vm_builder: VB,
45        native_builder: NativeBuilder,
46        app_pk: &AppProvingKey<VB::VmConfig>,
47        app_exe: Arc<VmExe<F>>,
48        agg_pk: &AggProvingKey,
49        agg_tree_config: AggregationTreeConfig,
50    ) -> Result<Self, VirtualMachineError> {
51        assert_eq!(
52            app_pk.leaf_fri_params, agg_pk.leaf_vm_pk.fri_params,
53            "App VM is incompatible with Agg VM because of leaf FRI parameters"
54        );
55        assert_eq!(
56            app_pk.app_vm_pk.vm_config.as_ref().num_public_values,
57            agg_pk.num_user_public_values(),
58            "App VM is incompatible with Agg VM  because of the number of public values"
59        );
60
61        Ok(Self {
62            app_prover: AppProver::new(
63                app_vm_builder,
64                &app_pk.app_vm_pk,
65                app_exe,
66                app_pk.leaf_committed_exe.get_program_commit(),
67            )?,
68            agg_prover: AggStarkProver::new(
69                native_builder,
70                agg_pk,
71                app_pk.leaf_committed_exe.exe.clone(),
72                agg_tree_config,
73            )?,
74        })
75    }
76
77    pub fn from_parts(
78        app_prover: AppProver<E, VB>,
79        agg_prover: AggStarkProver<E, NativeBuilder>,
80    ) -> Result<Self, VirtualMachineError> {
81        Ok(Self {
82            app_prover,
83            agg_prover,
84        })
85    }
86
87    pub fn with_program_name(mut self, program_name: impl AsRef<str>) -> Self {
88        self.set_program_name(program_name);
89        self
90    }
91    pub fn set_program_name(&mut self, program_name: impl AsRef<str>) -> &mut Self {
92        self.app_prover.set_program_name(program_name);
93        self
94    }
95
96    pub fn app_commit(&self) -> AppExecutionCommit {
97        self.app_prover.app_commit()
98    }
99
100    pub fn prove(&mut self, input: StdIn) -> Result<VmStarkProof<SC>, VirtualMachineError> {
101        let app_proof = self.app_prover.prove(input)?;
102        let leaf_proofs = self.agg_prover.generate_leaf_proofs(&app_proof)?;
103        self.agg_prover
104            .aggregate_leaf_proofs(leaf_proofs, app_proof.user_public_values.public_values)
105    }
106
107    #[cfg(feature = "evm-prove")]
108    pub fn generate_proof_for_outer_recursion(
109        &mut self,
110        input: StdIn,
111    ) -> Result<Proof<RootSC>, VirtualMachineError> {
112        let app_proof = self.app_prover.prove(input)?;
113        self.agg_prover.generate_root_proof(app_proof)
114    }
115    #[cfg(feature = "evm-prove")]
116    pub fn generate_root_verifier_input(
117        &mut self,
118        input: StdIn,
119    ) -> Result<RootVmVerifierInput<SC>, VirtualMachineError> {
120        let app_proof = self.app_prover.prove(input)?;
121        self.agg_prover.generate_root_verifier_input(app_proof)
122    }
123}
openvm_sdk/prover/stark.rs

openvm_sdk/prover/
stark.rs
