From 8f212d31ef3e3d8180db1811a2c1025a55cfb6ed Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 1 Oct 2021 14:59:16 +0200 Subject: [PATCH 1/8] Working custom (de)serializer --- src/gadgets/arithmetic_extension.rs | 10 +- src/plonk/recursive_verifier.rs | 8 + src/util/mod.rs | 1 + src/util/serialization.rs | 357 ++++++++++++++++++++++++++++ 4 files changed, 375 insertions(+), 1 deletion(-) create mode 100644 src/util/serialization.rs diff --git a/src/gadgets/arithmetic_extension.rs b/src/gadgets/arithmetic_extension.rs index af838ab6..de608be5 100644 --- a/src/gadgets/arithmetic_extension.rs +++ b/src/gadgets/arithmetic_extension.rs @@ -510,6 +510,7 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::verifier::verify; + use crate::util::serialization::Buffer; #[test] fn test_mul_many() -> Result<()> { @@ -583,7 +584,7 @@ mod tests { let config = CircuitConfig::large_config(); let pw = PartialWitness::new(); - let mut builder = CircuitBuilder::::new(config); + let mut builder = CircuitBuilder::::new(config.clone()); let x = FF::rand_vec(4); let y = FF::rand_vec(4); @@ -602,6 +603,13 @@ mod tests { let data = builder.build(); let proof = data.prove(pw)?; + let mut buffer = Buffer::new(Vec::new()); + buffer.write_proof(&proof.proof).unwrap(); + dbg!(buffer.len()); + let mut buffer = Buffer::new(buffer.bytes()); + let oproof = buffer.read_proof(&data.common, &config).unwrap(); + assert_eq!(proof.proof, oproof); + verify(proof, &data.verifier_only, &data.common) } } diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index 75158d67..7babb26f 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -139,6 +139,7 @@ mod tests { use crate::plonk::proof::{OpeningSetTarget, Proof, ProofTarget, ProofWithPublicInputs}; use crate::plonk::verifier::verify; use crate::util::log2_strict; + use crate::util::serialization::Buffer; // Construct a `FriQueryRoundTarget` with the same dimensions as the ones in `proof`. fn get_fri_query_round, const D: usize>( @@ -480,6 +481,13 @@ mod tests { builder.print_gate_counts(0); let data = builder.build(); let recursive_proof = data.prove(pw)?; + let mut buffer = Buffer::new(Vec::new()); + buffer.write_proof(&recursive_proof.proof).unwrap(); + dbg!(recursive_proof.public_inputs.len()); + dbg!(buffer.len()); + let mut buffer = Buffer::new(buffer.bytes()); + let proof = buffer.read_proof(&data.common, &config).unwrap(); + assert_eq!(recursive_proof.proof, proof); let now = std::time::Instant::now(); let compressed_recursive_proof = recursive_proof.clone().compress(&data.common)?; info!("{:.4} to compress proof", now.elapsed().as_secs_f64()); diff --git a/src/util/mod.rs b/src/util/mod.rs index daa6716b..d8e05a18 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -6,6 +6,7 @@ pub(crate) mod context_tree; pub(crate) mod marking; pub(crate) mod partial_products; pub mod reducing; +pub mod serialization; pub(crate) mod timing; pub(crate) fn bits_u64(n: u64) -> usize { diff --git a/src/util/serialization.rs b/src/util/serialization.rs new file mode 100644 index 00000000..5a32becb --- /dev/null +++ b/src/util/serialization.rs @@ -0,0 +1,357 @@ +use std::convert::TryInto; +use std::fmt; +use std::io::Cursor; +use std::io::{Error, ErrorKind, Read, Result, Write}; + +use crate::field::crandall_field::CrandallField; +use crate::field::extension_field::quartic::QuarticExtension; +use crate::field::extension_field::{Extendable, FieldExtension}; +use crate::field::field_types::{Field, PrimeField, RichField}; +use crate::fri::proof::{FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep}; +use crate::hash::hash_types::HashOut; +use crate::hash::merkle_proofs::MerkleProof; +use crate::hash::merkle_tree::{MerkleCap, MerkleTree}; +use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; +use crate::plonk::proof::{OpeningSet, Proof}; +use crate::polynomial::polynomial::PolynomialCoeffs; + +#[derive(Debug)] +pub struct Buffer(Cursor>); + +impl Buffer { + pub fn new(buffer: Vec) -> Self { + Self(Cursor::new(buffer)) + } + + pub fn len(&self) -> usize { + self.0.get_ref().len() + } + + pub fn bytes(self) -> Vec { + self.0.into_inner() + } + + pub fn write_u8(&mut self, x: u8) -> Result<()> { + self.0.write_all(&[x]) + } + pub fn read_u8(&mut self) -> Result { + let mut buf = [0; 1]; + self.0.read_exact(&mut buf)?; + Ok(buf[0]) + } + + pub fn write_field(&mut self, x: F) -> Result<()> { + self.0.write_all(&x.to_canonical_u64().to_le_bytes()) + } + pub fn read_field(&mut self) -> Result { + let mut buf = [0; std::mem::size_of::()]; + self.0.read_exact(&mut buf)?; + Ok(F::from_canonical_u64(u64::from_le_bytes( + buf.try_into().unwrap(), + ))) + } + + pub fn write_field_ext, const D: usize>( + &mut self, + x: F::Extension, + ) -> Result<()> { + for &a in &x.to_basefield_array() { + self.write_field(a)?; + } + Ok(()) + } + pub fn read_field_ext, const D: usize>(&mut self) -> Result { + let mut arr = [F::ZERO; D]; + for a in arr.iter_mut() { + *a = self.read_field()?; + } + Ok(>::from_basefield_array( + arr, + )) + } + + pub fn write_hash(&mut self, h: HashOut) -> Result<()> { + for &a in &h.elements { + self.write_field(a)?; + } + Ok(()) + } + pub fn read_hash(&mut self) -> Result> { + let mut elements = [F::ZERO; 4]; + for a in elements.iter_mut() { + *a = self.read_field()?; + } + Ok(HashOut { elements }) + } + + pub fn write_merkle_cap(&mut self, cap: &MerkleCap) -> Result<()> { + for &a in &cap.0 { + self.write_hash(a)?; + } + Ok(()) + } + pub fn read_merkle_cap(&mut self, cap_height: usize) -> Result> { + let cap_length = 1 << cap_height; + Ok(MerkleCap( + (0..cap_length) + .map(|_| self.read_hash()) + .collect::>>()?, + )) + } + + pub fn write_field_vec(&mut self, v: &[F]) -> Result<()> { + for &a in v { + self.write_field(a)?; + } + Ok(()) + } + pub fn read_field_vec(&mut self, length: usize) -> Result> { + Ok((0..length) + .map(|_| self.read_field()) + .collect::>>()?) + } + + pub fn write_field_ext_vec, const D: usize>( + &mut self, + v: &[F::Extension], + ) -> Result<()> { + for &a in v { + self.write_field_ext::(a)?; + } + Ok(()) + } + pub fn read_field_ext_vec, const D: usize>( + &mut self, + length: usize, + ) -> Result> { + Ok((0..length) + .map(|_| self.read_field_ext::()) + .collect::>>()?) + } + + pub fn write_opening_set, const D: usize>( + &mut self, + os: &OpeningSet, + ) -> Result<()> { + self.write_field_ext_vec::(&os.constants)?; + self.write_field_ext_vec::(&os.plonk_sigmas)?; + self.write_field_ext_vec::(&os.wires)?; + self.write_field_ext_vec::(&os.plonk_zs)?; + self.write_field_ext_vec::(&os.plonk_zs_right)?; + self.write_field_ext_vec::(&os.partial_products)?; + self.write_field_ext_vec::(&os.quotient_polys) + } + pub fn read_opening_set, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let constants = self.read_field_ext_vec::(common_data.num_constants)?; + let plonk_sigmas = self.read_field_ext_vec::(config.num_routed_wires)?; + let wires = self.read_field_ext_vec::(config.num_wires)?; + let plonk_zs = self.read_field_ext_vec::(config.num_challenges)?; + let plonk_zs_right = self.read_field_ext_vec::(config.num_challenges)?; + let partial_products = self.read_field_ext_vec::( + common_data.num_partial_products.0 * config.num_challenges, + )?; + let quotient_polys = self.read_field_ext_vec::( + common_data.quotient_degree_factor * config.num_challenges, + )?; + Ok(OpeningSet { + constants, + plonk_sigmas, + wires, + plonk_zs, + plonk_zs_right, + partial_products, + quotient_polys, + }) + } + + pub fn write_merkle_proof(&mut self, p: &MerkleProof) -> Result<()> { + let length = p.siblings.len(); + self.write_u8( + length + .try_into() + .expect("Merkle proof length must fit in u8."), + ); + for &h in &p.siblings { + self.write_hash(h)?; + } + Ok(()) + } + pub fn read_merkle_proof(&mut self) -> Result> { + let length = self.read_u8()?; + Ok(MerkleProof { + siblings: (0..length) + .map(|_| self.read_hash()) + .collect::>>()?, + }) + } + + pub fn write_fri_initial_proof( + &mut self, + fitp: &FriInitialTreeProof, + ) -> Result<()> { + for (v, p) in &fitp.evals_proofs { + self.write_field_vec(v)?; + self.write_merkle_proof(p)?; + } + Ok(()) + } + pub fn read_fri_initial_proof, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let mut evals_proofs = Vec::with_capacity(4); + + let constants_sigmas_v = + self.read_field_vec(common_data.num_constants + config.num_routed_wires)?; + let constants_sigmas_p = self.read_merkle_proof()?; + evals_proofs.push((constants_sigmas_v, constants_sigmas_p)); + + let wires_v = self.read_field_vec(config.num_wires)?; + let wires_p = self.read_merkle_proof()?; + evals_proofs.push((wires_v, wires_p)); + + let zs_partial_v = + self.read_field_vec(config.num_challenges * (1 + common_data.num_partial_products.0))?; + let zs_partial_p = self.read_merkle_proof()?; + evals_proofs.push((zs_partial_v, zs_partial_p)); + + let quotient_v = + self.read_field_vec(config.num_challenges * common_data.quotient_degree_factor)?; + let quotient_p = self.read_merkle_proof()?; + evals_proofs.push((quotient_v, quotient_p)); + + Ok(FriInitialTreeProof { evals_proofs }) + } + + pub fn write_fri_query_steps, const D: usize>( + &mut self, + fqss: &[FriQueryStep], + ) -> Result<()> { + for fqs in fqss { + self.write_field_ext_vec::(&fqs.evals)?; + self.write_merkle_proof(&fqs.merkle_proof)?; + } + Ok(()) + } + pub fn read_fri_query_steps, const D: usize>( + &mut self, + config: &CircuitConfig, + ) -> Result>> { + let mut fqss = Vec::with_capacity(config.fri_config.reduction_arity_bits.len()); + for &arity_bits in &config.fri_config.reduction_arity_bits { + let evals = self.read_field_ext_vec::(1 << arity_bits)?; + let merkle_proof = self.read_merkle_proof()?; + fqss.push(FriQueryStep { + evals, + merkle_proof, + }) + } + Ok(fqss) + } + + pub fn write_fri_query_rounds, const D: usize>( + &mut self, + fqrs: &[FriQueryRound], + ) -> Result<()> { + for fqr in fqrs { + self.write_fri_initial_proof(&fqr.initial_trees_proof)?; + self.write_fri_query_steps(&fqr.steps)?; + } + Ok(()) + } + pub fn read_fri_query_rounds, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result>> { + let mut fqrs = Vec::with_capacity(config.fri_config.num_query_rounds); + for i in 0..config.fri_config.num_query_rounds { + let initial_trees_proof = self.read_fri_initial_proof(common_data, config)?; + let steps = self.read_fri_query_steps(config)?; + fqrs.push(FriQueryRound { + initial_trees_proof, + steps, + }) + } + Ok(fqrs) + } + + pub fn write_fri_proof, const D: usize>( + &mut self, + fp: &FriProof, + ) -> Result<()> { + for cap in &fp.commit_phase_merkle_caps { + self.write_merkle_cap(cap)?; + } + self.write_fri_query_rounds(&fp.query_round_proofs)?; + self.write_field_ext_vec::(&fp.final_poly.coeffs)?; + self.write_field(fp.pow_witness) + } + pub fn read_fri_proof, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let commit_phase_merkle_caps = (0..config.fri_config.reduction_arity_bits.len()) + .map(|_| self.read_merkle_cap(config.cap_height)) + .collect::>>()?; + let query_round_proofs = self.read_fri_query_rounds(common_data, config)?; + let final_poly = PolynomialCoeffs::new(self.read_field_ext_vec::( + 1 << (common_data.degree_bits + - config.fri_config.reduction_arity_bits.iter().sum::()), + )?); + let pow_witness = self.read_field()?; + Ok(FriProof { + commit_phase_merkle_caps, + query_round_proofs, + final_poly, + pow_witness, + }) + } + + pub fn write_proof, const D: usize>( + &mut self, + proof: &Proof, + ) -> Result<()> { + self.write_merkle_cap(&proof.wires_cap)?; + self.write_merkle_cap(&proof.plonk_zs_partial_products_cap)?; + self.write_merkle_cap(&proof.quotient_polys_cap)?; + self.write_opening_set(&proof.openings)?; + self.write_fri_proof(&proof.opening_proof) + } + pub fn read_proof, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + 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 openings = self.read_opening_set(common_data, config)?; + let opening_proof = self.read_fri_proof(common_data, config)?; + + Ok(Proof { + wires_cap, + plonk_zs_partial_products_cap, + quotient_polys_cap, + openings, + opening_proof, + }) + } +} + +#[test] +fn yo() { + type F = CrandallField; + type FF = QuarticExtension; + let mut buffer = Buffer::new(Vec::new()); + let x = FF::rand(); + buffer.write_field_ext::(x).unwrap(); + let mut buffer = Buffer::new(buffer.0.into_inner()); + let y: FF = buffer.read_field_ext::().unwrap(); +} From fb585064a9d311b4cfddf7b7723fbe0367b3419b Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 1 Oct 2021 16:54:14 +0200 Subject: [PATCH 2/8] (De)Serializer for CompressedProof --- src/fri/proof.rs | 3 + src/plonk/proof.rs | 35 +++- src/plonk/recursive_verifier.rs | 27 +-- src/util/serialization.rs | 300 ++++++++++++++++++++++++++------ 4 files changed, 301 insertions(+), 64 deletions(-) diff --git a/src/fri/proof.rs b/src/fri/proof.rs index 44cef3dc..f0d13ebe 100644 --- a/src/fri/proof.rs +++ b/src/fri/proof.rs @@ -83,6 +83,8 @@ pub struct FriQueryRoundTarget { #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)] #[serde(bound = "")] pub struct CompressedFriQueryRounds, const D: usize> { + /// Query indices. + pub indices: Vec, /// Map from initial indices `i` to the `FriInitialProof` for the `i`th leaf. pub initial_trees_proofs: HashMap>, /// For each FRI query step, a map from initial indices `i` to the `FriInitialProof` for the `i`th leaf. @@ -182,6 +184,7 @@ impl, const D: usize> FriProof { .collect::>(); let mut compressed_query_proofs = CompressedFriQueryRounds { + indices: indices.to_vec(), initial_trees_proofs: HashMap::new(), steps: vec![HashMap::new(); num_reductions], }; diff --git a/src/plonk/proof.rs b/src/plonk/proof.rs index c7d0b0ff..4c9bfc65 100644 --- a/src/plonk/proof.rs +++ b/src/plonk/proof.rs @@ -10,7 +10,8 @@ use crate::hash::hash_types::{HashOut, MerkleCapTarget}; use crate::hash::hashing::hash_n_to_hash; use crate::hash::merkle_tree::MerkleCap; use crate::iop::target::Target; -use crate::plonk::circuit_data::CommonCircuitData; +use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; +use crate::util::serialization::Buffer; #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)] #[serde(bound = "")] @@ -83,6 +84,22 @@ impl, const D: usize> ProofWithPublicInputs { pub(crate) fn get_public_inputs_hash(&self) -> HashOut { hash_n_to_hash(self.public_inputs.clone(), true) } + + pub fn to_bytes(&self) -> anyhow::Result> { + let mut buffer = Buffer::new(Vec::new()); + buffer.write_proof_with_public_inputs(&self)?; + Ok(buffer.bytes()) + } + + pub fn from_bytes( + bytes: Vec, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> anyhow::Result { + let mut buffer = Buffer::new(bytes); + let proof = buffer.read_proof_with_public_inputs(common_data, config)?; + Ok(proof) + } } #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)] @@ -148,6 +165,22 @@ impl, const D: usize> CompressedProofWithPublicInpu pub(crate) fn get_public_inputs_hash(&self) -> HashOut { hash_n_to_hash(self.public_inputs.clone(), true) } + + pub fn to_bytes(&self) -> anyhow::Result> { + let mut buffer = Buffer::new(Vec::new()); + buffer.write_compressed_proof_with_public_inputs(&self)?; + Ok(buffer.bytes()) + } + + pub fn from_bytes( + bytes: Vec, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> anyhow::Result { + let mut buffer = Buffer::new(bytes); + let proof = buffer.read_compressed_proof_with_public_inputs(common_data, config)?; + Ok(proof) + } } pub(crate) struct ProofChallenges, const D: usize> { diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index 7babb26f..a2351700 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -136,7 +136,10 @@ mod tests { use crate::gadgets::polynomial::PolynomialCoeffsExtTarget; use crate::hash::merkle_proofs::MerkleProofTarget; use crate::iop::witness::{PartialWitness, Witness}; - use crate::plonk::proof::{OpeningSetTarget, Proof, ProofTarget, ProofWithPublicInputs}; + use crate::plonk::proof::{ + CompressedProofWithPublicInputs, OpeningSetTarget, Proof, ProofTarget, + ProofWithPublicInputs, + }; use crate::plonk::verifier::verify; use crate::util::log2_strict; use crate::util::serialization::Buffer; @@ -481,23 +484,25 @@ mod tests { builder.print_gate_counts(0); let data = builder.build(); let recursive_proof = data.prove(pw)?; - let mut buffer = Buffer::new(Vec::new()); - buffer.write_proof(&recursive_proof.proof).unwrap(); - dbg!(recursive_proof.public_inputs.len()); - dbg!(buffer.len()); - let mut buffer = Buffer::new(buffer.bytes()); - let proof = buffer.read_proof(&data.common, &config).unwrap(); - assert_eq!(recursive_proof.proof, proof); + let proof_bytes = recursive_proof.to_bytes()?; + info!("Proof length: {} bytes", proof_bytes.len()); + let proof_from_bytes = + ProofWithPublicInputs::from_bytes(proof_bytes, &data.common, &config)?; + assert_eq!(recursive_proof, proof_from_bytes); let now = std::time::Instant::now(); let compressed_recursive_proof = recursive_proof.clone().compress(&data.common)?; info!("{:.4} to compress proof", now.elapsed().as_secs_f64()); - let proof_bytes = serde_cbor::to_vec(&recursive_proof).unwrap(); - info!("Proof length: {} bytes", proof_bytes.len()); - let compressed_proof_bytes = serde_cbor::to_vec(&compressed_recursive_proof).unwrap(); + let compressed_proof_bytes = compressed_recursive_proof.to_bytes()?; info!( "Compressed proof length: {} bytes", compressed_proof_bytes.len() ); + let compressed_proof_from_bytes = CompressedProofWithPublicInputs::from_bytes( + compressed_proof_bytes, + &data.common, + &config, + )?; + assert_eq!(compressed_recursive_proof, compressed_proof_from_bytes); verify(recursive_proof, &data.verifier_only, &data.common) } } diff --git a/src/util/serialization.rs b/src/util/serialization.rs index 5a32becb..2c6a1d68 100644 --- a/src/util/serialization.rs +++ b/src/util/serialization.rs @@ -1,18 +1,25 @@ +use std::collections::HashMap; use std::convert::TryInto; use std::fmt; use std::io::Cursor; use std::io::{Error, ErrorKind, Read, Result, Write}; +use std::iter::FromIterator; use crate::field::crandall_field::CrandallField; use crate::field::extension_field::quartic::QuarticExtension; use crate::field::extension_field::{Extendable, FieldExtension}; use crate::field::field_types::{Field, PrimeField, RichField}; -use crate::fri::proof::{FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep}; +use crate::fri::proof::{ + CompressedFriProof, CompressedFriQueryRounds, FriInitialTreeProof, FriProof, FriQueryRound, + FriQueryStep, +}; use crate::hash::hash_types::HashOut; use crate::hash::merkle_proofs::MerkleProof; use crate::hash::merkle_tree::{MerkleCap, MerkleTree}; use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; -use crate::plonk::proof::{OpeningSet, Proof}; +use crate::plonk::proof::{ + CompressedProof, CompressedProofWithPublicInputs, OpeningSet, Proof, ProofWithPublicInputs, +}; use crate::polynomial::polynomial::PolynomialCoeffs; #[derive(Debug)] @@ -31,19 +38,28 @@ impl Buffer { self.0.into_inner() } - pub fn write_u8(&mut self, x: u8) -> Result<()> { + fn write_u8(&mut self, x: u8) -> Result<()> { self.0.write_all(&[x]) } - pub fn read_u8(&mut self) -> Result { - let mut buf = [0; 1]; + fn read_u8(&mut self) -> Result { + let mut buf = [0; std::mem::size_of::()]; self.0.read_exact(&mut buf)?; Ok(buf[0]) } - pub fn write_field(&mut self, x: F) -> Result<()> { + fn write_u32(&mut self, x: u32) -> Result<()> { + self.0.write_all(&x.to_le_bytes()) + } + fn read_u32(&mut self) -> Result { + let mut buf = [0; std::mem::size_of::()]; + self.0.read_exact(&mut buf)?; + Ok(u32::from_le_bytes(buf)) + } + + fn write_field(&mut self, x: F) -> Result<()> { self.0.write_all(&x.to_canonical_u64().to_le_bytes()) } - pub fn read_field(&mut self) -> Result { + fn read_field(&mut self) -> Result { let mut buf = [0; std::mem::size_of::()]; self.0.read_exact(&mut buf)?; Ok(F::from_canonical_u64(u64::from_le_bytes( @@ -51,16 +67,13 @@ impl Buffer { ))) } - pub fn write_field_ext, const D: usize>( - &mut self, - x: F::Extension, - ) -> Result<()> { + fn write_field_ext, const D: usize>(&mut self, x: F::Extension) -> Result<()> { for &a in &x.to_basefield_array() { self.write_field(a)?; } Ok(()) } - pub fn read_field_ext, const D: usize>(&mut self) -> Result { + fn read_field_ext, const D: usize>(&mut self) -> Result { let mut arr = [F::ZERO; D]; for a in arr.iter_mut() { *a = self.read_field()?; @@ -70,13 +83,13 @@ impl Buffer { )) } - pub fn write_hash(&mut self, h: HashOut) -> Result<()> { + fn write_hash(&mut self, h: HashOut) -> Result<()> { for &a in &h.elements { self.write_field(a)?; } Ok(()) } - pub fn read_hash(&mut self) -> Result> { + fn read_hash(&mut self) -> Result> { let mut elements = [F::ZERO; 4]; for a in elements.iter_mut() { *a = self.read_field()?; @@ -84,13 +97,13 @@ impl Buffer { Ok(HashOut { elements }) } - pub fn write_merkle_cap(&mut self, cap: &MerkleCap) -> Result<()> { + fn write_merkle_cap(&mut self, cap: &MerkleCap) -> Result<()> { for &a in &cap.0 { self.write_hash(a)?; } Ok(()) } - pub fn read_merkle_cap(&mut self, cap_height: usize) -> Result> { + fn read_merkle_cap(&mut self, cap_height: usize) -> Result> { let cap_length = 1 << cap_height; Ok(MerkleCap( (0..cap_length) @@ -99,19 +112,19 @@ impl Buffer { )) } - pub fn write_field_vec(&mut self, v: &[F]) -> Result<()> { + fn write_field_vec(&mut self, v: &[F]) -> Result<()> { for &a in v { self.write_field(a)?; } Ok(()) } - pub fn read_field_vec(&mut self, length: usize) -> Result> { + fn read_field_vec(&mut self, length: usize) -> Result> { Ok((0..length) .map(|_| self.read_field()) .collect::>>()?) } - pub fn write_field_ext_vec, const D: usize>( + fn write_field_ext_vec, const D: usize>( &mut self, v: &[F::Extension], ) -> Result<()> { @@ -120,7 +133,7 @@ impl Buffer { } Ok(()) } - pub fn read_field_ext_vec, const D: usize>( + fn read_field_ext_vec, const D: usize>( &mut self, length: usize, ) -> Result> { @@ -129,7 +142,7 @@ impl Buffer { .collect::>>()?) } - pub fn write_opening_set, const D: usize>( + fn write_opening_set, const D: usize>( &mut self, os: &OpeningSet, ) -> Result<()> { @@ -141,7 +154,7 @@ impl Buffer { self.write_field_ext_vec::(&os.partial_products)?; self.write_field_ext_vec::(&os.quotient_polys) } - pub fn read_opening_set, const D: usize>( + fn read_opening_set, const D: usize>( &mut self, common_data: &CommonCircuitData, config: &CircuitConfig, @@ -168,7 +181,7 @@ impl Buffer { }) } - pub fn write_merkle_proof(&mut self, p: &MerkleProof) -> Result<()> { + fn write_merkle_proof(&mut self, p: &MerkleProof) -> Result<()> { let length = p.siblings.len(); self.write_u8( length @@ -180,7 +193,7 @@ impl Buffer { } Ok(()) } - pub fn read_merkle_proof(&mut self) -> Result> { + fn read_merkle_proof(&mut self) -> Result> { let length = self.read_u8()?; Ok(MerkleProof { siblings: (0..length) @@ -189,7 +202,7 @@ impl Buffer { }) } - pub fn write_fri_initial_proof( + fn write_fri_initial_proof( &mut self, fitp: &FriInitialTreeProof, ) -> Result<()> { @@ -199,7 +212,7 @@ impl Buffer { } Ok(()) } - pub fn read_fri_initial_proof, const D: usize>( + fn read_fri_initial_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, config: &CircuitConfig, @@ -228,43 +241,38 @@ impl Buffer { Ok(FriInitialTreeProof { evals_proofs }) } - pub fn write_fri_query_steps, const D: usize>( + fn write_fri_query_step, const D: usize>( &mut self, - fqss: &[FriQueryStep], + fqs: &FriQueryStep, ) -> Result<()> { - for fqs in fqss { - self.write_field_ext_vec::(&fqs.evals)?; - self.write_merkle_proof(&fqs.merkle_proof)?; - } - Ok(()) + self.write_field_ext_vec::(&fqs.evals)?; + self.write_merkle_proof(&fqs.merkle_proof) } - pub fn read_fri_query_steps, const D: usize>( + fn read_fri_query_step, const D: usize>( &mut self, - config: &CircuitConfig, - ) -> Result>> { - let mut fqss = Vec::with_capacity(config.fri_config.reduction_arity_bits.len()); - for &arity_bits in &config.fri_config.reduction_arity_bits { - let evals = self.read_field_ext_vec::(1 << arity_bits)?; - let merkle_proof = self.read_merkle_proof()?; - fqss.push(FriQueryStep { - evals, - merkle_proof, - }) - } - Ok(fqss) + arity: usize, + ) -> Result> { + let evals = self.read_field_ext_vec::(arity)?; + let merkle_proof = self.read_merkle_proof()?; + Ok(FriQueryStep { + evals, + merkle_proof, + }) } - pub fn write_fri_query_rounds, const D: usize>( + fn write_fri_query_rounds, const D: usize>( &mut self, fqrs: &[FriQueryRound], ) -> Result<()> { for fqr in fqrs { self.write_fri_initial_proof(&fqr.initial_trees_proof)?; - self.write_fri_query_steps(&fqr.steps)?; + for fqs in &fqr.steps { + self.write_fri_query_step(fqs)?; + } } Ok(()) } - pub fn read_fri_query_rounds, const D: usize>( + fn read_fri_query_rounds, const D: usize>( &mut self, common_data: &CommonCircuitData, config: &CircuitConfig, @@ -272,7 +280,12 @@ impl Buffer { let mut fqrs = Vec::with_capacity(config.fri_config.num_query_rounds); for i in 0..config.fri_config.num_query_rounds { let initial_trees_proof = self.read_fri_initial_proof(common_data, config)?; - let steps = self.read_fri_query_steps(config)?; + let steps = config + .fri_config + .reduction_arity_bits + .iter() + .map(|&ar| self.read_fri_query_step(1 << ar)) + .collect::>()?; fqrs.push(FriQueryRound { initial_trees_proof, steps, @@ -281,7 +294,7 @@ impl Buffer { Ok(fqrs) } - pub fn write_fri_proof, const D: usize>( + fn write_fri_proof, const D: usize>( &mut self, fp: &FriProof, ) -> Result<()> { @@ -292,7 +305,7 @@ impl Buffer { self.write_field_ext_vec::(&fp.final_poly.coeffs)?; self.write_field(fp.pow_witness) } - pub fn read_fri_proof, const D: usize>( + fn read_fri_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, config: &CircuitConfig, @@ -343,6 +356,189 @@ impl Buffer { opening_proof, }) } + + pub fn write_proof_with_public_inputs, const D: usize>( + &mut self, + proof_with_pis: &ProofWithPublicInputs, + ) -> Result<()> { + let ProofWithPublicInputs { + proof, + public_inputs, + } = proof_with_pis; + self.write_proof(proof)?; + self.write_field_vec(public_inputs) + } + pub fn read_proof_with_public_inputs, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let proof = self.read_proof(common_data, config)?; + let public_inputs = self.read_field_vec(self.len() - self.0.position() as usize)?; + + Ok(ProofWithPublicInputs { + proof, + public_inputs, + }) + } + + fn write_compressed_fri_query_rounds, const D: usize>( + &mut self, + cfqrs: &CompressedFriQueryRounds, + ) -> Result<()> { + for &i in &cfqrs.indices { + self.write_u32(i as u32)?; + } + + let mut initial_trees_proofs = cfqrs.initial_trees_proofs.iter().collect::>(); + initial_trees_proofs.sort_by_key(|&x| x.0); + for (_, itp) in initial_trees_proofs { + self.write_fri_initial_proof(itp)?; + } + for h in &cfqrs.steps { + let mut fri_query_steps = h.iter().collect::>(); + fri_query_steps.sort_by_key(|&x| x.0); + for (_, fqs) in fri_query_steps { + self.write_fri_query_step(fqs)?; + } + } + Ok(()) + } + fn read_compressed_fri_query_rounds, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let original_indices = (0..config.fri_config.num_query_rounds) + .map(|_| self.read_u32().map(|i| i as usize)) + .collect::>>()?; + let mut indices = original_indices.clone(); + indices.sort(); + indices.dedup(); + let mut pairs = Vec::new(); + for &i in &indices { + pairs.push((i, self.read_fri_initial_proof(common_data, config)?)); + } + let initial_trees_proofs = HashMap::from_iter(pairs); + + let mut steps = Vec::with_capacity(config.fri_config.reduction_arity_bits.len()); + for &a in &config.fri_config.reduction_arity_bits { + indices.iter_mut().for_each(|x| { + *x >>= a; + }); + indices.dedup(); + let query_steps = (0..indices.len()) + .map(|_| self.read_fri_query_step(1 << a)) + .collect::>>()?; + steps.push( + indices + .iter() + .copied() + .zip(query_steps) + .collect::>(), + ); + } + + Ok(CompressedFriQueryRounds { + indices: original_indices, + initial_trees_proofs, + steps, + }) + } + + fn write_compressed_fri_proof, const D: usize>( + &mut self, + fp: &CompressedFriProof, + ) -> Result<()> { + for cap in &fp.commit_phase_merkle_caps { + self.write_merkle_cap(cap)?; + } + self.write_compressed_fri_query_rounds(&fp.query_round_proofs)?; + self.write_field_ext_vec::(&fp.final_poly.coeffs)?; + self.write_field(fp.pow_witness) + } + fn read_compressed_fri_proof, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let commit_phase_merkle_caps = (0..config.fri_config.reduction_arity_bits.len()) + .map(|_| self.read_merkle_cap(config.cap_height)) + .collect::>>()?; + let query_round_proofs = self.read_compressed_fri_query_rounds(common_data, config)?; + let final_poly = PolynomialCoeffs::new(self.read_field_ext_vec::( + 1 << (common_data.degree_bits + - config.fri_config.reduction_arity_bits.iter().sum::()), + )?); + let pow_witness = self.read_field()?; + Ok(CompressedFriProof { + commit_phase_merkle_caps, + query_round_proofs, + final_poly, + pow_witness, + }) + } + + pub fn write_compressed_proof, const D: usize>( + &mut self, + proof: &CompressedProof, + ) -> Result<()> { + self.write_merkle_cap(&proof.wires_cap)?; + self.write_merkle_cap(&proof.plonk_zs_partial_products_cap)?; + self.write_merkle_cap(&proof.quotient_polys_cap)?; + self.write_opening_set(&proof.openings)?; + self.write_compressed_fri_proof(&proof.opening_proof) + } + pub fn read_compressed_proof, const D: usize>( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + 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 openings = self.read_opening_set(common_data, config)?; + let opening_proof = self.read_compressed_fri_proof(common_data, config)?; + + Ok(CompressedProof { + wires_cap, + plonk_zs_partial_products_cap, + quotient_polys_cap, + openings, + opening_proof, + }) + } + + pub fn write_compressed_proof_with_public_inputs< + F: RichField + Extendable, + const D: usize, + >( + &mut self, + proof_with_pis: &CompressedProofWithPublicInputs, + ) -> Result<()> { + let CompressedProofWithPublicInputs { + proof, + public_inputs, + } = proof_with_pis; + self.write_compressed_proof(proof)?; + self.write_field_vec(public_inputs) + } + pub fn read_compressed_proof_with_public_inputs< + F: RichField + Extendable, + const D: usize, + >( + &mut self, + common_data: &CommonCircuitData, + config: &CircuitConfig, + ) -> Result> { + let proof = self.read_compressed_proof(common_data, config)?; + let public_inputs = self.read_field_vec(self.len() - self.0.position() as usize)?; + + Ok(CompressedProofWithPublicInputs { + proof, + public_inputs, + }) + } } #[test] From 5dcb85e08515ba946fc3755304e258c83256ef7b Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 1 Oct 2021 16:58:55 +0200 Subject: [PATCH 3/8] Minor --- src/gadgets/arithmetic_extension.rs | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/gadgets/arithmetic_extension.rs b/src/gadgets/arithmetic_extension.rs index de608be5..af838ab6 100644 --- a/src/gadgets/arithmetic_extension.rs +++ b/src/gadgets/arithmetic_extension.rs @@ -510,7 +510,6 @@ mod tests { use crate::plonk::circuit_builder::CircuitBuilder; use crate::plonk::circuit_data::CircuitConfig; use crate::plonk::verifier::verify; - use crate::util::serialization::Buffer; #[test] fn test_mul_many() -> Result<()> { @@ -584,7 +583,7 @@ mod tests { let config = CircuitConfig::large_config(); let pw = PartialWitness::new(); - let mut builder = CircuitBuilder::::new(config.clone()); + let mut builder = CircuitBuilder::::new(config); let x = FF::rand_vec(4); let y = FF::rand_vec(4); @@ -603,13 +602,6 @@ mod tests { let data = builder.build(); let proof = data.prove(pw)?; - let mut buffer = Buffer::new(Vec::new()); - buffer.write_proof(&proof.proof).unwrap(); - dbg!(buffer.len()); - let mut buffer = Buffer::new(buffer.bytes()); - let oproof = buffer.read_proof(&data.common, &config).unwrap(); - assert_eq!(proof.proof, oproof); - verify(proof, &data.verifier_only, &data.common) } } From c2765960923c3b5020bb14418e21cbe4e8ae99e8 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 1 Oct 2021 17:05:55 +0200 Subject: [PATCH 4/8] Remove useless test --- src/util/serialization.rs | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/util/serialization.rs b/src/util/serialization.rs index 2c6a1d68..d83839d9 100644 --- a/src/util/serialization.rs +++ b/src/util/serialization.rs @@ -540,14 +540,3 @@ impl Buffer { }) } } - -#[test] -fn yo() { - type F = CrandallField; - type FF = QuarticExtension; - let mut buffer = Buffer::new(Vec::new()); - let x = FF::rand(); - buffer.write_field_ext::(x).unwrap(); - let mut buffer = Buffer::new(buffer.0.into_inner()); - let y: FF = buffer.read_field_ext::().unwrap(); -} From 17ed6a2b040ad299588c32a3e820261b6d380ba3 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 1 Oct 2021 17:12:46 +0200 Subject: [PATCH 5/8] Clippy --- src/plonk/proof.rs | 4 ++-- src/util/serialization.rs | 23 ++++++++++------------- 2 files changed, 12 insertions(+), 15 deletions(-) diff --git a/src/plonk/proof.rs b/src/plonk/proof.rs index 4c9bfc65..8ee20bc7 100644 --- a/src/plonk/proof.rs +++ b/src/plonk/proof.rs @@ -87,7 +87,7 @@ impl, const D: usize> ProofWithPublicInputs { pub fn to_bytes(&self) -> anyhow::Result> { let mut buffer = Buffer::new(Vec::new()); - buffer.write_proof_with_public_inputs(&self)?; + buffer.write_proof_with_public_inputs(self)?; Ok(buffer.bytes()) } @@ -168,7 +168,7 @@ impl, const D: usize> CompressedProofWithPublicInpu pub fn to_bytes(&self) -> anyhow::Result> { let mut buffer = Buffer::new(Vec::new()); - buffer.write_compressed_proof_with_public_inputs(&self)?; + buffer.write_compressed_proof_with_public_inputs(self)?; Ok(buffer.bytes()) } diff --git a/src/util/serialization.rs b/src/util/serialization.rs index d83839d9..bfc0473e 100644 --- a/src/util/serialization.rs +++ b/src/util/serialization.rs @@ -1,21 +1,18 @@ use std::collections::HashMap; use std::convert::TryInto; -use std::fmt; use std::io::Cursor; -use std::io::{Error, ErrorKind, Read, Result, Write}; +use std::io::{Read, Result, Write}; use std::iter::FromIterator; -use crate::field::crandall_field::CrandallField; -use crate::field::extension_field::quartic::QuarticExtension; use crate::field::extension_field::{Extendable, FieldExtension}; -use crate::field::field_types::{Field, PrimeField, RichField}; +use crate::field::field_types::{PrimeField, RichField}; use crate::fri::proof::{ CompressedFriProof, CompressedFriQueryRounds, FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep, }; use crate::hash::hash_types::HashOut; use crate::hash::merkle_proofs::MerkleProof; -use crate::hash::merkle_tree::{MerkleCap, MerkleTree}; +use crate::hash::merkle_tree::MerkleCap; use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; use crate::plonk::proof::{ CompressedProof, CompressedProofWithPublicInputs, OpeningSet, Proof, ProofWithPublicInputs, @@ -119,9 +116,9 @@ impl Buffer { Ok(()) } fn read_field_vec(&mut self, length: usize) -> Result> { - Ok((0..length) + (0..length) .map(|_| self.read_field()) - .collect::>>()?) + .collect::>>() } fn write_field_ext_vec, const D: usize>( @@ -137,9 +134,9 @@ impl Buffer { &mut self, length: usize, ) -> Result> { - Ok((0..length) + (0..length) .map(|_| self.read_field_ext::()) - .collect::>>()?) + .collect::>>() } fn write_opening_set, const D: usize>( @@ -187,7 +184,7 @@ impl Buffer { length .try_into() .expect("Merkle proof length must fit in u8."), - ); + )?; for &h in &p.siblings { self.write_hash(h)?; } @@ -278,7 +275,7 @@ impl Buffer { config: &CircuitConfig, ) -> Result>> { let mut fqrs = Vec::with_capacity(config.fri_config.num_query_rounds); - for i 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, config)?; let steps = config .fri_config @@ -413,7 +410,7 @@ impl Buffer { .map(|_| self.read_u32().map(|i| i as usize)) .collect::>>()?; let mut indices = original_indices.clone(); - indices.sort(); + indices.sort_unstable(); indices.dedup(); let mut pairs = Vec::new(); for &i in &indices { From 3859ca20905142c599e48baa066ea3bad240d6f2 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Sat, 2 Oct 2021 10:46:02 +0200 Subject: [PATCH 6/8] PR comments --- src/fri/mod.rs | 6 ++++ src/fri/recursive_verifier.rs | 7 ++--- src/fri/verifier.rs | 6 ++-- src/plonk/circuit_builder.rs | 7 +---- src/plonk/circuit_data.rs | 4 +++ src/plonk/proof.rs | 8 ++--- src/plonk/recursive_verifier.rs | 10 ++---- src/util/serialization.rs | 56 +++++++++++++++------------------ 8 files changed, 49 insertions(+), 55 deletions(-) diff --git a/src/fri/mod.rs b/src/fri/mod.rs index 716260a3..5e8936fa 100644 --- a/src/fri/mod.rs +++ b/src/fri/mod.rs @@ -17,3 +17,9 @@ pub struct FriConfig { /// Number of query rounds to perform. pub num_query_rounds: usize, } + +impl FriConfig { + pub(crate) fn total_arities(&self) -> usize { + self.reduction_arity_bits.iter().sum() + } +} diff --git a/src/fri/recursive_verifier.rs b/src/fri/recursive_verifier.rs index 2c0d009f..142d1e24 100644 --- a/src/fri/recursive_verifier.rs +++ b/src/fri/recursive_verifier.rs @@ -81,15 +81,14 @@ impl, const D: usize> CircuitBuilder { common_data: &CommonCircuitData, ) { let config = &common_data.config; - let total_arities = config.fri_config.reduction_arity_bits.iter().sum::(); debug_assert_eq!( - common_data.degree_bits, - log2_strict(proof.final_poly.len()) + total_arities, + common_data.final_poly_len(), + proof.final_poly.len(), "Final polynomial has wrong degree." ); // Size of the LDE domain. - let n = proof.final_poly.len() << (total_arities + config.rate_bits); + let n = 1 << (common_data.degree_bits + config.rate_bits); challenger.observe_opening_set(os); diff --git a/src/fri/verifier.rs b/src/fri/verifier.rs index 6662830a..efbd733b 100644 --- a/src/fri/verifier.rs +++ b/src/fri/verifier.rs @@ -64,14 +64,14 @@ pub(crate) fn verify_fri_proof, const D: usize>( common_data: &CommonCircuitData, ) -> Result<()> { let config = &common_data.config; - let total_arities = config.fri_config.reduction_arity_bits.iter().sum::(); + let total_arities = config.fri_config.total_arities(); ensure!( - common_data.degree_bits == log2_strict(proof.final_poly.len()) + total_arities, + common_data.final_poly_len() == proof.final_poly.len(), "Final polynomial has wrong degree." ); // Size of the LDE domain. - let n = proof.final_poly.len() << (total_arities + config.rate_bits); + let n = 1 << (common_data.degree_bits + config.rate_bits); // Check PoW. fri_verify_proof_of_work(challenges.fri_pow_response, &config.fri_config)?; diff --git a/src/plonk/circuit_builder.rs b/src/plonk/circuit_builder.rs index 035a6d90..18f84681 100644 --- a/src/plonk/circuit_builder.rs +++ b/src/plonk/circuit_builder.rs @@ -579,12 +579,7 @@ impl, const D: usize> CircuitBuilder { info!("Degree after blinding & padding: {}", degree); let degree_bits = log2_strict(degree); assert!( - self.config - .fri_config - .reduction_arity_bits - .iter() - .sum::() - <= degree_bits, + self.config.fri_config.total_arities() <= degree_bits, "FRI total reduction arity is too large." ); diff --git a/src/plonk/circuit_data.rs b/src/plonk/circuit_data.rs index 644ab370..f8bb0b6a 100644 --- a/src/plonk/circuit_data.rs +++ b/src/plonk/circuit_data.rs @@ -252,6 +252,10 @@ impl, const D: usize> CommonCircuitData { pub fn partial_products_range(&self) -> RangeFrom { self.config.num_challenges.. } + + pub fn final_poly_len(&self) -> usize { + 1 << (self.degree_bits - self.config.fri_config.total_arities()) + } } /// The `Target` version of `VerifierCircuitData`, for use inside recursive circuits. Note that this diff --git a/src/plonk/proof.rs b/src/plonk/proof.rs index 8ee20bc7..d26e5fb1 100644 --- a/src/plonk/proof.rs +++ b/src/plonk/proof.rs @@ -10,7 +10,7 @@ use crate::hash::hash_types::{HashOut, MerkleCapTarget}; use crate::hash::hashing::hash_n_to_hash; use crate::hash::merkle_tree::MerkleCap; use crate::iop::target::Target; -use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; +use crate::plonk::circuit_data::CommonCircuitData; use crate::util::serialization::Buffer; #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)] @@ -94,10 +94,9 @@ impl, const D: usize> ProofWithPublicInputs { pub fn from_bytes( bytes: Vec, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> anyhow::Result { let mut buffer = Buffer::new(bytes); - let proof = buffer.read_proof_with_public_inputs(common_data, config)?; + let proof = buffer.read_proof_with_public_inputs(common_data)?; Ok(proof) } } @@ -175,10 +174,9 @@ impl, const D: usize> CompressedProofWithPublicInpu pub fn from_bytes( bytes: Vec, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> anyhow::Result { let mut buffer = Buffer::new(bytes); - let proof = buffer.read_compressed_proof_with_public_inputs(common_data, config)?; + let proof = buffer.read_compressed_proof_with_public_inputs(common_data)?; Ok(proof) } } diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index a2351700..5a485495 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -486,8 +486,7 @@ mod tests { let recursive_proof = data.prove(pw)?; let proof_bytes = recursive_proof.to_bytes()?; info!("Proof length: {} bytes", proof_bytes.len()); - let proof_from_bytes = - ProofWithPublicInputs::from_bytes(proof_bytes, &data.common, &config)?; + let proof_from_bytes = ProofWithPublicInputs::from_bytes(proof_bytes, &data.common)?; assert_eq!(recursive_proof, proof_from_bytes); let now = std::time::Instant::now(); let compressed_recursive_proof = recursive_proof.clone().compress(&data.common)?; @@ -497,11 +496,8 @@ mod tests { "Compressed proof length: {} bytes", compressed_proof_bytes.len() ); - let compressed_proof_from_bytes = CompressedProofWithPublicInputs::from_bytes( - compressed_proof_bytes, - &data.common, - &config, - )?; + let compressed_proof_from_bytes = + CompressedProofWithPublicInputs::from_bytes(compressed_proof_bytes, &data.common)?; assert_eq!(compressed_recursive_proof, compressed_proof_from_bytes); verify(recursive_proof, &data.verifier_only, &data.common) } diff --git a/src/util/serialization.rs b/src/util/serialization.rs index bfc0473e..b3737363 100644 --- a/src/util/serialization.rs +++ b/src/util/serialization.rs @@ -13,7 +13,7 @@ use crate::fri::proof::{ use crate::hash::hash_types::HashOut; use crate::hash::merkle_proofs::MerkleProof; use crate::hash::merkle_tree::MerkleCap; -use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData}; +use crate::plonk::circuit_data::CommonCircuitData; use crate::plonk::proof::{ CompressedProof, CompressedProofWithPublicInputs, OpeningSet, Proof, ProofWithPublicInputs, }; @@ -154,8 +154,8 @@ impl Buffer { fn read_opening_set, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { + let config = &common_data.config; let constants = self.read_field_ext_vec::(common_data.num_constants)?; let plonk_sigmas = self.read_field_ext_vec::(config.num_routed_wires)?; let wires = self.read_field_ext_vec::(config.num_wires)?; @@ -212,8 +212,8 @@ impl Buffer { fn read_fri_initial_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { + let config = &common_data.config; let mut evals_proofs = Vec::with_capacity(4); let constants_sigmas_v = @@ -272,11 +272,11 @@ impl Buffer { fn read_fri_query_rounds, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result>> { + let config = &common_data.config; let mut fqrs = Vec::with_capacity(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, config)?; + let initial_trees_proof = self.read_fri_initial_proof(common_data)?; let steps = config .fri_config .reduction_arity_bits @@ -305,16 +305,14 @@ impl Buffer { fn read_fri_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { + let config = &common_data.config; let commit_phase_merkle_caps = (0..config.fri_config.reduction_arity_bits.len()) .map(|_| self.read_merkle_cap(config.cap_height)) .collect::>>()?; - let query_round_proofs = self.read_fri_query_rounds(common_data, config)?; - let final_poly = PolynomialCoeffs::new(self.read_field_ext_vec::( - 1 << (common_data.degree_bits - - config.fri_config.reduction_arity_bits.iter().sum::()), - )?); + 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 pow_witness = self.read_field()?; Ok(FriProof { commit_phase_merkle_caps, @@ -337,13 +335,13 @@ impl Buffer { pub fn read_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> 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 openings = self.read_opening_set(common_data, config)?; - let opening_proof = self.read_fri_proof(common_data, config)?; + let openings = self.read_opening_set(common_data)?; + let opening_proof = self.read_fri_proof(common_data)?; Ok(Proof { wires_cap, @@ -368,10 +366,11 @@ impl Buffer { pub fn read_proof_with_public_inputs, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { - let proof = self.read_proof(common_data, config)?; - let public_inputs = self.read_field_vec(self.len() - self.0.position() as usize)?; + let proof = self.read_proof(common_data)?; + let public_inputs = self.read_field_vec( + (self.len() - self.0.position() as usize) / std::mem::size_of::(), + )?; Ok(ProofWithPublicInputs { proof, @@ -404,8 +403,8 @@ impl Buffer { fn read_compressed_fri_query_rounds, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { + let config = &common_data.config; let original_indices = (0..config.fri_config.num_query_rounds) .map(|_| self.read_u32().map(|i| i as usize)) .collect::>>()?; @@ -414,7 +413,7 @@ impl Buffer { indices.dedup(); let mut pairs = Vec::new(); for &i in &indices { - pairs.push((i, self.read_fri_initial_proof(common_data, config)?)); + pairs.push((i, self.read_fri_initial_proof(common_data)?)); } let initial_trees_proofs = HashMap::from_iter(pairs); @@ -457,16 +456,14 @@ impl Buffer { fn read_compressed_fri_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { + let config = &common_data.config; let commit_phase_merkle_caps = (0..config.fri_config.reduction_arity_bits.len()) .map(|_| self.read_merkle_cap(config.cap_height)) .collect::>>()?; - let query_round_proofs = self.read_compressed_fri_query_rounds(common_data, config)?; - let final_poly = PolynomialCoeffs::new(self.read_field_ext_vec::( - 1 << (common_data.degree_bits - - config.fri_config.reduction_arity_bits.iter().sum::()), - )?); + 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 pow_witness = self.read_field()?; Ok(CompressedFriProof { commit_phase_merkle_caps, @@ -489,13 +486,13 @@ impl Buffer { pub fn read_compressed_proof, const D: usize>( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> 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 openings = self.read_opening_set(common_data, config)?; - let opening_proof = self.read_compressed_fri_proof(common_data, config)?; + let openings = self.read_opening_set(common_data)?; + let opening_proof = self.read_compressed_fri_proof(common_data)?; Ok(CompressedProof { wires_cap, @@ -526,9 +523,8 @@ impl Buffer { >( &mut self, common_data: &CommonCircuitData, - config: &CircuitConfig, ) -> Result> { - let proof = self.read_compressed_proof(common_data, config)?; + let proof = self.read_compressed_proof(common_data)?; let public_inputs = self.read_field_vec(self.len() - self.0.position() as usize)?; Ok(CompressedProofWithPublicInputs { From fbefaa4768f16d57466381bf34d80c398a6b614f Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Sat, 2 Oct 2021 14:01:08 +0200 Subject: [PATCH 7/8] Unused import --- src/plonk/recursive_verifier.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index 3855ca3a..33bcbb67 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -142,7 +142,6 @@ mod tests { }; use crate::plonk::verifier::verify; use crate::util::log2_strict; - use crate::util::serialization::Buffer; // Construct a `FriQueryRoundTarget` with the same dimensions as the ones in `proof`. fn get_fri_query_round, const D: usize>( From bce3256c96ce41861f487ccf09d6e02f67ddd1e0 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Mon, 4 Oct 2021 10:21:35 +0200 Subject: [PATCH 8/8] PR feedback --- src/fri/recursive_verifier.rs | 2 +- src/fri/verifier.rs | 3 +-- src/util/serialization.rs | 4 +++- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/fri/recursive_verifier.rs b/src/fri/recursive_verifier.rs index 142d1e24..78d5f007 100644 --- a/src/fri/recursive_verifier.rs +++ b/src/fri/recursive_verifier.rs @@ -88,7 +88,7 @@ impl, const D: usize> CircuitBuilder { ); // Size of the LDE domain. - let n = 1 << (common_data.degree_bits + config.rate_bits); + let n = common_data.lde_size(); challenger.observe_opening_set(os); diff --git a/src/fri/verifier.rs b/src/fri/verifier.rs index efbd733b..f9c1d998 100644 --- a/src/fri/verifier.rs +++ b/src/fri/verifier.rs @@ -64,14 +64,13 @@ pub(crate) fn verify_fri_proof, const D: usize>( common_data: &CommonCircuitData, ) -> Result<()> { let config = &common_data.config; - let total_arities = config.fri_config.total_arities(); ensure!( common_data.final_poly_len() == proof.final_poly.len(), "Final polynomial has wrong degree." ); // Size of the LDE domain. - let n = 1 << (common_data.degree_bits + config.rate_bits); + let n = common_data.lde_size(); // Check PoW. fri_verify_proof_of_work(challenges.fri_pow_response, &config.fri_config)?; diff --git a/src/util/serialization.rs b/src/util/serialization.rs index b3737363..21b12c11 100644 --- a/src/util/serialization.rs +++ b/src/util/serialization.rs @@ -525,7 +525,9 @@ impl Buffer { common_data: &CommonCircuitData, ) -> Result> { let proof = self.read_compressed_proof(common_data)?; - let public_inputs = self.read_field_vec(self.len() - self.0.position() as usize)?; + let public_inputs = self.read_field_vec( + (self.len() - self.0.position() as usize) / std::mem::size_of::(), + )?; Ok(CompressedProofWithPublicInputs { proof,