From 23f0e49c87bcd14db0ea6c6eaebd6e9e308e57a6 Mon Sep 17 00:00:00 2001 From: Daniel Lubarov Date: Sun, 2 Jan 2022 11:26:26 -0800 Subject: [PATCH] Separate some circuit logic from FRI code (#414) My goal is to make the FRI code independent of circuit objects like `CommonCircuitData`, so that it can be reused by STARK code which won't involve those objects. A few changes here: - Move `rate_bits` and `cap_height` into `FriConfig`. - Move `degree_bits` into `FriParameters` (since it's instance size specific). - Make `FriParams` contain `FriConfig`, so FRI methods can take just the former and access fields in both. - Replace `CommonCircuitConfig` with `FriParams` in FRI prover methods. The FRI verifier methods still involve circuit objects, as they have PLONK logic in `fri_combine_initial`. Will think about how to deal with that after this. --- plonky2/src/bin/bench_recursion.rs | 4 +-- plonky2/src/fri/commitment.rs | 6 ++-- plonky2/src/fri/mod.rs | 34 +++++++++++++++++-- plonky2/src/fri/proof.rs | 6 ++-- plonky2/src/fri/prover.rs | 44 +++++++++++++++---------- plonky2/src/fri/recursive_verifier.rs | 13 ++++---- plonky2/src/fri/verifier.rs | 2 +- plonky2/src/plonk/circuit_builder.rs | 21 ++++++------ plonky2/src/plonk/circuit_data.rs | 17 +++------- plonky2/src/plonk/get_challenges.rs | 2 +- plonky2/src/plonk/prover.rs | 16 ++++----- plonky2/src/plonk/recursive_verifier.rs | 8 ++--- plonky2/src/util/serialization.rs | 26 ++++++++------- 13 files changed, 116 insertions(+), 83 deletions(-) diff --git a/plonky2/src/bin/bench_recursion.rs b/plonky2/src/bin/bench_recursion.rs index e75ea135..cb8eaca9 100644 --- a/plonky2/src/bin/bench_recursion.rs +++ b/plonky2/src/bin/bench_recursion.rs @@ -26,11 +26,11 @@ fn bench_prove, const D: usize>() -> Result<()> { constant_gate_size: 6, use_base_arithmetic_gate: false, security_bits: 128, - rate_bits: 3, num_challenges: 3, zero_knowledge: false, - cap_height: 1, fri_config: FriConfig { + rate_bits: 3, + cap_height: 1, proof_of_work_bits: 15, reduction_strategy: FriReductionStrategy::ConstantArityBits(3, 5), num_query_rounds: 35, diff --git a/plonky2/src/fri/commitment.rs b/plonky2/src/fri/commitment.rs index cd61a3c2..9d0fd82e 100644 --- a/plonky2/src/fri/commitment.rs +++ b/plonky2/src/fri/commitment.rs @@ -208,14 +208,14 @@ impl, C: GenericConfig, const D: usize> alpha.shift_poly(&mut final_poly); final_poly += zs_quotient; - let lde_final_poly = final_poly.lde(config.rate_bits); + let lde_final_poly = final_poly.lde(config.fri_config.rate_bits); let lde_final_values = timed!( timing, &format!("perform final FFT {}", lde_final_poly.len()), lde_final_poly.coset_fft(F::coset_shift().into()) ); - let fri_proof = fri_proof( + let fri_proof = fri_proof::( &commitments .par_iter() .map(|c| &c.merkle_tree) @@ -223,7 +223,7 @@ impl, C: GenericConfig, const D: usize> lde_final_poly, lde_final_values, challenger, - common_data, + &common_data.fri_params, timing, ); diff --git a/plonky2/src/fri/mod.rs b/plonky2/src/fri/mod.rs index bfb2ebfd..c50d1ff7 100644 --- a/plonky2/src/fri/mod.rs +++ b/plonky2/src/fri/mod.rs @@ -9,6 +9,12 @@ pub mod verifier; #[derive(Debug, Clone, Eq, PartialEq)] pub struct FriConfig { + /// `rate = 2^{-rate_bits}`. + pub rate_bits: usize, + + /// Height of Merkle tree caps. + pub cap_height: usize, + pub proof_of_work_bits: u32, pub reduction_strategy: FriReductionStrategy, @@ -17,10 +23,16 @@ pub struct FriConfig { pub num_query_rounds: usize, } -/// Parameters which are generated during preprocessing, in contrast to `FriConfig` which is -/// user-specified. +/// FRI parameters, including generated parameters which are specific to an instance size, in +/// contrast to `FriConfig` which is user-specified and independent of instance size. #[derive(Debug)] -pub(crate) struct FriParams { +pub struct FriParams { + /// User-specified FRI configuration. + pub config: FriConfig, + + /// The degree of the purported codeword, measured in bits. + pub degree_bits: usize, + /// The arity of each FRI reduction step, expressed as the log2 of the actual arity. /// For example, `[3, 2, 1]` would describe a FRI reduction tree with 8-to-1 reduction, then /// a 4-to-1 reduction, then a 2-to-1 reduction. After these reductions, the reduced polynomial @@ -36,4 +48,20 @@ impl FriParams { pub(crate) fn max_arity_bits(&self) -> Option { self.reduction_arity_bits.iter().copied().max() } + + pub fn lde_bits(&self) -> usize { + self.degree_bits + self.config.rate_bits + } + + pub fn lde_size(&self) -> usize { + 1 << self.lde_bits() + } + + pub fn final_poly_bits(&self) -> usize { + self.degree_bits - self.total_arities() + } + + pub fn final_poly_len(&self) -> usize { + 1 << self.final_poly_bits() + } } diff --git a/plonky2/src/fri/proof.rs b/plonky2/src/fri/proof.rs index 98362af6..784f3286 100644 --- a/plonky2/src/fri/proof.rs +++ b/plonky2/src/fri/proof.rs @@ -140,7 +140,7 @@ impl, H: Hasher, const D: usize> FriProof, H: Hasher, const D: usize> CompressedFriPr .. } = challenges; let mut fri_inferred_elements = fri_inferred_elements.0.into_iter(); - let cap_height = common_data.config.cap_height; + let cap_height = common_data.config.fri_config.cap_height; let reduction_arity_bits = &common_data.fri_params.reduction_arity_bits; let num_reductions = reduction_arity_bits.len(); let num_initial_trees = query_round_proofs @@ -270,7 +270,7 @@ impl, H: Hasher, const D: usize> CompressedFriPr let mut steps_indices = vec![vec![]; num_reductions]; let mut steps_evals = vec![vec![]; num_reductions]; let mut steps_proofs = vec![vec![]; num_reductions]; - let height = common_data.degree_bits + common_data.config.rate_bits; + let height = common_data.degree_bits + common_data.config.fri_config.rate_bits; let heights = reduction_arity_bits .iter() .scan(height, |acc, &bits| { diff --git a/plonky2/src/fri/prover.rs b/plonky2/src/fri/prover.rs index 21311939..05135c91 100644 --- a/plonky2/src/fri/prover.rs +++ b/plonky2/src/fri/prover.rs @@ -4,11 +4,10 @@ use plonky2_util::reverse_index_bits_in_place; use rayon::prelude::*; use crate::fri::proof::{FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep}; -use crate::fri::FriConfig; +use crate::fri::{FriConfig, FriParams}; use crate::hash::hash_types::{HashOut, RichField}; use crate::hash::merkle_tree::MerkleTree; use crate::iop::challenger::Challenger; -use crate::plonk::circuit_data::CommonCircuitData; use crate::plonk::config::{GenericConfig, Hasher}; use crate::plonk::plonk_common::reduce_with_powers; use crate::timed; @@ -22,7 +21,7 @@ pub fn fri_proof, C: GenericConfig, const // Evaluation of the polynomial on the large domain. lde_polynomial_values: PolynomialValues, challenger: &mut Challenger, - common_data: &CommonCircuitData, + fri_params: &FriParams, timing: &mut TimingTree, ) -> FriProof { let n = lde_polynomial_values.values.len(); @@ -32,11 +31,11 @@ pub fn fri_proof, C: GenericConfig, const let (trees, final_coeffs) = timed!( timing, "fold codewords in the commitment phase", - fri_committed_trees( + fri_committed_trees::( lde_polynomial_coeffs, lde_polynomial_values, challenger, - common_data, + fri_params, ) ); @@ -45,12 +44,12 @@ pub fn fri_proof, C: GenericConfig, const let pow_witness = timed!( timing, "find proof-of-work witness", - fri_proof_of_work::(current_hash, &common_data.config.fri_config) + fri_proof_of_work::(current_hash, &fri_params.config) ); // Query phase let query_round_proofs = - fri_prover_query_rounds(initial_merkle_trees, &trees, challenger, n, common_data); + fri_prover_query_rounds::(initial_merkle_trees, &trees, challenger, n, fri_params); FriProof { commit_phase_merkle_caps: trees.iter().map(|t| t.cap.clone()).collect(), @@ -64,18 +63,17 @@ fn fri_committed_trees, C: GenericConfig, mut coeffs: PolynomialCoeffs, mut values: PolynomialValues, challenger: &mut Challenger, - common_data: &CommonCircuitData, + fri_params: &FriParams, ) -> ( Vec>, PolynomialCoeffs, ) { - let config = &common_data.config; let mut trees = Vec::new(); let mut shift = F::MULTIPLICATIVE_GROUP_GENERATOR; - let num_reductions = common_data.fri_params.reduction_arity_bits.len(); + let num_reductions = fri_params.reduction_arity_bits.len(); for i in 0..num_reductions { - let arity = 1 << common_data.fri_params.reduction_arity_bits[i]; + let arity = 1 << fri_params.reduction_arity_bits[i]; reverse_index_bits_in_place(&mut values.values); let chunked_values = values @@ -83,7 +81,7 @@ fn fri_committed_trees, C: GenericConfig, .par_chunks(arity) .map(|chunk: &[F::Extension]| flatten(chunk)) .collect(); - let tree = MerkleTree::::new(chunked_values, config.cap_height); + let tree = MerkleTree::::new(chunked_values, fri_params.config.cap_height); challenger.observe_cap(&tree.cap); trees.push(tree); @@ -102,7 +100,9 @@ fn fri_committed_trees, C: GenericConfig, } // The coefficients being removed here should always be zero. - coeffs.coeffs.truncate(coeffs.len() >> config.rate_bits); + coeffs + .coeffs + .truncate(coeffs.len() >> fri_params.config.rate_bits); challenger.observe_extension_elements(&coeffs.coeffs); (trees, coeffs) @@ -142,10 +142,18 @@ fn fri_prover_query_rounds< trees: &[MerkleTree], challenger: &mut Challenger, n: usize, - common_data: &CommonCircuitData, + fri_params: &FriParams, ) -> Vec> { - (0..common_data.config.fri_config.num_query_rounds) - .map(|_| fri_prover_query_round(initial_merkle_trees, trees, challenger, n, common_data)) + (0..fri_params.config.num_query_rounds) + .map(|_| { + fri_prover_query_round::( + initial_merkle_trees, + trees, + challenger, + n, + fri_params, + ) + }) .collect() } @@ -158,7 +166,7 @@ fn fri_prover_query_round< trees: &[MerkleTree], challenger: &mut Challenger, n: usize, - common_data: &CommonCircuitData, + fri_params: &FriParams, ) -> FriQueryRound { let mut query_steps = Vec::new(); let x = challenger.get_challenge(); @@ -168,7 +176,7 @@ fn fri_prover_query_round< .map(|t| (t.get(x_index).to_vec(), t.prove(x_index))) .collect::>(); for (i, tree) in trees.iter().enumerate() { - let arity_bits = common_data.fri_params.reduction_arity_bits[i]; + let arity_bits = fri_params.reduction_arity_bits[i]; let evals = unflatten(tree.get(x_index >> arity_bits)); let merkle_proof = tree.prove(x_index >> arity_bits); diff --git a/plonky2/src/fri/recursive_verifier.rs b/plonky2/src/fri/recursive_verifier.rs index 80a39f12..9d5fae4d 100644 --- a/plonky2/src/fri/recursive_verifier.rs +++ b/plonky2/src/fri/recursive_verifier.rs @@ -78,7 +78,7 @@ impl, const D: usize> CircuitBuilder { ) { let random_access = RandomAccessGate::::new_from_config( &self.config, - max_fri_arity_bits.max(self.config.cap_height), + max_fri_arity_bits.max(self.config.fri_config.cap_height), ); let (interpolation_wires, interpolation_routed_wires) = if 1 << max_fri_arity_bits > common_data.quotient_degree_factor { @@ -143,7 +143,7 @@ impl, const D: usize> CircuitBuilder { } debug_assert_eq!( - common_data.final_poly_len(), + common_data.fri_params.final_poly_len(), proof.final_poly.len(), "Final polynomial has wrong degree." ); @@ -267,8 +267,8 @@ impl, const D: usize> CircuitBuilder { let degree_log = common_data.degree_bits; debug_assert_eq!( degree_log, - common_data.config.cap_height + proof.evals_proofs[0].1.siblings.len() - - config.rate_bits + common_data.config.fri_config.cap_height + proof.evals_proofs[0].1.siblings.len() + - config.fri_config.rate_bits ); let subgroup_x = self.convert_to_ext(subgroup_x); let mut alpha = ReducingFactorTarget::new(alpha); @@ -343,8 +343,9 @@ impl, const D: usize> CircuitBuilder { let x_index = challenger.get_challenge(self); let mut x_index_bits = self.low_bits(x_index, n_log, F::BITS); - let cap_index = - self.le_sum(x_index_bits[x_index_bits.len() - common_data.config.cap_height..].iter()); + let cap_index = self.le_sum( + x_index_bits[x_index_bits.len() - common_data.config.fri_config.cap_height..].iter(), + ); with_context!( self, "check FRI initial proof", diff --git a/plonky2/src/fri/verifier.rs b/plonky2/src/fri/verifier.rs index cf883be6..d374ff68 100644 --- a/plonky2/src/fri/verifier.rs +++ b/plonky2/src/fri/verifier.rs @@ -72,7 +72,7 @@ pub(crate) fn verify_fri_proof< ) -> Result<()> { let config = &common_data.config; ensure!( - common_data.final_poly_len() == proof.final_poly.len(), + common_data.fri_params.final_poly_len() == proof.final_poly.len(), "Final polynomial has wrong degree." ); diff --git a/plonky2/src/plonk/circuit_builder.rs b/plonky2/src/plonk/circuit_builder.rs index dd800ede..2456d6fd 100644 --- a/plonky2/src/plonk/circuit_builder.rs +++ b/plonky2/src/plonk/circuit_builder.rs @@ -111,9 +111,9 @@ impl, const D: usize> CircuitBuilder { fn check_config(&self) { let &CircuitConfig { security_bits, - rate_bits, fri_config: FriConfig { + rate_bits, proof_of_work_bits, num_query_rounds, .. @@ -368,14 +368,16 @@ impl, const D: usize> CircuitBuilder { }) } - fn fri_params(&self, degree_bits_estimate: usize) -> FriParams { + fn fri_params(&self, degree_bits: usize) -> FriParams { let fri_config = &self.config.fri_config; let reduction_arity_bits = fri_config.reduction_strategy.reduction_arity_bits( - degree_bits_estimate, - self.config.rate_bits, + degree_bits, + self.config.fri_config.rate_bits, fri_config.num_query_rounds, ); FriParams { + config: fri_config.clone(), + degree_bits, reduction_arity_bits, } } @@ -620,8 +622,8 @@ impl, const D: usize> CircuitBuilder { let (gate_tree, max_filtered_constraint_degree, num_constants) = Tree::from_gates(gates); // `quotient_degree_factor` has to be between `max_filtered_constraint_degree-1` and `1<, const D: usize> CircuitBuilder { let (sigma_vecs, forest) = self.sigma_vecs(&k_is, &subgroup); // Precompute FFT roots. - let max_fft_points = - 1 << (degree_bits + max(self.config.rate_bits, log2_ceil(quotient_degree_factor))); + let max_fft_points = 1 << (degree_bits + max(rate_bits, log2_ceil(quotient_degree_factor))); let fft_root_table = fft_root_table(max_fft_points); let constants_sigmas_vecs = [constant_vecs, sigma_vecs.clone()].concat(); let constants_sigmas_commitment = PolynomialBatchCommitment::from_values( constants_sigmas_vecs, - self.config.rate_bits, + rate_bits, self.config.zero_knowledge & PlonkPolynomials::CONSTANTS_SIGMAS.blinding, - self.config.cap_height, + self.config.fri_config.cap_height, &mut timing, Some(&fft_root_table), ); diff --git a/plonky2/src/plonk/circuit_data.rs b/plonky2/src/plonk/circuit_data.rs index df8d51a0..74308fc3 100644 --- a/plonky2/src/plonk/circuit_data.rs +++ b/plonky2/src/plonk/circuit_data.rs @@ -30,14 +30,11 @@ pub struct CircuitConfig { /// for both base field and extension field arithmetic. pub use_base_arithmetic_gate: bool, pub security_bits: usize, - pub rate_bits: usize, /// The number of challenge points to generate, for IOPs that have soundness errors of (roughly) /// `degree / |F|`. pub num_challenges: usize, pub zero_knowledge: bool, - pub cap_height: usize, - // TODO: Find a better place for this. pub fri_config: FriConfig, } @@ -49,7 +46,7 @@ impl Default for CircuitConfig { impl CircuitConfig { pub fn rate(&self) -> f64 { - 1.0 / ((1 << self.rate_bits) as f64) + 1.0 / ((1 << self.fri_config.rate_bits) as f64) } pub fn num_advice_wires(&self) -> usize { @@ -64,11 +61,11 @@ impl CircuitConfig { constant_gate_size: 5, use_base_arithmetic_gate: true, security_bits: 100, - rate_bits: 3, num_challenges: 2, zero_knowledge: false, - cap_height: 4, fri_config: FriConfig { + rate_bits: 3, + cap_height: 4, proof_of_work_bits: 16, reduction_strategy: FriReductionStrategy::ConstantArityBits(4, 5), num_query_rounds: 28, @@ -251,11 +248,11 @@ impl, C: GenericConfig, const D: usize> } pub fn lde_size(&self) -> usize { - 1 << (self.degree_bits + self.config.rate_bits) + 1 << (self.degree_bits + self.config.fri_config.rate_bits) } pub fn lde_generator(&self) -> F { - F::primitive_root_of_unity(self.degree_bits + self.config.rate_bits) + F::primitive_root_of_unity(self.degree_bits + self.config.fri_config.rate_bits) } pub fn constraint_degree(&self) -> usize { @@ -289,10 +286,6 @@ impl, C: GenericConfig, const D: usize> pub fn partial_products_range(&self) -> RangeFrom { self.config.num_challenges.. } - - pub fn final_poly_len(&self) -> usize { - 1 << (self.degree_bits - self.fri_params.total_arities()) - } } /// The `Target` version of `VerifierCircuitData`, for use inside recursive circuits. Note that this diff --git a/plonky2/src/plonk/get_challenges.rs b/plonky2/src/plonk/get_challenges.rs index 4e90e27b..23e7f454 100644 --- a/plonky2/src/plonk/get_challenges.rs +++ b/plonky2/src/plonk/get_challenges.rs @@ -189,7 +189,7 @@ impl, C: GenericConfig, const D: usize> vec![HashSet::new(); common_data.fri_params.reduction_arity_bits.len()]; let precomputed_reduced_evals = PrecomputedReducedEvals::from_os_and_alpha(&self.proof.openings, *fri_alpha); - let log_n = common_data.degree_bits + common_data.config.rate_bits; + let log_n = common_data.degree_bits + common_data.config.fri_config.rate_bits; // Simulate the proof verification and collect the inferred elements. // The content of the loop is basically the same as the `fri_verifier_query_round` function. for &(mut x_index) in fri_query_indices { diff --git a/plonky2/src/plonk/prover.rs b/plonky2/src/plonk/prover.rs index 169f78bb..f7196270 100644 --- a/plonky2/src/plonk/prover.rs +++ b/plonky2/src/plonk/prover.rs @@ -71,9 +71,9 @@ pub(crate) fn prove, C: GenericConfig, co "compute wires commitment", PolynomialBatchCommitment::from_values( wires_values, - config.rate_bits, + config.fri_config.rate_bits, config.zero_knowledge & PlonkPolynomials::WIRES.blinding, - config.cap_height, + config.fri_config.cap_height, timing, prover_data.fft_root_table.as_ref(), ) @@ -111,9 +111,9 @@ pub(crate) fn prove, C: GenericConfig, co "commit to partial products and Z's", PolynomialBatchCommitment::from_values( zs_partial_products, - config.rate_bits, + config.fri_config.rate_bits, config.zero_knowledge & PlonkPolynomials::ZS_PARTIAL_PRODUCTS.blinding, - config.cap_height, + config.fri_config.cap_height, timing, prover_data.fft_root_table.as_ref(), ) @@ -160,9 +160,9 @@ pub(crate) fn prove, C: GenericConfig, co "commit to quotient polys", PolynomialBatchCommitment::from_coeffs( all_quotient_poly_chunks, - config.rate_bits, + config.fri_config.rate_bits, config.zero_knowledge & PlonkPolynomials::QUOTIENT.blinding, - config.cap_height, + config.fri_config.cap_height, timing, prover_data.fft_root_table.as_ref(), ) @@ -309,14 +309,14 @@ fn compute_quotient_polys< let num_challenges = common_data.config.num_challenges; let max_degree_bits = log2_ceil(common_data.quotient_degree_factor); assert!( - max_degree_bits <= common_data.config.rate_bits, + max_degree_bits <= common_data.config.fri_config.rate_bits, "Having constraints of degree higher than the rate is not supported yet. \ If we need this in the future, we can precompute the larger LDE before computing the `ListPolynomialCommitment`s." ); // We reuse the LDE computed in `ListPolynomialCommitment` and extract every `step` points to get // an LDE matching `max_filtered_constraint_degree`. - let step = 1 << (common_data.config.rate_bits - max_degree_bits); + let step = 1 << (common_data.config.fri_config.rate_bits - max_degree_bits); // When opening the `Z`s polys at the "next" point in Plonk, need to look at the point `next_step` // steps away since we work on an LDE of degree `max_filtered_constraint_degree`. let next_step = 1 << max_degree_bits; diff --git a/plonky2/src/plonk/recursive_verifier.rs b/plonky2/src/plonk/recursive_verifier.rs index 1850e320..dc6f5039 100644 --- a/plonky2/src/plonk/recursive_verifier.rs +++ b/plonky2/src/plonk/recursive_verifier.rs @@ -454,8 +454,8 @@ mod tests { // A high-rate recursive proof, designed to be verifiable with fewer routed wires. let high_rate_config = CircuitConfig { - rate_bits: 7, fri_config: FriConfig { + rate_bits: 7, proof_of_work_bits: 16, num_query_rounds: 12, ..standard_config.fri_config.clone() @@ -476,10 +476,10 @@ mod tests { // A final proof, optimized for size. let final_config = CircuitConfig { - cap_height: 0, - rate_bits: 8, num_routed_wires: 37, fri_config: FriConfig { + rate_bits: 8, + cap_height: 0, proof_of_work_bits: 20, reduction_strategy: FriReductionStrategy::MinSize(None), num_query_rounds: 10, @@ -582,7 +582,7 @@ mod tests { set_proof_target(&inner_proof, &pt, &mut pw); let inner_data = VerifierCircuitTarget { - constants_sigmas_cap: builder.add_virtual_cap(inner_config.cap_height), + constants_sigmas_cap: builder.add_virtual_cap(inner_config.fri_config.cap_height), }; pw.set_cap_target( &inner_data.constants_sigmas_cap, diff --git a/plonky2/src/util/serialization.rs b/plonky2/src/util/serialization.rs index 1b7fdbda..a9284bf4 100644 --- a/plonky2/src/util/serialization.rs +++ b/plonky2/src/util/serialization.rs @@ -347,11 +347,12 @@ impl Buffer { ) -> Result> { let config = &common_data.config; let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len()) - .map(|_| self.read_merkle_cap(config.cap_height)) + .map(|_| self.read_merkle_cap(config.fri_config.cap_height)) .collect::>>()?; let query_round_proofs = self.read_fri_query_rounds(common_data)?; - let final_poly = - PolynomialCoeffs::new(self.read_field_ext_vec::(common_data.final_poly_len())?); + let final_poly = PolynomialCoeffs::new( + self.read_field_ext_vec::(common_data.fri_params.final_poly_len())?, + ); let pow_witness = self.read_field()?; Ok(FriProof { commit_phase_merkle_caps, @@ -376,9 +377,9 @@ impl Buffer { common_data: &CommonCircuitData, ) -> Result> { let config = &common_data.config; - let wires_cap = self.read_merkle_cap(config.cap_height)?; - let plonk_zs_partial_products_cap = self.read_merkle_cap(config.cap_height)?; - let quotient_polys_cap = self.read_merkle_cap(config.cap_height)?; + let wires_cap = self.read_merkle_cap(config.fri_config.cap_height)?; + let plonk_zs_partial_products_cap = self.read_merkle_cap(config.fri_config.cap_height)?; + let quotient_polys_cap = self.read_merkle_cap(config.fri_config.cap_height)?; let openings = self.read_opening_set(common_data)?; let opening_proof = self.read_fri_proof(common_data)?; @@ -522,11 +523,12 @@ impl Buffer { ) -> Result> { let config = &common_data.config; let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len()) - .map(|_| self.read_merkle_cap(config.cap_height)) + .map(|_| self.read_merkle_cap(config.fri_config.cap_height)) .collect::>>()?; let query_round_proofs = self.read_compressed_fri_query_rounds(common_data)?; - let final_poly = - PolynomialCoeffs::new(self.read_field_ext_vec::(common_data.final_poly_len())?); + let final_poly = PolynomialCoeffs::new( + self.read_field_ext_vec::(common_data.fri_params.final_poly_len())?, + ); let pow_witness = self.read_field()?; Ok(CompressedFriProof { commit_phase_merkle_caps, @@ -559,9 +561,9 @@ impl Buffer { common_data: &CommonCircuitData, ) -> Result> { let config = &common_data.config; - let wires_cap = self.read_merkle_cap(config.cap_height)?; - let plonk_zs_partial_products_cap = self.read_merkle_cap(config.cap_height)?; - let quotient_polys_cap = self.read_merkle_cap(config.cap_height)?; + let wires_cap = self.read_merkle_cap(config.fri_config.cap_height)?; + let plonk_zs_partial_products_cap = self.read_merkle_cap(config.fri_config.cap_height)?; + let quotient_polys_cap = self.read_merkle_cap(config.fri_config.cap_height)?; let openings = self.read_opening_set(common_data)?; let opening_proof = self.read_compressed_fri_proof(common_data)?;