logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-05 23:33:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove Config from CommonCircuitData

Browse Source
This commit is contained in:
wborgeaud 2022-10-25 10:08:21 +02:00
parent 7b2f515c00
commit 0e58efdcc1
13 changed files with 94 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
evm/src/recursive_verifier.rs
View File

@ -235,7 +235,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
.zip(verifier_data_target) .zip(verifier_data_target)
.enumerate() .enumerate()
{ {
builder.verify_proof( builder.verify_proof::<C>(
recursive_proof, recursive_proof,
&verifier_data_target, &verifier_data_target,
&verifier_data[i].common, &verifier_data[i].common,
@ -579,7 +579,7 @@ where
{ {
let recursive_proofs = std::array::from_fn(|i| { let recursive_proofs = std::array::from_fn(|i| {
let verifier_data = &verifier_data[i]; let verifier_data = &verifier_data[i];
builder.add_virtual_proof_with_pis(&verifier_data.common) builder.add_virtual_proof_with_pis::<C>(&verifier_data.common)
}); });
let verifier_data = std::array::from_fn(|i| { let verifier_data = std::array::from_fn(|i| {
let verifier_data = &verifier_data[i]; let verifier_data = &verifier_data[i];

8
plonky2/examples/bench_recursion.rs
View File

@ -32,7 +32,7 @@ use structopt::StructOpt;
type ProofTuple<F, C, const D: usize> = ( type ProofTuple<F, C, const D: usize> = (
ProofWithPublicInputs<F, C, D>, ProofWithPublicInputs<F, C, D>,
VerifierOnlyCircuitData<C, D>, VerifierOnlyCircuitData<C, D>,
CommonCircuitData<F, C, D>, CommonCircuitData<F, D>,
); );
#[derive(Clone, StructOpt, Debug)] #[derive(Clone, StructOpt, Debug)]
@ -112,7 +112,7 @@ where
let (inner_proof, inner_vd, inner_cd) = inner; let (inner_proof, inner_vd, inner_cd) = inner;
let mut builder = CircuitBuilder::<F, D>::new(config.clone()); let mut builder = CircuitBuilder::<F, D>::new(config.clone());
let mut pw = PartialWitness::new(); let mut pw = PartialWitness::new();
let pt = builder.add_virtual_proof_with_pis(inner_cd); let pt = builder.add_virtual_proof_with_pis::<InnerC>(inner_cd);
pw.set_proof_with_pis_target(&pt, inner_proof); pw.set_proof_with_pis_target(&pt, inner_proof);
let inner_data = VerifierCircuitTarget { let inner_data = VerifierCircuitTarget {
@ -121,7 +121,7 @@ where
}; };
pw.set_verifier_data_target(&inner_data, inner_vd); pw.set_verifier_data_target(&inner_data, inner_vd);
builder.verify_proof(pt, &inner_data, inner_cd); builder.verify_proof::<InnerC>(pt, &inner_data, inner_cd);
builder.print_gate_counts(0); builder.print_gate_counts(0);
if let Some(min_degree_bits) = min_degree_bits { if let Some(min_degree_bits) = min_degree_bits {
@ -150,7 +150,7 @@ where
fn test_serialization<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( fn test_serialization<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
proof: &ProofWithPublicInputs<F, C, D>, proof: &ProofWithPublicInputs<F, C, D>,
vd: &VerifierOnlyCircuitData<C, D>, vd: &VerifierOnlyCircuitData<C, D>,
cd: &CommonCircuitData<F, C, D>, cd: &CommonCircuitData<F, D>,
) -> Result<()> ) -> Result<()>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,

2
plonky2/src/iop/generator.rs
View File

@ -22,7 +22,7 @@ pub(crate) fn generate_partial_witness<
>( >(
inputs: PartialWitness<F>, inputs: PartialWitness<F>,
prover_data: &'a ProverOnlyCircuitData<F, C, D>, prover_data: &'a ProverOnlyCircuitData<F, C, D>,
common_data: &'a CommonCircuitData<F, C, D>, common_data: &'a CommonCircuitData<F, D>,
) -> PartitionWitness<'a, F> { ) -> PartitionWitness<'a, F> {
let config = &common_data.config; let config = &common_data.config;
let generators = &prover_data.generators; let generators = &prover_data.generators;

20
plonky2/src/plonk/circuit_data.rs
View File

@ -106,7 +106,7 @@ impl CircuitConfig {
pub struct CircuitData<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> { pub struct CircuitData<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {
pub prover_only: ProverOnlyCircuitData<F, C, D>, pub prover_only: ProverOnlyCircuitData<F, C, D>,
pub verifier_only: VerifierOnlyCircuitData<C, D>, pub verifier_only: VerifierOnlyCircuitData<C, D>,
pub common: CommonCircuitData<F, C, D>, pub common: CommonCircuitData<F, D>,
} }
impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
@ -196,7 +196,7 @@ pub struct ProverCircuitData<
const D: usize, const D: usize,
> { > {
pub prover_only: ProverOnlyCircuitData<F, C, D>, pub prover_only: ProverOnlyCircuitData<F, C, D>,
pub common: CommonCircuitData<F, C, D>, pub common: CommonCircuitData<F, D>,
} }
impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
@ -223,7 +223,7 @@ pub struct VerifierCircuitData<
const D: usize, const D: usize,
> { > {
pub verifier_only: VerifierOnlyCircuitData<C, D>, pub verifier_only: VerifierOnlyCircuitData<C, D>,
pub common: CommonCircuitData<F, C, D>, pub common: CommonCircuitData<F, D>,
} }
impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
@ -287,17 +287,13 @@ pub struct VerifierOnlyCircuitData<C: GenericConfig<D>, const D: usize> {
/// Circuit data required by both the prover and the verifier. /// Circuit data required by both the prover and the verifier.
#[derive(Debug, Eq, PartialEq)] #[derive(Debug, Eq, PartialEq)]
pub struct CommonCircuitData< pub struct CommonCircuitData<F: RichField + Extendable<D>, const D: usize> {
F: RichField + Extendable<D>,
C: GenericConfig<D, F = F>,
const D: usize,
> {
pub config: CircuitConfig, pub config: CircuitConfig,
pub(crate) fri_params: FriParams, pub(crate) fri_params: FriParams,
/// The types of gates used in this circuit, along with their prefixes. /// The types of gates used in this circuit, along with their prefixes.
pub(crate) gates: Vec<GateRef<C::F, D>>, pub(crate) gates: Vec<GateRef<F, D>>,
/// Information on the circuit's selector polynomials. /// Information on the circuit's selector polynomials.
pub(crate) selectors_info: SelectorsInfo, pub(crate) selectors_info: SelectorsInfo,
@ -314,15 +310,13 @@ pub struct CommonCircuitData<
pub(crate) num_public_inputs: usize, pub(crate) num_public_inputs: usize,
/// The `{k_i}` valued used in `S_ID_i` in Plonk's permutation argument. /// The `{k_i}` valued used in `S_ID_i` in Plonk's permutation argument.
pub(crate) k_is: Vec<C::F>, pub(crate) k_is: Vec<F>,
/// The number of partial products needed to compute the `Z` polynomials. /// The number of partial products needed to compute the `Z` polynomials.
pub(crate) num_partial_products: usize, pub(crate) num_partial_products: usize,
} }
impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> impl<F: RichField + Extendable<D>, const D: usize> CommonCircuitData<F, D> {
CommonCircuitData<F, C, D>
{
pub const fn degree_bits(&self) -> usize { pub const fn degree_bits(&self) -> usize {
self.fri_params.degree_bits self.fri_params.degree_bits
} }

20
plonky2/src/plonk/conditional_recursive_verifier.rs
View File

@ -30,7 +30,7 @@ pub(crate) fn dummy_proof<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<( ) -> Result<(
ProofWithPublicInputs<F, C, D>, ProofWithPublicInputs<F, C, D>,
VerifierOnlyCircuitData<C, D>, VerifierOnlyCircuitData<C, D>,
@ -80,7 +80,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
inner_verifier_data0: &VerifierCircuitTarget, inner_verifier_data0: &VerifierCircuitTarget,
proof_with_pis1: &ProofWithPublicInputsTarget<D>, proof_with_pis1: &ProofWithPublicInputsTarget<D>,
inner_verifier_data1: &VerifierCircuitTarget, inner_verifier_data1: &VerifierCircuitTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) where ) where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
{ {
@ -144,7 +144,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
), ),
}; };
self.verify_proof(selected_proof, &selected_verifier_data, inner_common_data); self.verify_proof::<C>(selected_proof, &selected_verifier_data, inner_common_data);
} }
/// Conditionally verify a proof with a new generated dummy proof. /// Conditionally verify a proof with a new generated dummy proof.
@ -153,18 +153,18 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
condition: BoolTarget, condition: BoolTarget,
proof_with_pis: &ProofWithPublicInputsTarget<D>, proof_with_pis: &ProofWithPublicInputsTarget<D>,
inner_verifier_data: &VerifierCircuitTarget, inner_verifier_data: &VerifierCircuitTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) -> (ProofWithPublicInputsTarget<D>, VerifierCircuitTarget) ) -> (ProofWithPublicInputsTarget<D>, VerifierCircuitTarget)
where where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
{ {
let dummy_proof = self.add_virtual_proof_with_pis(inner_common_data); let dummy_proof = self.add_virtual_proof_with_pis::<C>(inner_common_data);
let dummy_verifier_data = VerifierCircuitTarget { let dummy_verifier_data = VerifierCircuitTarget {
constants_sigmas_cap: self constants_sigmas_cap: self
.add_virtual_cap(inner_common_data.config.fri_config.cap_height), .add_virtual_cap(inner_common_data.config.fri_config.cap_height),
circuit_digest: self.add_virtual_hash(), circuit_digest: self.add_virtual_hash(),
}; };
self.conditionally_verify_proof( self.conditionally_verify_proof::<C>(
condition, condition,
proof_with_pis, proof_with_pis,
inner_verifier_data, inner_verifier_data,
@ -406,10 +406,10 @@ mod tests {
// Conditionally verify the two proofs. // Conditionally verify the two proofs.
let mut builder = CircuitBuilder::<F, D>::new(config); let mut builder = CircuitBuilder::<F, D>::new(config);
let mut pw = PartialWitness::new(); let mut pw = PartialWitness::new();
let pt = builder.add_virtual_proof_with_pis(&data.common); let pt = builder.add_virtual_proof_with_pis::<C>(&data.common);
pw.set_proof_with_pis_target(&pt, &proof); pw.set_proof_with_pis_target(&pt, &proof);
let dummy_pt = builder.add_virtual_proof_with_pis(&data.common); let dummy_pt = builder.add_virtual_proof_with_pis::<C>(&data.common);
pw.set_proof_with_pis_target(&dummy_pt, &dummy_proof); pw.set_proof_with_pis_target::<C, D>(&dummy_pt, &dummy_proof);
let inner_data = VerifierCircuitTarget { let inner_data = VerifierCircuitTarget {
constants_sigmas_cap: builder.add_virtual_cap(data.common.config.fri_config.cap_height), constants_sigmas_cap: builder.add_virtual_cap(data.common.config.fri_config.cap_height),
circuit_digest: builder.add_virtual_hash(), circuit_digest: builder.add_virtual_hash(),
@ -421,7 +421,7 @@ mod tests {
}; };
pw.set_verifier_data_target(&dummy_inner_data, &dummy_data); pw.set_verifier_data_target(&dummy_inner_data, &dummy_data);
let b = builder.constant_bool(F::rand().0 % 2 == 0); let b = builder.constant_bool(F::rand().0 % 2 == 0);
builder.conditionally_verify_proof( builder.conditionally_verify_proof::<C>(
b, b,
&pt, &pt,
&inner_data, &inner_data,

20
plonky2/src/plonk/get_challenges.rs
View File

@ -30,7 +30,7 @@ fn get_challenges<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, cons
final_poly: &PolynomialCoeffs<F::Extension>, final_poly: &PolynomialCoeffs<F::Extension>,
pow_witness: F, pow_witness: F,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<ProofChallenges<F, D>> { ) -> anyhow::Result<ProofChallenges<F, D>> {
let config = &common_data.config; let config = &common_data.config;
let num_challenges = config.num_challenges; let num_challenges = config.num_challenges;
@ -74,7 +74,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub(crate) fn fri_query_indices( pub(crate) fn fri_query_indices(
&self, &self,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<Vec<usize>> { ) -> anyhow::Result<Vec<usize>> {
Ok(self Ok(self
.get_challenges(self.get_public_inputs_hash(), circuit_digest, common_data)? .get_challenges(self.get_public_inputs_hash(), circuit_digest, common_data)?
@ -87,7 +87,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
&self, &self,
public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash, public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<ProofChallenges<F, D>> { ) -> anyhow::Result<ProofChallenges<F, D>> {
let Proof { let Proof {
wires_cap, wires_cap,
@ -103,7 +103,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
}, },
} = &self.proof; } = &self.proof;
get_challenges( get_challenges::<F, C, D>(
public_inputs_hash, public_inputs_hash,
wires_cap, wires_cap,
plonk_zs_partial_products_cap, plonk_zs_partial_products_cap,
@ -126,7 +126,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
&self, &self,
public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash, public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<ProofChallenges<F, D>> { ) -> anyhow::Result<ProofChallenges<F, D>> {
let CompressedProof { let CompressedProof {
wires_cap, wires_cap,
@ -142,7 +142,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
}, },
} = &self.proof; } = &self.proof;
get_challenges( get_challenges::<F, C, D>(
public_inputs_hash, public_inputs_hash,
wires_cap, wires_cap,
plonk_zs_partial_products_cap, plonk_zs_partial_products_cap,
@ -160,7 +160,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub(crate) fn get_inferred_elements( pub(crate) fn get_inferred_elements(
&self, &self,
challenges: &ProofChallenges<F, D>, challenges: &ProofChallenges<F, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> FriInferredElements<F, D> { ) -> FriInferredElements<F, D> {
let ProofChallenges { let ProofChallenges {
plonk_zeta, plonk_zeta,
@ -244,7 +244,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
final_poly: &PolynomialCoeffsExtTarget<D>, final_poly: &PolynomialCoeffsExtTarget<D>,
pow_witness: Target, pow_witness: Target,
inner_circuit_digest: HashOutTarget, inner_circuit_digest: HashOutTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) -> ProofChallengesTarget<D> ) -> ProofChallengesTarget<D>
where where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
@ -292,7 +292,7 @@ impl<const D: usize> ProofWithPublicInputsTarget<D> {
builder: &mut CircuitBuilder<F, D>, builder: &mut CircuitBuilder<F, D>,
public_inputs_hash: HashOutTarget, public_inputs_hash: HashOutTarget,
inner_circuit_digest: HashOutTarget, inner_circuit_digest: HashOutTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) -> ProofChallengesTarget<D> ) -> ProofChallengesTarget<D>
where where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
@ -311,7 +311,7 @@ impl<const D: usize> ProofWithPublicInputsTarget<D> {
}, },
} = &self.proof; } = &self.proof;
builder.get_challenges( builder.get_challenges::<C>(
public_inputs_hash, public_inputs_hash,
wires_cap, wires_cap,
plonk_zs_partial_products_cap, plonk_zs_partial_products_cap,

12
plonky2/src/plonk/proof.rs
View File

@ -82,7 +82,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub fn compress( pub fn compress(
self, self,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<CompressedProofWithPublicInputs<F, C, D>> { ) -> anyhow::Result<CompressedProofWithPublicInputs<F, C, D>> {
let indices = self.fri_query_indices(circuit_digest, common_data)?; let indices = self.fri_query_indices(circuit_digest, common_data)?;
let compressed_proof = self.proof.compress(&indices, &common_data.fri_params); let compressed_proof = self.proof.compress(&indices, &common_data.fri_params);
@ -106,7 +106,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub fn from_bytes( pub fn from_bytes(
bytes: Vec<u8>, bytes: Vec<u8>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<Self> { ) -> anyhow::Result<Self> {
let mut buffer = Buffer::new(bytes); let mut buffer = Buffer::new(bytes);
let proof = buffer.read_proof_with_public_inputs(common_data)?; let proof = buffer.read_proof_with_public_inputs(common_data)?;
@ -178,7 +178,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub fn decompress( pub fn decompress(
self, self,
circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash, circuit_digest: &<<C as GenericConfig<D>>::Hasher as Hasher<C::F>>::Hash,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<ProofWithPublicInputs<F, C, D>> ) -> anyhow::Result<ProofWithPublicInputs<F, C, D>>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,
@ -198,7 +198,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub(crate) fn verify( pub(crate) fn verify(
self, self,
verifier_data: &VerifierOnlyCircuitData<C, D>, verifier_data: &VerifierOnlyCircuitData<C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<()> ) -> anyhow::Result<()>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,
@ -240,7 +240,7 @@ impl<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>
pub fn from_bytes( pub fn from_bytes(
bytes: Vec<u8>, bytes: Vec<u8>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<Self> { ) -> anyhow::Result<Self> {
let mut buffer = Buffer::new(bytes); let mut buffer = Buffer::new(bytes);
let proof = buffer.read_compressed_proof_with_public_inputs(common_data)?; let proof = buffer.read_compressed_proof_with_public_inputs(common_data)?;
@ -303,7 +303,7 @@ impl<F: RichField + Extendable<D>, const D: usize> OpeningSet<F, D> {
wires_commitment: &PolynomialBatch<F, C, D>, wires_commitment: &PolynomialBatch<F, C, D>,
zs_partial_products_commitment: &PolynomialBatch<F, C, D>, zs_partial_products_commitment: &PolynomialBatch<F, C, D>,
quotient_polys_commitment: &PolynomialBatch<F, C, D>, quotient_polys_commitment: &PolynomialBatch<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Self { ) -> Self {
let eval_commitment = |z: F::Extension, c: &PolynomialBatch<F, C, D>| { let eval_commitment = |z: F::Extension, c: &PolynomialBatch<F, C, D>| {
c.polynomials c.polynomials

10
plonky2/src/plonk/prover.rs
View File

@ -28,7 +28,7 @@ use crate::util::transpose;
pub fn prove<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( pub fn prove<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
prover_data: &ProverOnlyCircuitData<F, C, D>, prover_data: &ProverOnlyCircuitData<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
inputs: PartialWitness<F>, inputs: PartialWitness<F>,
timing: &mut TimingTree, timing: &mut TimingTree,
) -> Result<ProofWithPublicInputs<F, C, D>> ) -> Result<ProofWithPublicInputs<F, C, D>>
@ -233,7 +233,7 @@ fn all_wires_permutation_partial_products<
betas: &[F], betas: &[F],
gammas: &[F], gammas: &[F],
prover_data: &ProverOnlyCircuitData<F, C, D>, prover_data: &ProverOnlyCircuitData<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Vec<Vec<PolynomialValues<F>>> { ) -> Vec<Vec<PolynomialValues<F>>> {
(0..common_data.config.num_challenges) (0..common_data.config.num_challenges)
.map(|i| { .map(|i| {
@ -260,7 +260,7 @@ fn wires_permutation_partial_products_and_zs<
beta: F, beta: F,
gamma: F, gamma: F,
prover_data: &ProverOnlyCircuitData<F, C, D>, prover_data: &ProverOnlyCircuitData<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Vec<PolynomialValues<F>> { ) -> Vec<PolynomialValues<F>> {
let degree = common_data.quotient_degree_factor; let degree = common_data.quotient_degree_factor;
let subgroup = &prover_data.subgroup; let subgroup = &prover_data.subgroup;
@ -318,7 +318,7 @@ fn compute_quotient_polys<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
prover_data: &'a ProverOnlyCircuitData<F, C, D>, prover_data: &'a ProverOnlyCircuitData<F, C, D>,
public_inputs_hash: &<<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash, public_inputs_hash: &<<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash,
wires_commitment: &'a PolynomialBatch<F, C, D>, wires_commitment: &'a PolynomialBatch<F, C, D>,
@ -424,7 +424,7 @@ fn compute_quotient_polys<
public_inputs_hash, public_inputs_hash,
); );
let mut quotient_values_batch = eval_vanishing_poly_base_batch( let mut quotient_values_batch = eval_vanishing_poly_base_batch::<F, C, D>(
common_data, common_data,
&indices_batch, &indices_batch,
&shifted_xs_batch, &shifted_xs_batch,

32
plonky2/src/plonk/recursive_verifier.rs
View File

@ -19,7 +19,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
&mut self, &mut self,
proof_with_pis: ProofWithPublicInputsTarget<D>, proof_with_pis: ProofWithPublicInputsTarget<D>,
inner_verifier_data: &VerifierCircuitTarget, inner_verifier_data: &VerifierCircuitTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) where ) where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
{ {
@ -29,14 +29,14 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
); );
let public_inputs_hash = let public_inputs_hash =
self.hash_n_to_hash_no_pad::<C::InnerHasher>(proof_with_pis.public_inputs.clone()); self.hash_n_to_hash_no_pad::<C::InnerHasher>(proof_with_pis.public_inputs.clone());
let challenges = proof_with_pis.get_challenges( let challenges = proof_with_pis.get_challenges::<F, C>(
self, self,
public_inputs_hash, public_inputs_hash,
inner_verifier_data.circuit_digest, inner_verifier_data.circuit_digest,
inner_common_data, inner_common_data,
); );
self.verify_proof_with_challenges( self.verify_proof_with_challenges::<C>(
proof_with_pis.proof, proof_with_pis.proof,
public_inputs_hash, public_inputs_hash,
challenges, challenges,
@ -52,7 +52,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
public_inputs_hash: HashOutTarget, public_inputs_hash: HashOutTarget,
challenges: ProofChallengesTarget<D>, challenges: ProofChallengesTarget<D>,
inner_verifier_data: &VerifierCircuitTarget, inner_verifier_data: &VerifierCircuitTarget,
inner_common_data: &CommonCircuitData<F, C, D>, inner_common_data: &CommonCircuitData<F, D>,
) where ) where
C::Hasher: AlgebraicHasher<F>, C::Hasher: AlgebraicHasher<F>,
{ {
@ -75,7 +75,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
let vanishing_polys_zeta = with_context!( let vanishing_polys_zeta = with_context!(
self, self,
"evaluate the vanishing polynomial at our challenge point, zeta.", "evaluate the vanishing polynomial at our challenge point, zeta.",
eval_vanishing_poly_circuit( eval_vanishing_poly_circuit::<F, C, D>(
self, self,
inner_common_data, inner_common_data,
challenges.plonk_zeta, challenges.plonk_zeta,
@ -129,9 +129,9 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
pub fn add_virtual_proof_with_pis<InnerC: GenericConfig<D, F = F>>( pub fn add_virtual_proof_with_pis<InnerC: GenericConfig<D, F = F>>(
&mut self, &mut self,
common_data: &CommonCircuitData<F, InnerC, D>, common_data: &CommonCircuitData<F, D>,
) -> ProofWithPublicInputsTarget<D> { ) -> ProofWithPublicInputsTarget<D> {
let proof = self.add_virtual_proof(common_data); let proof = self.add_virtual_proof::<InnerC>(common_data);
let public_inputs = self.add_virtual_targets(common_data.num_public_inputs); let public_inputs = self.add_virtual_targets(common_data.num_public_inputs);
ProofWithPublicInputsTarget { ProofWithPublicInputsTarget {
proof, proof,
@ -141,7 +141,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
fn add_virtual_proof<InnerC: GenericConfig<D, F = F>>( fn add_virtual_proof<InnerC: GenericConfig<D, F = F>>(
&mut self, &mut self,
common_data: &CommonCircuitData<F, InnerC, D>, common_data: &CommonCircuitData<F, D>,
) -> ProofTarget<D> { ) -> ProofTarget<D> {
let config = &common_data.config; let config = &common_data.config;
let fri_params = &common_data.fri_params; let fri_params = &common_data.fri_params;
@ -159,14 +159,14 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilder<F, D> {
wires_cap: self.add_virtual_cap(cap_height), wires_cap: self.add_virtual_cap(cap_height),
plonk_zs_partial_products_cap: self.add_virtual_cap(cap_height), plonk_zs_partial_products_cap: self.add_virtual_cap(cap_height),
quotient_polys_cap: self.add_virtual_cap(cap_height), quotient_polys_cap: self.add_virtual_cap(cap_height),
openings: self.add_opening_set(common_data), openings: self.add_opening_set::<InnerC>(common_data),
opening_proof: self.add_virtual_fri_proof(num_leaves_per_oracle, fri_params), opening_proof: self.add_virtual_fri_proof(num_leaves_per_oracle, fri_params),
} }
} }
fn add_opening_set<InnerC: GenericConfig<D, F = F>>( fn add_opening_set<InnerC: GenericConfig<D, F = F>>(
&mut self, &mut self,
common_data: &CommonCircuitData<F, InnerC, D>, common_data: &CommonCircuitData<F, D>,
) -> OpeningSetTarget<D> { ) -> OpeningSetTarget<D> {
let config = &common_data.config; let config = &common_data.config;
let num_challenges = config.num_challenges; let num_challenges = config.num_challenges;
@ -330,7 +330,7 @@ mod tests {
) -> Result<( ) -> Result<(
ProofWithPublicInputs<F, C, D>, ProofWithPublicInputs<F, C, D>,
VerifierOnlyCircuitData<C, D>, VerifierOnlyCircuitData<C, D>,
CommonCircuitData<F, C, D>, CommonCircuitData<F, D>,
)> )>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,
@ -356,7 +356,7 @@ mod tests {
>( >(
inner_proof: ProofWithPublicInputs<F, InnerC, D>, inner_proof: ProofWithPublicInputs<F, InnerC, D>,
inner_vd: VerifierOnlyCircuitData<InnerC, D>, inner_vd: VerifierOnlyCircuitData<InnerC, D>,
inner_cd: CommonCircuitData<F, InnerC, D>, inner_cd: CommonCircuitData<F, D>,
config: &CircuitConfig, config: &CircuitConfig,
min_degree_bits: Option<usize>, min_degree_bits: Option<usize>,
print_gate_counts: bool, print_gate_counts: bool,
@ -364,7 +364,7 @@ mod tests {
) -> Result<( ) -> Result<(
ProofWithPublicInputs<F, C, D>, ProofWithPublicInputs<F, C, D>,
VerifierOnlyCircuitData<C, D>, VerifierOnlyCircuitData<C, D>,
CommonCircuitData<F, C, D>, CommonCircuitData<F, D>,
)> )>
where where
InnerC::Hasher: AlgebraicHasher<F>, InnerC::Hasher: AlgebraicHasher<F>,
@ -372,7 +372,7 @@ mod tests {
{ {
let mut builder = CircuitBuilder::<F, D>::new(config.clone()); let mut builder = CircuitBuilder::<F, D>::new(config.clone());
let mut pw = PartialWitness::new(); let mut pw = PartialWitness::new();
let pt = builder.add_virtual_proof_with_pis(&inner_cd); let pt = builder.add_virtual_proof_with_pis::<InnerC>(&inner_cd);
pw.set_proof_with_pis_target(&pt, &inner_proof); pw.set_proof_with_pis_target(&pt, &inner_proof);
let inner_data = VerifierCircuitTarget { let inner_data = VerifierCircuitTarget {
@ -385,7 +385,7 @@ mod tests {
); );
pw.set_hash_target(inner_data.circuit_digest, inner_vd.circuit_digest); pw.set_hash_target(inner_data.circuit_digest, inner_vd.circuit_digest);
builder.verify_proof(pt, &inner_data, &inner_cd); builder.verify_proof::<InnerC>(pt, &inner_data, &inner_cd);
if print_gate_counts { if print_gate_counts {
builder.print_gate_counts(0); builder.print_gate_counts(0);
@ -422,7 +422,7 @@ mod tests {
>( >(
proof: &ProofWithPublicInputs<F, C, D>, proof: &ProofWithPublicInputs<F, C, D>,
vd: &VerifierOnlyCircuitData<C, D>, vd: &VerifierOnlyCircuitData<C, D>,
cd: &CommonCircuitData<F, C, D>, cd: &CommonCircuitData<F, D>,
) -> Result<()> ) -> Result<()>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,

4
plonky2/src/plonk/validate_shape.rs
View File

@ -8,7 +8,7 @@ use crate::plonk::proof::{OpeningSet, Proof, ProofWithPublicInputs};
pub(crate) fn validate_proof_with_pis_shape<F, C, const D: usize>( pub(crate) fn validate_proof_with_pis_shape<F, C, const D: usize>(
proof_with_pis: &ProofWithPublicInputs<F, C, D>, proof_with_pis: &ProofWithPublicInputs<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<()> ) -> anyhow::Result<()>
where where
F: RichField + Extendable<D>, F: RichField + Extendable<D>,
@ -32,7 +32,7 @@ where
fn validate_proof_shape<F, C, const D: usize>( fn validate_proof_shape<F, C, const D: usize>(
proof: &Proof<F, C, D>, proof: &Proof<F, C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> anyhow::Result<()> ) -> anyhow::Result<()>
where where
F: RichField + Extendable<D>, F: RichField + Extendable<D>,

19
plonky2/src/plonk/vanishing_poly.rs
View File

@ -25,7 +25,7 @@ pub(crate) fn eval_vanishing_poly<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
x: F::Extension, x: F::Extension,
vars: EvaluationVars<F, D>, vars: EvaluationVars<F, D>,
local_zs: &[F::Extension], local_zs: &[F::Extension],
@ -39,7 +39,7 @@ pub(crate) fn eval_vanishing_poly<
let max_degree = common_data.quotient_degree_factor; let max_degree = common_data.quotient_degree_factor;
let num_prods = common_data.num_partial_products; let num_prods = common_data.num_partial_products;
let constraint_terms = evaluate_gate_constraints(common_data, vars); let constraint_terms = evaluate_gate_constraints::<F, C, D>(common_data, vars);
// The L_0(x) (Z(x) - 1) vanishing terms. // The L_0(x) (Z(x) - 1) vanishing terms.
let mut vanishing_z_1_terms = Vec::new(); let mut vanishing_z_1_terms = Vec::new();
@ -100,7 +100,7 @@ pub(crate) fn eval_vanishing_poly_base_batch<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
indices_batch: &[usize], indices_batch: &[usize],
xs_batch: &[F], xs_batch: &[F],
vars_batch: EvaluationVarsBaseBatch<F>, vars_batch: EvaluationVarsBaseBatch<F>,
@ -126,7 +126,8 @@ pub(crate) fn eval_vanishing_poly_base_batch<
let num_gate_constraints = common_data.num_gate_constraints; let num_gate_constraints = common_data.num_gate_constraints;
let constraint_terms_batch = evaluate_gate_constraints_base_batch(common_data, vars_batch); let constraint_terms_batch =
evaluate_gate_constraints_base_batch::<F, C, D>(common_data, vars_batch);
debug_assert!(constraint_terms_batch.len() == n * num_gate_constraints); debug_assert!(constraint_terms_batch.len() == n * num_gate_constraints);
let num_challenges = common_data.config.num_challenges; let num_challenges = common_data.config.num_challenges;
@ -210,7 +211,7 @@ pub fn evaluate_gate_constraints<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
vars: EvaluationVars<F, D>, vars: EvaluationVars<F, D>,
) -> Vec<F::Extension> { ) -> Vec<F::Extension> {
let mut constraints = vec![F::Extension::ZERO; common_data.num_gate_constraints]; let mut constraints = vec![F::Extension::ZERO; common_data.num_gate_constraints];
@ -244,7 +245,7 @@ pub fn evaluate_gate_constraints_base_batch<
C: GenericConfig<D, F = F>, C: GenericConfig<D, F = F>,
const D: usize, const D: usize,
>( >(
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
vars_batch: EvaluationVarsBaseBatch<F>, vars_batch: EvaluationVarsBaseBatch<F>,
) -> Vec<F> { ) -> Vec<F> {
let mut constraints_batch = vec![F::ZERO; common_data.num_gate_constraints * vars_batch.len()]; let mut constraints_batch = vec![F::ZERO; common_data.num_gate_constraints * vars_batch.len()];
@ -276,7 +277,7 @@ pub fn evaluate_gate_constraints_circuit<
const D: usize, const D: usize,
>( >(
builder: &mut CircuitBuilder<F, D>, builder: &mut CircuitBuilder<F, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
vars: EvaluationTargets<D>, vars: EvaluationTargets<D>,
) -> Vec<ExtensionTarget<D>> { ) -> Vec<ExtensionTarget<D>> {
let mut all_gate_constraints = vec![builder.zero_extension(); common_data.num_gate_constraints]; let mut all_gate_constraints = vec![builder.zero_extension(); common_data.num_gate_constraints];
@ -311,7 +312,7 @@ pub(crate) fn eval_vanishing_poly_circuit<
const D: usize, const D: usize,
>( >(
builder: &mut CircuitBuilder<F, D>, builder: &mut CircuitBuilder<F, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
x: ExtensionTarget<D>, x: ExtensionTarget<D>,
x_pow_deg: ExtensionTarget<D>, x_pow_deg: ExtensionTarget<D>,
vars: EvaluationTargets<D>, vars: EvaluationTargets<D>,
@ -329,7 +330,7 @@ pub(crate) fn eval_vanishing_poly_circuit<
let constraint_terms = with_context!( let constraint_terms = with_context!(
builder, builder,
"evaluate gate constraints", "evaluate gate constraints",
evaluate_gate_constraints_circuit(builder, common_data, vars,) evaluate_gate_constraints_circuit::<F, C, D>(builder, common_data, vars,)
); );
// The L_0(x) (Z(x) - 1) vanishing terms. // The L_0(x) (Z(x) - 1) vanishing terms.

6
plonky2/src/plonk/verifier.rs
View File

@ -15,7 +15,7 @@ use crate::plonk::vars::EvaluationVars;
pub(crate) fn verify<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( pub(crate) fn verify<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
proof_with_pis: ProofWithPublicInputs<F, C, D>, proof_with_pis: ProofWithPublicInputs<F, C, D>,
verifier_data: &VerifierOnlyCircuitData<C, D>, verifier_data: &VerifierOnlyCircuitData<C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<()> ) -> Result<()>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,
@ -47,7 +47,7 @@ pub(crate) fn verify_with_challenges<
public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash, public_inputs_hash: <<C as GenericConfig<D>>::InnerHasher as Hasher<F>>::Hash,
challenges: ProofChallenges<F, D>, challenges: ProofChallenges<F, D>,
verifier_data: &VerifierOnlyCircuitData<C, D>, verifier_data: &VerifierOnlyCircuitData<C, D>,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<()> ) -> Result<()>
where where
[(); C::Hasher::HASH_SIZE]:, [(); C::Hasher::HASH_SIZE]:,
@ -65,7 +65,7 @@ where
let partial_products = &proof.openings.partial_products; let partial_products = &proof.openings.partial_products;
// Evaluate the vanishing polynomial at our challenge point, zeta. // Evaluate the vanishing polynomial at our challenge point, zeta.
let vanishing_polys_zeta = eval_vanishing_poly( let vanishing_polys_zeta = eval_vanishing_poly::<F, C, D>(
common_data, common_data,
challenges.plonk_zeta, challenges.plonk_zeta,
vars, vars,

36
plonky2/src/util/serialization.rs
View File

@ -165,7 +165,7 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<OpeningSet<F, D>> { ) -> Result<OpeningSet<F, D>> {
let config = &common_data.config; let config = &common_data.config;
let constants = self.read_field_ext_vec::<F, D>(common_data.num_constants)?; let constants = self.read_field_ext_vec::<F, D>(common_data.num_constants)?;
@ -233,7 +233,7 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<FriInitialTreeProof<F, C::Hasher>> { ) -> Result<FriInitialTreeProof<F, C::Hasher>> {
let config = &common_data.config; let config = &common_data.config;
let salt = salt_size(common_data.fri_params.hiding); let salt = salt_size(common_data.fri_params.hiding);
@ -312,12 +312,12 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<Vec<FriQueryRound<F, C::Hasher, D>>> { ) -> Result<Vec<FriQueryRound<F, C::Hasher, D>>> {
let config = &common_data.config; let config = &common_data.config;
let mut fqrs = Vec::with_capacity(config.fri_config.num_query_rounds); let mut fqrs = Vec::with_capacity(config.fri_config.num_query_rounds);
for _ in 0..config.fri_config.num_query_rounds { for _ in 0..config.fri_config.num_query_rounds {
let initial_trees_proof = self.read_fri_initial_proof(common_data)?; let initial_trees_proof = self.read_fri_initial_proof::<F, C, D>(common_data)?;
let steps = common_data let steps = common_data
.fri_params .fri_params
.reduction_arity_bits .reduction_arity_bits
@ -345,13 +345,13 @@ impl Buffer {
} }
fn read_fri_proof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( fn read_fri_proof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<FriProof<F, C::Hasher, D>> { ) -> Result<FriProof<F, C::Hasher, D>> {
let config = &common_data.config; let config = &common_data.config;
let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len()) let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len())
.map(|_| self.read_merkle_cap(config.fri_config.cap_height)) .map(|_| self.read_merkle_cap(config.fri_config.cap_height))
.collect::<Result<Vec<_>>>()?; .collect::<Result<Vec<_>>>()?;
let query_round_proofs = self.read_fri_query_rounds(common_data)?; let query_round_proofs = self.read_fri_query_rounds::<F, C, D>(common_data)?;
let final_poly = PolynomialCoeffs::new( let final_poly = PolynomialCoeffs::new(
self.read_field_ext_vec::<F, D>(common_data.fri_params.final_poly_len())?, self.read_field_ext_vec::<F, D>(common_data.fri_params.final_poly_len())?,
); );
@ -376,14 +376,14 @@ impl Buffer {
} }
pub fn read_proof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( pub fn read_proof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<Proof<F, C, D>> { ) -> Result<Proof<F, C, D>> {
let config = &common_data.config; let config = &common_data.config;
let wires_cap = self.read_merkle_cap(config.fri_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 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 quotient_polys_cap = self.read_merkle_cap(config.fri_config.cap_height)?;
let openings = self.read_opening_set(common_data)?; let openings = self.read_opening_set::<F, C, D>(common_data)?;
let opening_proof = self.read_fri_proof(common_data)?; let opening_proof = self.read_fri_proof::<F, C, D>(common_data)?;
Ok(Proof { Ok(Proof {
wires_cap, wires_cap,
@ -415,7 +415,7 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<ProofWithPublicInputs<F, C, D>> { ) -> Result<ProofWithPublicInputs<F, C, D>> {
let proof = self.read_proof(common_data)?; let proof = self.read_proof(common_data)?;
let public_inputs = self.read_field_vec( let public_inputs = self.read_field_vec(
@ -460,7 +460,7 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<CompressedFriQueryRounds<F, C::Hasher, D>> { ) -> Result<CompressedFriQueryRounds<F, C::Hasher, D>> {
let config = &common_data.config; let config = &common_data.config;
let original_indices = (0..config.fri_config.num_query_rounds) let original_indices = (0..config.fri_config.num_query_rounds)
@ -471,7 +471,7 @@ impl Buffer {
indices.dedup(); indices.dedup();
let mut pairs = Vec::new(); let mut pairs = Vec::new();
for &i in &indices { for &i in &indices {
pairs.push((i, self.read_fri_initial_proof(common_data)?)); pairs.push((i, self.read_fri_initial_proof::<F, C, D>(common_data)?));
} }
let initial_trees_proofs = HashMap::from_iter(pairs); let initial_trees_proofs = HashMap::from_iter(pairs);
@ -521,13 +521,13 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<CompressedFriProof<F, C::Hasher, D>> { ) -> Result<CompressedFriProof<F, C::Hasher, D>> {
let config = &common_data.config; let config = &common_data.config;
let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len()) let commit_phase_merkle_caps = (0..common_data.fri_params.reduction_arity_bits.len())
.map(|_| self.read_merkle_cap(config.fri_config.cap_height)) .map(|_| self.read_merkle_cap(config.fri_config.cap_height))
.collect::<Result<Vec<_>>>()?; .collect::<Result<Vec<_>>>()?;
let query_round_proofs = self.read_compressed_fri_query_rounds(common_data)?; let query_round_proofs = self.read_compressed_fri_query_rounds::<F, C, D>(common_data)?;
let final_poly = PolynomialCoeffs::new( let final_poly = PolynomialCoeffs::new(
self.read_field_ext_vec::<F, D>(common_data.fri_params.final_poly_len())?, self.read_field_ext_vec::<F, D>(common_data.fri_params.final_poly_len())?,
); );
@ -560,14 +560,14 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<CompressedProof<F, C, D>> { ) -> Result<CompressedProof<F, C, D>> {
let config = &common_data.config; let config = &common_data.config;
let wires_cap = self.read_merkle_cap(config.fri_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 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 quotient_polys_cap = self.read_merkle_cap(config.fri_config.cap_height)?;
let openings = self.read_opening_set(common_data)?; let openings = self.read_opening_set::<F, C, D>(common_data)?;
let opening_proof = self.read_compressed_fri_proof(common_data)?; let opening_proof = self.read_compressed_fri_proof::<F, C, D>(common_data)?;
Ok(CompressedProof { Ok(CompressedProof {
wires_cap, wires_cap,
@ -599,7 +599,7 @@ impl Buffer {
const D: usize, const D: usize,
>( >(
&mut self, &mut self,
common_data: &CommonCircuitData<F, C, D>, common_data: &CommonCircuitData<F, D>,
) -> Result<CompressedProofWithPublicInputs<F, C, D>> { ) -> Result<CompressedProofWithPublicInputs<F, C, D>> {
let proof = self.read_compressed_proof(common_data)?; let proof = self.read_compressed_proof(common_data)?;
let public_inputs = self.read_field_vec( let public_inputs = self.read_field_vec(