add pub wrapper fn

plonky2/src/plonk/wrapper/mod.rs

@@ -2,3 +2,4 @@ pub mod plonky2_config;
 pub mod poseidon_bn128;
 pub mod poseidon_bn128_constants;
 pub mod utils;
+

plonky2/src/recursion/mod.rs

@@ -8,3 +8,4 @@ pub mod conditional_recursive_verifier;
 pub mod cyclic_recursion;
 pub mod dummy_circuit;
 pub mod recursive_verifier;
+pub mod wrapper_recursion;

plonky2/src/recursion/wrapper_recursion.rs

@@ -0,0 +1,65 @@
+use std::time::Instant;
+use anyhow::Error;
+use log::Level;
+use plonky2_field::extension::Extendable;
+use crate::hash::hash_types::RichField;
+use crate::iop::witness::{PartialWitness, WitnessWrite};
+use crate::plonk::circuit_builder::CircuitBuilder;
+use crate::plonk::circuit_data::{CircuitConfig, CommonCircuitData, VerifierOnlyCircuitData};
+use crate::plonk::config::{AlgebraicHasher, GenericConfig};
+use crate::plonk::proof::ProofWithPublicInputs;
+use crate::util::timing::TimingTree;
+use crate::plonk;
+
+type Proof<F, C, const D: usize> = (
+    ProofWithPublicInputs<F, C, D>,
+    VerifierOnlyCircuitData<C, D>,
+    CommonCircuitData<F, D>,
+);
+
+pub fn wrap_plonky2_proof<
+    F: RichField + Extendable<D>,
+    C: GenericConfig<D, F = F>,
+    InnerC: GenericConfig<D, F = F>,
+    const D: usize,
+>(
+    inner_proof: ProofWithPublicInputs<F, InnerC, D>,
+    inner_vd: VerifierOnlyCircuitData<InnerC, D>,
+    inner_cd: CommonCircuitData<F, D>,
+) -> Result<Proof<F, C, D>, Error>
+where
+    InnerC::Hasher: AlgebraicHasher<F>,
+{
+    let circuit_config = CircuitConfig::standard_recursion_config();
+    let mut builder = CircuitBuilder::<F, D>::new(circuit_config.clone());
+    let mut pw = PartialWitness::new();
+    let pt = builder.add_virtual_proof_with_pis(&inner_cd);
+    pw.set_proof_with_pis_target(&pt, &inner_proof);
+
+    let inner_data = builder.add_virtual_verifier_data(inner_cd.config.fri_config.cap_height);
+    pw.set_cap_target(
+        &inner_data.constants_sigmas_cap,
+        &inner_vd.constants_sigmas_cap,
+    );
+    pw.set_hash_target(inner_data.circuit_digest, inner_vd.circuit_digest);
+
+    for i in 0..30 {
+        builder.register_public_input(pt.public_inputs[0]);
+    }
+
+    builder.verify_proof::<InnerC>(&pt, &inner_data, &inner_cd);
+
+    let data = builder.build::<C>();
+
+    let mut timing = TimingTree::new("prove", Level::Debug);
+
+    let start_recursive = Instant::now();
+    let proof = plonk::prover::prove(&data.prover_only, &data.common, pw, &mut timing)?;
+    println!("plonky2 wrapper use: {}s", start_recursive.elapsed().as_secs_f64());
+
+    println!("plonky2 wrapper degrees: {}", data.common.degree_bits());
+
+    data.verify(proof.clone())?;
+
+    Ok((proof, data.verifier_only, data.common))
+}

starky/src/fibonacci_stark.rs

@@ -160,7 +160,7 @@ mod tests {
     use plonky2::util::timing::TimingTree;
 
     use std::time::{Duration, Instant};
-
+    use plonky2::recursion::wrapper_recursion::wrap_plonky2_proof;
     use crate::config::StarkConfig;
     use crate::fibonacci_stark::FibonacciStark;
     use crate::proof::StarkProofWithPublicInputs;
@@ -262,7 +262,7 @@ mod tests {
         // this recursive proof will be wrapped
         println!("recursive proof size: {} bytes {}KB", bincode::serialize(&r_p).unwrap().len(), bincode::serialize(&r_p).unwrap().len()/1024);
 
-        let (w_p, w_v, w_c) = recursive_plonky2_proof::<F, C2, C, D>(r_p, r_v, r_c)?;
+        let (w_p, w_v, w_c) = wrap_plonky2_proof::<F, C2, C, D>(r_p, r_v, r_c)?;
         println!("wrapper proof size: {} bytes {}KB", bincode::serialize(&w_p).unwrap().len(), bincode::serialize(&w_p).unwrap().len()/1024);
 
         let common_data_file = File::create("common_circuit_data.json")?;
@@ -379,7 +379,7 @@ mod tests {
         CommonCircuitData<F, D>,
     );
 
-    fn recursive_plonky2_proof<
+    pub fn recursive_plonky2_proof<
         F: RichField + Extendable<D>,
         C: GenericConfig<D, F = F>,
         InnerC: GenericConfig<D, F = F>,