1use std::{marker::PhantomData, sync::Arc};
18
19use binius_core::{
20 constraint_system::{ConstraintSystem, InoutSegment},
21 word::Word,
22};
23use binius_field::Ghash128b as B128;
24use binius_hash::HashSuite;
25use binius_iop::{
26 basefold::compiler::BaseFoldVerifierCompiler,
27 channel::{
28 IOPVerifierChannel,
29 oracle_setup::{DummyElem, OracleSetupChannel},
30 },
31 fri,
32 merkle_tree::BinaryMerkleTreeScheme,
33};
34use binius_ip::channel::WordIPVerifierChannel;
35use binius_spartan_frontend::{
36 compiler::compile,
37 constraint_system::{BlindingInfo, WitnessLayout},
38};
39use binius_spartan_verifier::{
40 IOPVerifier as IronSpartanIOPVerifier,
41 constraint_system::ConstraintSystemPadded,
42 wrapper::{IronSpartanBuilderChannel, ZKWrappedVerifierChannel},
43};
44use binius_transcript::{VerifierTranscript, fiat_shamir::Challenger};
45use binius_utils::{DeserializeBytes, SerializeBytes, serialization::SerializationError};
46use bytes::{Buf, BufMut};
47use digest::Output;
48
49use crate::{
50 protocols::shift::WiringEvalClaim,
51 verify::{IOPVerifier, SECURITY_BITS},
52};
53
54#[derive(Clone)]
59pub struct ZKVerifier<H: HashSuite> {
60 inner_iop_verifier: IOPVerifier,
61 outer_iop_verifier: IronSpartanIOPVerifier<B128>,
62 outer_layout: Arc<WitnessLayout<B128>>,
63 basefold_compiler: BaseFoldVerifierCompiler<B128>,
64 _hash_marker: PhantomData<H>,
66}
67
68impl<H> ZKVerifier<H>
69where
70 H: HashSuite,
71 Output<H::LeafHash>: DeserializeBytes,
72{
73 pub fn setup(constraint_system: ConstraintSystem, log_inv_rate: usize) -> Result<Self, Error> {
75 let _setup_guard = tracing::debug_span!("Setup ZK verifier").entered();
76
77 constraint_system.validate()?;
78
79 let log_public_words = constraint_system.log_public_words(InoutSegment::Public);
80
81 let inner_iop_verifier = IOPVerifier::new(constraint_system, log_public_words);
82
83 let dummy_inout_words =
85 vec![Word::from_u64(0); inner_iop_verifier.constraint_system().n_inout];
86
87 let outer_builder = {
88 let _guard = tracing::debug_span!("Build ZK wrapper circuit").entered();
89 let mut builder_channel = IronSpartanBuilderChannel::new();
90 let _ = inner_iop_verifier
93 .verify(&dummy_inout_words, &mut builder_channel)
94 .expect("symbolic verify should not fail");
95 builder_channel.finish()
96 };
97 let (outer_cs, outer_layout) = {
98 let _guard = tracing::debug_span!("Compile ZK wrapper circuit").entered();
99 compile(outer_builder)
100 };
101
102 tracing::debug!(
103 n_public = outer_cs.n_public(),
104 n_precommit = outer_cs.n_precommit(),
105 n_private = outer_cs.n_private(),
106 n_mul_constraints = outer_cs.mul_constraints().len(),
107 "ZK wrapper circuit stats"
108 );
109
110 let n_test_queries = fri::calculate_n_test_queries(SECURITY_BITS, log_inv_rate);
112 let blinding_info = BlindingInfo::default();
113 let outer_cs = ConstraintSystemPadded::new(outer_cs, blinding_info);
114 let outer_layout = Arc::new(outer_layout.with_blinding(*outer_cs.blinding_info()));
115 let outer_iop_verifier = IronSpartanIOPVerifier::new(outer_cs);
116
117 let oracle_schedule = {
122 let mut channel = OracleSetupChannel::new(true);
123 <OracleSetupChannel as IOPVerifierChannel<B128>>::recv_oracle(
124 &mut channel,
125 outer_iop_verifier.constraint_system().precommit_len(),
126 true,
127 )
128 .expect("OracleSetupChannel::recv_oracle is infallible");
129 let _ = inner_iop_verifier.verify(&dummy_inout_words, &mut channel);
131 let public = vec![
132 DummyElem::<B128>::default();
133 1 << outer_iop_verifier.constraint_system().log_public()
134 ];
135 let _ = outer_iop_verifier.verify((), &public, &mut channel);
136 channel.into_oracle_schedule()
137 };
138
139 let merkle_scheme = BinaryMerkleTreeScheme::<B128, H>::new();
140 let basefold_compiler = BaseFoldVerifierCompiler::new(
141 &merkle_scheme,
142 oracle_schedule,
143 log_inv_rate,
144 n_test_queries,
145 );
146
147 Ok(Self {
148 inner_iop_verifier,
149 outer_iop_verifier,
150 outer_layout,
151 basefold_compiler,
152 _hash_marker: PhantomData,
153 })
154 }
155
156 pub const fn inner_iop_verifier(&self) -> &IOPVerifier {
158 &self.inner_iop_verifier
159 }
160
161 pub const fn outer_iop_verifier(&self) -> &IronSpartanIOPVerifier<B128> {
163 &self.outer_iop_verifier
164 }
165
166 pub fn outer_layout(&self) -> &WitnessLayout<B128> {
170 &self.outer_layout
171 }
172
173 pub fn outer_layout_arc(&self) -> Arc<WitnessLayout<B128>> {
177 Arc::clone(&self.outer_layout)
178 }
179
180 pub const fn basefold_compiler(&self) -> &BaseFoldVerifierCompiler<B128> {
182 &self.basefold_compiler
183 }
184
185 pub const fn constraint_system(&self) -> &ConstraintSystem {
187 self.inner_iop_verifier.constraint_system()
188 }
189
190 pub const fn log_public_words(&self) -> usize {
192 self.inner_iop_verifier.log_public_words()
193 }
194
195 pub fn log_inv_rate(&self) -> usize {
197 self.basefold_compiler.fri_params().rs_code().log_inv_rate()
198 }
199
200 pub fn verify<Challenger_: Challenger>(
202 &self,
203 inout: &[Word],
204 transcript: &mut VerifierTranscript<Challenger_>,
205 ) -> Result<(), Error> {
206 let channel = self
208 .basefold_compiler
209 .create_channel_from_transcript::<H, Challenger_, _>(transcript);
210 let mut wrapped_channel = ZKWrappedVerifierChannel::new(
211 channel,
212 &self.outer_iop_verifier,
213 Arc::clone(&self.outer_layout),
214 )?;
215
216 {
218 let inner_cs = self.inner_iop_verifier.constraint_system();
219 let _scope = tracing::debug_span!(
220 "Binius64",
221 n_hidden_words = inner_cs.n_hidden_words(InoutSegment::Public),
222 n_bitand = inner_cs.and_constraints.len(),
223 n_intmul = inner_cs.imul_constraints.len(),
224 )
225 .entered();
226
227 let inout = wrapped_channel.observe_words(inout);
230 let claim = self
231 .inner_iop_verifier
232 .verify(&inout, &mut wrapped_channel)?;
233
234 let public_value = |elem| {
240 wrapped_channel
241 .public_value(elem)
242 .expect("a public claim and its inputs are public wires")
243 };
244 WiringEvalClaim {
245 inputs: claim.inputs.iter().map(public_value).collect(),
246 claimed: public_value(&claim.claimed),
247 eval_fn: claim.eval_fn,
248 }
249 .check_native()
250 .map_err(crate::error::Error::from)?;
251 };
252
253 {
255 let outer_cs = self.outer_iop_verifier.constraint_system();
256 let _scope = tracing::debug_span!(
257 "ZK Wrapper",
258 n_witness = outer_cs.n_private(),
259 n_constraints = outer_cs.mul_constraints().len(),
260 )
261 .entered();
262
263 wrapped_channel.finish()?;
264 }
265
266 Ok(())
267 }
268
269 pub fn verify_sig<Challenger_: Challenger>(
274 &self,
275 inout: &[Word],
276 message: &[u8],
277 transcript: &mut VerifierTranscript<Challenger_>,
278 ) -> Result<(), Error> {
279 crate::signature::observe_message::<H, _>(&mut transcript.observe(), message);
280 self.verify(inout, transcript)
281 }
282}
283
284impl<H> SerializeBytes for ZKVerifier<H>
288where
289 H: HashSuite,
290 Output<H::LeafHash>: DeserializeBytes,
291{
292 fn serialize(&self, mut write_buf: impl BufMut) -> Result<(), SerializationError> {
293 const VERSION: u32 = 1;
294 VERSION.serialize(&mut write_buf)?;
295 self.constraint_system().serialize(&mut write_buf)?;
296 self.log_inv_rate().serialize(write_buf)
297 }
298}
299
300impl<H> DeserializeBytes for ZKVerifier<H>
301where
302 H: HashSuite,
303 Output<H::LeafHash>: DeserializeBytes,
304{
305 fn deserialize(mut read_buf: impl Buf) -> Result<Self, SerializationError> {
306 const VERSION: u32 = 1;
307 let version = u32::deserialize(&mut read_buf)?;
308 if version != VERSION {
309 return Err(SerializationError::InvalidConstruction {
310 name: "ZKVerifier::version",
311 });
312 }
313 let constraint_system = ConstraintSystem::deserialize(&mut read_buf)?;
314 let log_inv_rate = usize::deserialize(&mut read_buf)?;
315 Self::setup(constraint_system, log_inv_rate)
316 .map_err(|_| SerializationError::InvalidConstruction { name: "ZKVerifier" })
317 }
318}
319
320#[derive(Debug, thiserror::Error)]
322pub enum Error {
323 #[error("inner verification error: {0}")]
324 InnerVerification(#[from] crate::error::Error),
325 #[error("outer verification error: {0}")]
326 OuterVerification(#[from] binius_spartan_verifier::Error),
327 #[error("constraint system error: {0}")]
328 ConstraintSystem(#[from] binius_core::ConstraintSystemError),
329}