somehow it works?

src/proof/mod.rs

@@ -100,7 +100,7 @@ where
 
     /// Generate the recursive SNARK, encoded in `ProveOutput`
     fn prove_recursively(
-        pp: &Self::PublicParams,
+        pp: &'a Self::PublicParams,
         z0: &[F],
         steps: Vec<C1LEM<'a, F, C>>,
         store: &'a Store<F>,
@@ -174,7 +174,7 @@ pub trait Prover<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> {
     /// Generate a proof from a sequence of frames
     fn prove(
         &self,
-        pp: &Self::PublicParams,
+        pp: &'a Self::PublicParams,
         frames: &[Frame],
         store: &'a Store<F>,
     ) -> Result<(Self::RecursiveSnark, Vec<F>, Vec<F>, usize), ProofError> {
@@ -205,7 +205,7 @@ pub trait Prover<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> {
     /// Evaluate an expression with an environment and then generate the corresponding proof
     fn evaluate_and_prove(
         &self,
-        pp: &Self::PublicParams,
+        pp: &'a Self::PublicParams,
         expr: Ptr,
         env: Ptr,
         store: &'a Store<F>,

src/proof/nova.rs

@@ -159,7 +159,7 @@ where
     /// A proof for the intermediate steps of a recursive computation along with
     /// the number of steps used for verification
     Recursive(
-        Box<RecursiveSNARK<E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>>>,
+        Box<RecursiveSNARK<'a, E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>>>,
         usize,
         PhantomData<&'a C>,
     ),
@@ -234,7 +234,7 @@ where
 
     #[tracing::instrument(skip_all, name = "nova::prove_recursively")]
     fn prove_recursively(
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &'a PublicParams<F, C1LEM<'a, F, C>>,
         z0: &[F],
         steps: Vec<C1LEM<'a, F, C>>,
         store: &'a Store<F>,
@@ -257,7 +257,7 @@ where
         tracing::debug!("steps.len: {num_steps}");
 
         // produce a recursive SNARK
-        let mut recursive_snark: Option<RecursiveSNARK<E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>>> =
+        let mut recursive_snark: Option<RecursiveSNARK<'_, E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>>> =
             None;
 
         // the shadowing here is voluntary

src/proof/supernova.rs

@@ -134,7 +134,7 @@ where
     <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
 {
     /// A proof for the intermediate steps of a recursive computation
-    Recursive(Box<RecursiveSNARK<E1<F>, E2<F>>>),
+    Recursive(Box<RecursiveSNARK<'a, E1<F>, E2<F>>>),
     /// A proof for the final step of a recursive computation
     Compressed(
         Box<CompressedSNARK<E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>, SS1<F>, SS2<F>>>,
@@ -177,14 +177,14 @@ where
 
     #[tracing::instrument(skip_all, name = "supernova::prove_recursively")]
     fn prove_recursively(
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &'a PublicParams<F, C1LEM<'a, F, C>>,
         z0: &[F],
         steps: Vec<C1LEM<'a, F, C>>,
         store: &'a Store<F>,
         _reduction_count: usize,
         _lang: Arc<Lang<F, C>>,
     ) -> Result<Self, ProofError> {
-        let mut recursive_snark_option: Option<RecursiveSNARK<E1<F>, E2<F>>> = None;
+        let mut recursive_snark_option: Option<RecursiveSNARK<'_, E1<F>, E2<F>>> = None;
 
         let z0_primary = z0;
         let z0_secondary = Self::z0_secondary();