sp1_prover/
components.rs

1use std::sync::Arc;
2
3use sp1_core_executor::HEIGHT_THRESHOLD;
4use sp1_core_machine::riscv::RiscvAir;
5use sp1_hypercube::{
6    prover::{AirProver, CpuShardProver, SP1InnerPcsProver, SP1OuterPcsProver},
7    MachineVerifier, SP1InnerPcs, SP1OuterPcs, SP1Pcs, ShardContextImpl, ShardVerifier,
8};
9use sp1_primitives::{
10    fri_params::{core_fri_config, recursion_fri_config, shrink_fri_config, wrap_fri_config},
11    SP1Field, SP1GlobalContext, SP1OuterGlobalContext,
12};
13use sp1_verifier::compressed::{RECURSION_LOG_STACKING_HEIGHT, RECURSION_MAX_LOG_ROW_COUNT};
14use static_assertions::const_assert;
15
16pub const CORE_LOG_STACKING_HEIGHT: u32 = 21;
17pub const CORE_MAX_LOG_ROW_COUNT: usize = 22;
18
19const_assert!(HEIGHT_THRESHOLD <= (1 << CORE_MAX_LOG_ROW_COUNT));
20
21use sp1_recursion_machine::RecursionAir;
22
23const COMPRESS_DEGREE: usize = 3;
24const SHRINK_DEGREE: usize = 3;
25const WRAP_DEGREE: usize = 3;
26
27pub type CompressAir<F> = RecursionAir<F, COMPRESS_DEGREE, 2>;
28pub type ShrinkAir<F> = RecursionAir<F, SHRINK_DEGREE, 2>;
29pub type WrapAir<F> = RecursionAir<F, WRAP_DEGREE, 1>;
30
31pub const RECURSION_LOG_TRACE_AREA: usize = 27;
32const SHRINK_LOG_STACKING_HEIGHT: u32 = 18;
33pub(crate) const SHRINK_MAX_LOG_ROW_COUNT: usize = 19;
34
35pub(crate) const WRAP_LOG_STACKING_HEIGHT: u32 = 21;
36
37pub type CoreSC = ShardContextImpl<SP1GlobalContext, SP1Pcs<SP1GlobalContext>, RiscvAir<SP1Field>>;
38
39pub type RecursionSC =
40    ShardContextImpl<SP1GlobalContext, SP1Pcs<SP1GlobalContext>, CompressAir<SP1Field>>;
41pub type ShrinkSC =
42    ShardContextImpl<SP1GlobalContext, SP1Pcs<SP1GlobalContext>, ShrinkAir<SP1Field>>;
43
44pub type WrapSC =
45    ShardContextImpl<SP1OuterGlobalContext, SP1Pcs<SP1OuterGlobalContext>, WrapAir<SP1Field>>;
46
47pub trait CoreProver: AirProver<SP1GlobalContext, CoreSC> {
48    /// The default verifier for the core prover.
49    ///
50    /// The verifier fixes the parameters of the underlying proof system.
51    fn verifier() -> MachineVerifier<SP1GlobalContext, CoreSC> {
52        let core_log_stacking_height = CORE_LOG_STACKING_HEIGHT;
53        let core_max_log_row_count = CORE_MAX_LOG_ROW_COUNT;
54
55        let machine = RiscvAir::machine();
56
57        let core_verifier = ShardVerifier::from_basefold_parameters(
58            core_fri_config(),
59            core_log_stacking_height,
60            core_max_log_row_count,
61            machine.clone(),
62        );
63
64        MachineVerifier::new(core_verifier)
65    }
66}
67
68impl<C> CoreProver for C where C: AirProver<SP1GlobalContext, CoreSC> {}
69
70pub trait RecursionProver: AirProver<SP1GlobalContext, RecursionSC> {
71    fn verifier() -> MachineVerifier<SP1GlobalContext, RecursionSC> {
72        let compress_log_stacking_height = RECURSION_LOG_STACKING_HEIGHT;
73        let compress_max_log_row_count = RECURSION_MAX_LOG_ROW_COUNT;
74
75        let machine = CompressAir::<SP1Field>::compress_machine();
76        let recursion_shard_verifier = ShardVerifier::from_basefold_parameters(
77            recursion_fri_config(),
78            compress_log_stacking_height,
79            compress_max_log_row_count,
80            machine.clone(),
81        );
82
83        MachineVerifier::new(recursion_shard_verifier)
84    }
85
86    fn shrink_verifier() -> MachineVerifier<SP1GlobalContext, ShrinkSC> {
87        let shrink_log_stacking_height = SHRINK_LOG_STACKING_HEIGHT;
88        let shrink_max_log_row_count = SHRINK_MAX_LOG_ROW_COUNT;
89
90        let machine = CompressAir::<SP1Field>::shrink_machine();
91        let recursion_shard_verifier = ShardVerifier::from_basefold_parameters(
92            shrink_fri_config(),
93            shrink_log_stacking_height,
94            shrink_max_log_row_count,
95            machine.clone(),
96        );
97
98        MachineVerifier::new(recursion_shard_verifier)
99    }
100}
101
102pub trait WrapProver: AirProver<SP1OuterGlobalContext, WrapSC> {
103    fn wrap_verifier() -> MachineVerifier<SP1OuterGlobalContext, WrapSC> {
104        let wrap_log_stacking_height = WRAP_LOG_STACKING_HEIGHT;
105        let wrap_max_log_row_count = RECURSION_MAX_LOG_ROW_COUNT;
106
107        let machine = WrapAir::<SP1Field>::wrap_machine();
108        let wrap_shard_verifier = ShardVerifier::from_basefold_parameters(
109            wrap_fri_config(),
110            wrap_log_stacking_height,
111            wrap_max_log_row_count,
112            machine.clone(),
113        );
114
115        MachineVerifier::new(wrap_shard_verifier)
116    }
117}
118
119impl<C> RecursionProver for C where C: AirProver<SP1GlobalContext, RecursionSC> {}
120
121impl<C> WrapProver for C where C: AirProver<SP1OuterGlobalContext, WrapSC> {}
122
123pub trait WrapProverBuilder<C: SP1ProverComponents>: Send + Sync + 'static {
124    fn build(&self) -> Arc<C::WrapProver>;
125}
126
127pub struct ReadyWrapProverBuilder<C: SP1ProverComponents> {
128    prover: Arc<C::WrapProver>,
129}
130
131impl<C: SP1ProverComponents> ReadyWrapProverBuilder<C> {
132    pub fn new(prover: Arc<C::WrapProver>) -> Self {
133        Self { prover }
134    }
135}
136
137impl<C: SP1ProverComponents> WrapProverBuilder<C> for ReadyWrapProverBuilder<C> {
138    fn build(&self) -> Arc<C::WrapProver> {
139        self.prover.clone()
140    }
141}
142
143pub trait SP1ProverComponents: Send + Sync + 'static + Sized {
144    /// The prover for making SP1 core proofs.
145    type CoreProver: CoreProver;
146    /// The prover for making SP1 recursive proofs.
147    type RecursionProver: RecursionProver;
148    type WrapProver: WrapProver;
149    type WrapProverBuilder: WrapProverBuilder<Self>;
150
151    fn core_verifier() -> MachineVerifier<SP1GlobalContext, CoreSC> {
152        <Self::CoreProver as CoreProver>::verifier()
153    }
154
155    fn compress_verifier() -> MachineVerifier<SP1GlobalContext, RecursionSC> {
156        <Self::RecursionProver as RecursionProver>::verifier()
157    }
158
159    fn shrink_verifier() -> MachineVerifier<SP1GlobalContext, ShrinkSC> {
160        <Self::RecursionProver as RecursionProver>::shrink_verifier()
161    }
162
163    fn wrap_verifier() -> MachineVerifier<SP1OuterGlobalContext, WrapSC> {
164        <Self::WrapProver as WrapProver>::wrap_verifier()
165    }
166}
167
168pub struct CpuSP1ProverComponents;
169
170pub struct CpuWrapProverBuilder;
171
172impl WrapProverBuilder<CpuSP1ProverComponents> for CpuWrapProverBuilder {
173    fn build(&self) -> Arc<<CpuSP1ProverComponents as SP1ProverComponents>::WrapProver> {
174        let wrap_verifier = CpuSP1ProverComponents::wrap_verifier();
175        Arc::new(CpuShardProver::new(wrap_verifier.shard_verifier().clone()))
176    }
177}
178
179impl SP1ProverComponents for CpuSP1ProverComponents {
180    type CoreProver = CpuShardProver<
181        SP1GlobalContext,
182        SP1Pcs<SP1GlobalContext>,
183        SP1InnerPcsProver,
184        RiscvAir<SP1Field>,
185    >;
186    type RecursionProver =
187        CpuShardProver<SP1GlobalContext, SP1InnerPcs, SP1InnerPcsProver, CompressAir<SP1Field>>;
188    type WrapProver =
189        CpuShardProver<SP1OuterGlobalContext, SP1OuterPcs, SP1OuterPcsProver, WrapAir<SP1Field>>;
190    type WrapProverBuilder = CpuWrapProverBuilder;
191}
sp1_prover/components.rs

sp1_prover/
components.rs
