diff --git a/benches/common/fib.rs b/benches/common/fib.rs
index f32c1844b9..e9426bd32a 100644
--- a/benches/common/fib.rs
+++ b/benches/common/fib.rs
@@ -68,7 +68,7 @@ fn compute_coeffs<F: LurkField>(store: &Store<F>) -> (usize, usize) {
         store.intern_empty_env(),
         store.cont_outermost(),
     ];
-    let lang: Lang<F, Coproc<F>> = Lang::new();
+    let lang: Lang<F> = Lang::new();
     let mut coef_lin = 0;
     let coef_ang;
     let step_func = eval_step();
diff --git a/benches/end2end.rs b/benches/end2end.rs
index e6e5602edb..d201c08d82 100644
--- a/benches/end2end.rs
+++ b/benches/end2end.rs
@@ -59,7 +59,7 @@ fn end2end_benchmark(c: &mut Criterion) {
     let reduction_count = DEFAULT_REDUCTION_COUNT;
 
     // setup
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     let store = Store::default();
@@ -234,7 +234,7 @@ fn prove_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -282,7 +282,7 @@ fn prove_compressed_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -324,7 +324,7 @@ fn verify_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -377,7 +377,7 @@ fn verify_compressed_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
diff --git a/benches/fibonacci.rs b/benches/fibonacci.rs
index 9cbd85c5b1..5cdac5a357 100644
--- a/benches/fibonacci.rs
+++ b/benches/fibonacci.rs
@@ -80,7 +80,7 @@ fn fibonacci_prove<M: measurement::Measurement>(
     c: &mut BenchmarkGroup<'_, M>,
 ) {
     let limit = fib_limit(prove_params.fib_n, prove_params.reduction_count);
-    let lang_pallas = Lang::<pallas::Scalar, Coproc<pallas::Scalar>>::new();
+    let lang_pallas = Lang::<pallas::Scalar>::new();
     let lang_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
diff --git a/benches/public_params.rs b/benches/public_params.rs
index df52634ee9..9332a6c6b1 100644
--- a/benches/public_params.rs
+++ b/benches/public_params.rs
@@ -1,8 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion, SamplingMode};
-use lurk::{
-    eval::lang::{Coproc, Lang},
-    proof::nova,
-};
+use lurk::{eval::lang::Lang, proof::nova};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -14,8 +11,7 @@ const DEFAULT_REDUCTION_COUNT: usize = 10;
 fn public_params_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("public_params_benchmark");
     group.sampling_mode(SamplingMode::Flat);
-    let lang_pallas =
-        Lang::<pasta_curves::pallas::Scalar, Coproc<pasta_curves::pallas::Scalar>>::new();
+    let lang_pallas = Lang::<pasta_curves::pallas::Scalar>::new();
     let lang_pallas_rc = Arc::new(lang_pallas);
 
     let reduction_count = DEFAULT_REDUCTION_COUNT;
diff --git a/benches/sha256.rs b/benches/sha256.rs
index b8f6d55a0e..5ef0fce4a6 100644
--- a/benches/sha256.rs
+++ b/benches/sha256.rs
@@ -38,7 +38,7 @@ fn sha256_ivc<F: LurkField>(
     state: Rc<RefCell<State>>,
     arity: usize,
     n: usize,
-    input: &Vec<usize>,
+    input: &[usize],
 ) -> Ptr {
     assert_eq!(n, input.len());
     let input = input
@@ -128,7 +128,7 @@ fn sha256_ivc_prove<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = NovaProver::new(prove_params.reduction_count, lang_rc.clone());
@@ -209,7 +209,7 @@ fn sha256_ivc_prove_compressed<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = NovaProver::new(prove_params.reduction_count, lang_rc.clone());
@@ -293,7 +293,7 @@ fn sha256_nivc_prove<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = SuperNovaProver::new(prove_params.reduction_count, lang_rc.clone());
diff --git a/benches/synthesis.rs b/benches/synthesis.rs
index c130df7e4b..661038ec8f 100644
--- a/benches/synthesis.rs
+++ b/benches/synthesis.rs
@@ -40,7 +40,7 @@ fn synthesize<M: measurement::Measurement>(
     c: &mut BenchmarkGroup<'_, M>,
 ) {
     let limit = 1_000_000;
-    let lang_rc = Arc::new(Lang::<Fq, Coproc<Fq>>::new());
+    let lang_rc = Arc::new(Lang::<Fq>::new());
     let state = State::init_lurk_state().rccell();
 
     c.bench_with_input(
diff --git a/examples/tp_table.rs b/examples/tp_table.rs
index 73459290e8..588accd9e2 100644
--- a/examples/tp_table.rs
+++ b/examples/tp_table.rs
@@ -3,7 +3,7 @@ use ascii_table::{Align, AsciiTable};
 use criterion::black_box;
 use lurk::{
     eval::lang::{Coproc, Lang},
-    lem::{eval::evaluate, multiframe::MultiFrame, store::Store},
+    lem::{eval::evaluate, store::Store},
     proof::nova::{public_params, NovaProver, PublicParams},
 };
 use num_traits::ToPrimitive;
@@ -157,7 +157,7 @@ fn main() {
 
     let frames = evaluate::<Fr, Coproc<Fr>>(None, program, &store, limit).unwrap();
 
-    let lang = Lang::<Fr, Coproc<Fr>>::new();
+    let lang = Lang::<Fr>::new();
     let lang_arc = Arc::new(lang.clone());
 
     let mut data = Vec::with_capacity(rc_vec.len());
@@ -166,8 +166,7 @@ fn main() {
         let prover: NovaProver<'_, _, _> = NovaProver::new(rc, lang_arc.clone());
         println!("Getting public params for rc={rc}");
         // TODO: use cache once it's fixed
-        let pp: PublicParams<_, MultiFrame<'_, _, Coproc<Fr>>> =
-            public_params(rc, lang_arc.clone());
+        let pp: PublicParams<_> = public_params(rc, lang_arc.clone());
         let n_folds_data = (0..=max_n_folds)
             .map(|n_folds| {
                 let n_frames = n_iters(n_folds, rc);
diff --git a/src/cli/lurk_proof.rs b/src/cli/lurk_proof.rs
index 1ccc37dea9..76cc2b7eeb 100644
--- a/src/cli/lurk_proof.rs
+++ b/src/cli/lurk_proof.rs
@@ -1,6 +1,6 @@
-use ::nova::traits::Engine;
 use abomonation::Abomonation;
 use anyhow::{bail, Result};
+use ff::PrimeField;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, sync::Arc};
 
@@ -10,7 +10,7 @@ use crate::{
     field::LurkField,
     lem::{pointers::ZPtr, store::Store},
     proof::{
-        nova::{self, CurveCycleEquipped, C1LEM, E1, E2},
+        nova::{self, CurveCycleEquipped, Dual, C1LEM},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -154,9 +154,10 @@ impl<'a, F: CurveCycleEquipped + Serialize, C: Coprocessor<F> + Serialize + Dese
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + DeserializeOwned,
-        C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
-    > LurkProof<'static, F, C>
+        C: Coprocessor<F> + Serialize + DeserializeOwned + 'a,
+    > LurkProof<'a, F, C>
 {
     #[inline]
     pub(crate) fn is_cached(proof_key: &str) -> bool {
@@ -165,12 +166,13 @@ impl<
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + DeserializeOwned,
-        C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
-    > LurkProof<'static, F, C>
+        C: Coprocessor<F> + Serialize + DeserializeOwned + 'a,
+    > LurkProof<'a, F, C>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     pub(crate) fn verify_proof(proof_key: &str) -> Result<()> {
         let lurk_proof = load::<Self>(&proof_path(proof_key))?;
diff --git a/src/cli/repl/meta_cmd.rs b/src/cli/repl/meta_cmd.rs
index 11e561ed9f..5c38f148b4 100644
--- a/src/cli/repl/meta_cmd.rs
+++ b/src/cli/repl/meta_cmd.rs
@@ -1,7 +1,8 @@
-use ::nova::traits::Engine;
+use ::nova::supernova::StepCircuit;
 use abomonation::Abomonation;
 use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
+use ff::PrimeField;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, process};
 
@@ -22,7 +23,7 @@ use crate::{
     },
     package::{Package, SymbolRef},
     proof::{
-        nova::{self, CurveCycleEquipped, C1LEM, E1, E2},
+        nova::{self, CurveCycleEquipped, Dual, C1LEM},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -44,12 +45,13 @@ pub(super) struct MetaCmd<F: LurkField, C: Coprocessor<F> + Serialize + Deserial
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + Serialize + DeserializeOwned,
         C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
     > MetaCmd<F, C>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     const LOAD: MetaCmd<F, C> = MetaCmd {
         name: "load",
@@ -992,7 +994,7 @@ where
 
             let (fun, proto_rc) = Self::get_fun_and_rc(repl, ptcl)?;
 
-            match load::<ProtocolProof<'_, _, C>>(&path)? {
+            match load::<ProtocolProof<F, C1LEM<'a, F, C>>>(&path)? {
                 ProtocolProof::Nova {
                     args: LurkData { z_ptr, z_dag },
                     proof,
@@ -1096,23 +1098,14 @@ fn get_path<F: LurkField, C: Coprocessor<F> + Serialize + DeserializeOwned>(
 #[non_exhaustive]
 #[derive(Serialize, Deserialize)]
 #[serde(bound(serialize = "F: Serialize", deserialize = "F: DeserializeOwned"))]
-enum ProtocolProof<'a, F: CurveCycleEquipped, C: Coprocessor<F> + Serialize + DeserializeOwned>
-where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-{
+enum ProtocolProof<F: CurveCycleEquipped, S> {
     Nova {
         args: LurkData<F>,
-        proof: nova::Proof<F, C1LEM<'a, F, C>>,
+        proof: nova::Proof<F, S>,
     },
 }
 
-impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a + Serialize + DeserializeOwned>
-    HasFieldModulus for ProtocolProof<'a, F, C>
-where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-{
+impl<F: CurveCycleEquipped, S: StepCircuit<F>> HasFieldModulus for ProtocolProof<F, S> {
     fn field_modulus() -> String {
         F::MODULUS.to_owned()
     }
diff --git a/src/cli/repl/mod.rs b/src/cli/repl/mod.rs
index 7d2a72e76c..bb55493174 100644
--- a/src/cli/repl/mod.rs
+++ b/src/cli/repl/mod.rs
@@ -3,7 +3,7 @@ mod meta_cmd;
 use abomonation::Abomonation;
 use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
-use nova::traits::Engine;
+use ff::PrimeField;
 use rustyline::{
     error::ReadlineError,
     history::DefaultHistory,
@@ -39,7 +39,7 @@ use crate::{
     },
     parser,
     proof::{
-        nova::{CurveCycleEquipped, NovaProver, E1, E2},
+        nova::{CurveCycleEquipped, Dual, NovaProver},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -166,8 +166,8 @@ impl<
         C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
     > Repl<F, C>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     pub(crate) fn new(
         store: Store<F>,
diff --git a/src/eval/lang.rs b/src/eval/lang.rs
index 43ae0d0a58..0ad5f6ca65 100644
--- a/src/eval/lang.rs
+++ b/src/eval/lang.rs
@@ -73,7 +73,7 @@ pub enum Coproc<F: LurkField> {
 ///
 // TODO: Define a trait for the Hash and parameterize on that also.
 #[derive(Debug, Default, Clone, Deserialize, Serialize)]
-pub struct Lang<F, C> {
+pub struct Lang<F, C = Coproc<F>> {
     /// An IndexMap that stores coprocessors with their associated `Sym` keys.
     coprocessors: IndexMap<Symbol, C>,
     _p: PhantomData<F>,
@@ -185,12 +185,12 @@ pub(crate) mod test {
 
     #[test]
     fn lang() {
-        Lang::<Fr, Coproc<Fr>>::new();
+        Lang::<Fr>::new();
     }
 
     #[test]
     fn dummy_lang() {
-        let _lang = Lang::<Fr, Coproc<Fr>>::new_with_bindings(vec![(
+        let _lang = Lang::<Fr>::new_with_bindings(vec![(
             sym!("coproc", "dummy"),
             DummyCoprocessor::new().into(),
         )]);
diff --git a/src/lem/eval.rs b/src/lem/eval.rs
index 6631b153ad..135ebf0731 100644
--- a/src/lem/eval.rs
+++ b/src/lem/eval.rs
@@ -1720,10 +1720,7 @@ fn make_thunk() -> Func {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        eval::lang::{Coproc, Lang},
-        lem::store::Store,
-    };
+    use crate::{eval::lang::Lang, lem::store::Store};
     use bellpepper_core::{test_cs::TestConstraintSystem, Comparable};
     use expect_test::{expect, Expect};
     use halo2curves::bn256::Fr;
@@ -1734,7 +1731,7 @@ mod tests {
         let func = eval_step();
         let frame = Frame::blank(func, 0, &store);
         let mut cs = TestConstraintSystem::<Fr>::new();
-        let lang: Lang<Fr, Coproc<Fr>> = Lang::new();
+        let lang: Lang<Fr> = Lang::new();
         let _ = func.synthesize_frame_aux(&mut cs, &store, &frame, &lang);
         let expect_eq = |computed: usize, expected: Expect| {
             expected.assert_eq(&computed.to_string());
diff --git a/src/lem/multiframe.rs b/src/lem/multiframe.rs
index 9fc1cfe5f9..e269fb09fa 100644
--- a/src/lem/multiframe.rs
+++ b/src/lem/multiframe.rs
@@ -15,7 +15,7 @@ use crate::{
     eval::lang::Lang,
     field::{LanguageField, LurkField},
     proof::{
-        nova::{CurveCycleEquipped, E1, E2},
+        nova::{CurveCycleEquipped, E1},
         supernova::{FoldingConfig, C2},
         CEKState, EvaluationStore, FrameLike, Provable,
     },
@@ -898,11 +898,14 @@ impl<'a, F: LurkField, C: Coprocessor<F>> nova::supernova::StepCircuit<F> for Mu
     }
 }
 
-impl<'a, F, C> NonUniformCircuit<E1<F>, E2<F>, MultiFrame<'a, F, C>, C2<F>> for MultiFrame<'a, F, C>
+impl<'a, F, C> NonUniformCircuit<E1<F>> for MultiFrame<'a, F, C>
 where
     F: CurveCycleEquipped + LurkField,
     C: Coprocessor<F> + 'a,
 {
+    type C1 = MultiFrame<'a, F, C>;
+    type C2 = C2<F>;
+
     fn num_circuits(&self) -> usize {
         assert_eq!(self.pc, 0);
         self.get_lang().coprocessor_count() + 1
@@ -1042,7 +1045,7 @@ mod tests {
 
         let mut cs_clone = cs.clone();
 
-        let lang = Lang::<Bn, Coproc<Bn>>::new();
+        let lang = Lang::<Bn>::new();
 
         let output_sequential = synthesize_frames_sequential(
             &mut cs,
@@ -1083,7 +1086,7 @@ mod tests {
         // not self-evaluating
         let expr = store.read_with_default_state("(+ 1 2)").unwrap();
 
-        let lang = Arc::new(Lang::<Bn, Coproc<Bn>>::new());
+        let lang = Arc::new(Lang::<Bn>::new());
         let mut frames = evaluate::<Bn, Coproc<Bn>>(None, expr, &store, 1).unwrap();
         assert_eq!(frames.len(), 1);
 
diff --git a/src/lem/tests/eval_tests.rs b/src/lem/tests/eval_tests.rs
index ed19de2a10..0b3e39c393 100644
--- a/src/lem/tests/eval_tests.rs
+++ b/src/lem/tests/eval_tests.rs
@@ -87,7 +87,7 @@ fn do_test_aux<C: Coprocessor<Fr>>(
             lang,
         )
     } else {
-        let lang = Lang::<Fr, Coproc<Fr>>::new();
+        let lang = Lang::<Fr>::new();
         do_test(
             s,
             ptr,
diff --git a/src/proof/mod.rs b/src/proof/mod.rs
index 86cdf7a0a6..549aa53429 100644
--- a/src/proof/mod.rs
+++ b/src/proof/mod.rs
@@ -15,7 +15,7 @@ pub mod supernova;
 #[cfg(test)]
 mod tests;
 
-use ::nova::traits::Engine;
+use ff::Field;
 use std::sync::Arc;
 
 use crate::{
@@ -24,7 +24,7 @@ use crate::{
     eval::lang::Lang,
     field::LurkField,
     lem::{eval::EvalConfig, pointers::Ptr, store::Store},
-    proof::nova::E2,
+    proof::nova::Dual,
 };
 
 use self::{nova::CurveCycleEquipped, supernova::FoldingConfig};
@@ -111,9 +111,8 @@ where
 
     /// Return the `z0_secondary`
     #[inline]
-    fn z0_secondary() -> Vec<<F::E2 as Engine>::Scalar> {
-        use ff::Field;
-        vec![<E2<F> as Engine>::Scalar::ZERO]
+    fn z0_secondary() -> Vec<Dual<F>> {
+        vec![Dual::<F>::ZERO]
     }
 }
 
diff --git a/src/proof/nova.rs b/src/proof/nova.rs
index 0e5c887d77..88d78a5a84 100644
--- a/src/proof/nova.rs
+++ b/src/proof/nova.rs
@@ -2,12 +2,12 @@ use bellpepper_core::{num::AllocatedNum, ConstraintSystem};
 use halo2curves::bn256::Fr as Bn256Scalar;
 use nova::{
     errors::NovaError,
-    provider::{Bn256Engine, GrumpkinEngine, PallasEngine, VestaEngine},
+    provider::{Bn256Engine, PallasEngine},
     traits::{
         circuit::{StepCircuit, TrivialCircuit},
         evaluation::EvaluationEngineTrait,
         snark::RelaxedR1CSSNARKTrait,
-        Engine,
+        CurveCycleEquipped as NovaCurveCycleEquipped, Dual as DualEng, Engine,
     },
     CompressedSNARK, ProverKey, R1CSWithArity, RecursiveSNARK, VerifierKey,
 };
@@ -43,40 +43,39 @@ pub trait CurveCycleEquipped: LurkField {
     ///
     /// The following abstracts over curve cycle groups for which there exists an implementation of [`nova::traits::evaluation::EvaluationEngineTrait<G>`],
     /// encapsulating these idiosyncracies within Nova.
+    type E1: NovaCurveCycleEquipped<Scalar = Self>;
 
     /// a concrete implementation of an [`nova::traits::evaluation::EvaluationEngineTrait<G>`] for G1,
     type EE1: EvaluationEngineTrait<Self::E1>;
     /// a concrete implementation of an [`nova::traits::evaluation::EvaluationEngineTrait<G>`] for G2,
-    type EE2: EvaluationEngineTrait<Self::E2>;
-
-    /// The group type for the first curve in the cycle.
-    type E1: Engine<Base = <Self::E2 as Engine>::Scalar, Scalar = Self>;
-    /// The  group type for the second curve in the cycle.
-    type E2: Engine<Base = <Self::E1 as Engine>::Scalar>;
+    type EE2: EvaluationEngineTrait<DualEng<Self::E1>>;
 }
 
 impl CurveCycleEquipped for pallas::Scalar {
-    type EE1 = nova::provider::ipa_pc::EvaluationEngine<Self::E1>;
-    type EE2 = nova::provider::ipa_pc::EvaluationEngine<Self::E2>;
-
     type E1 = PallasEngine;
-    type E2 = VestaEngine;
+
+    type EE1 = nova::provider::ipa_pc::EvaluationEngine<Self::E1>;
+    type EE2 = nova::provider::ipa_pc::EvaluationEngine<DualEng<Self::E1>>;
 }
 // The impl CurveCycleEquipped for vesta::Scalar is academically possible, but voluntarily omitted to avoid confusion.
 
 impl CurveCycleEquipped for Bn256Scalar {
     type EE1 = nova::provider::ipa_pc::EvaluationEngine<Self::E1>;
-    type EE2 = nova::provider::ipa_pc::EvaluationEngine<Self::E2>;
+    type EE2 = nova::provider::ipa_pc::EvaluationEngine<DualEng<Self::E1>>;
 
     type E1 = Bn256Engine;
-    type E2 = GrumpkinEngine;
 }
 // The impl CurveCycleEquipped for grumpkin::Scalar is academically possible, but voluntarily omitted to avoid confusion.
 
 /// Convenience alias for the primary group type pegged to a LurkField through a CurveCycleEquipped type.
 pub type E1<F> = <F as CurveCycleEquipped>::E1;
-/// Convenience alias for the secondary group type pegged to a LurkField through a CurveCycleEquipped type.
-pub type E2<F> = <F as CurveCycleEquipped>::E2;
+
+/// Convenience alias for the Dual field of a CurveCycleEquipped field.
+/// By definition, this is both:
+/// - the Base field for the associated Primary Engine,
+/// - the Scalar field for the Secondary Engine.
+pub type Dual<F> =
+    <<<F as CurveCycleEquipped>::E1 as NovaCurveCycleEquipped>::Secondary as Engine>::Scalar;
 
 /// Type alias for the Evaluation Engine using G1 group elements.
 pub type EE1<F> = <F as CurveCycleEquipped>::EE1;
@@ -90,42 +89,40 @@ pub type SS1<F> = nova::spartan::snark::RelaxedR1CSSNARK<E1<F>, EE1<F>>;
 /// Type alias for the Relaxed R1CS Spartan SNARK using G2 group elements, EE2.
 // NOTE: this is not a SNARK that uses computational commitments,
 // that SNARK would be found at nova::spartan::ppsnark::RelaxedR1CSSNARK,
-pub type SS2<F> = nova::spartan::snark::RelaxedR1CSSNARK<E2<F>, EE2<F>>;
+pub type SS2<F> = nova::spartan::snark::RelaxedR1CSSNARK<DualEng<E1<F>>, EE2<F>>;
 
 /// Type alias for a MultiFrame with S1 field elements.
 /// This uses the <<F as CurveCycleEquipped>::G1 as Group>::Scalar type for the G1 scalar field elements
 /// to reflect it this should not be used outside the Nova context
 pub type C1LEM<'a, F, C> = crate::lem::multiframe::MultiFrame<'a, F, C>;
 /// Type alias for a Trivial Test Circuit with G2 scalar field elements.
-pub type C2<F> = TrivialCircuit<<E2<F> as Engine>::Scalar>;
+pub type C2<F> = TrivialCircuit<Dual<F>>;
 
 /// Type alias for Nova Circuit Parameters with the curve cycle types defined above.
 pub type NovaCircuitShape<F> = R1CSWithArity<E1<F>>;
 
 /// Type alias for Nova Public Parameters with the curve cycle types defined above.
-pub type NovaPublicParams<F, C1> = nova::PublicParams<E1<F>, E2<F>, C1, C2<F>>;
+pub type NovaPublicParams<F> = nova::PublicParams<E1<F>>;
 
 /// A struct that contains public parameters for the Nova proving system.
 #[derive(Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct PublicParams<F, SC: StepCircuit<F>>
+pub struct PublicParams<F>
 where
     F: CurveCycleEquipped,
 {
     /// Public parameters for the Nova proving system.
-    pub pp: NovaPublicParams<F, SC>,
+    pub pp: NovaPublicParams<F>,
     /// Prover and verifier key for final proof compression
     #[serde(skip)]
     pk_and_vk: OnceCell<(
-        ProverKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>,
-        VerifierKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>,
+        ProverKey<E1<F>, SS1<F>, SS2<F>>,
+        VerifierKey<E1<F>, SS1<F>, SS2<F>>,
     )>,
 }
 
 // this avoids dipping into the pk/vk
-impl<F: CurveCycleEquipped, SC: StepCircuit<F> + std::fmt::Debug> std::fmt::Debug
-    for PublicParams<F, SC>
-{
+impl<F: CurveCycleEquipped> std::fmt::Debug for PublicParams<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PublicParams")
             .field("pp", &self.pp)
@@ -133,28 +130,26 @@ impl<F: CurveCycleEquipped, SC: StepCircuit<F> + std::fmt::Debug> std::fmt::Debu
     }
 }
 
-impl<F: CurveCycleEquipped, SC: StepCircuit<F>> PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> PublicParams<F> {
     /// provides a reference to a ProverKey suitable for producing a CompressedProof
-    pub fn pk(&self) -> &ProverKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>> {
-        let (pk, _vk) = self.pk_and_vk.get_or_init(|| {
-            CompressedSNARK::<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap()
-        });
+    pub fn pk(&self) -> &ProverKey<E1<F>, SS1<F>, SS2<F>> {
+        let (pk, _vk) = self
+            .pk_and_vk
+            .get_or_init(|| CompressedSNARK::<E1<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap());
         pk
     }
 
     /// provides a reference to a VerifierKey suitable for verifying a CompressedProof
-    pub fn vk(&self) -> &VerifierKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>> {
-        let (_pk, vk) = self.pk_and_vk.get_or_init(|| {
-            CompressedSNARK::<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap()
-        });
+    pub fn vk(&self) -> &VerifierKey<E1<F>, SS1<F>, SS2<F>> {
+        let (_pk, vk) = self
+            .pk_and_vk
+            .get_or_init(|| CompressedSNARK::<E1<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap());
         vk
     }
 }
 
-impl<F: CurveCycleEquipped, SC: StepCircuit<F>> From<NovaPublicParams<F, SC>>
-    for PublicParams<F, SC>
-{
-    fn from(pp: NovaPublicParams<F, SC>) -> PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> From<NovaPublicParams<F>> for PublicParams<F> {
+    fn from(pp: NovaPublicParams<F>) -> PublicParams<F> {
         PublicParams {
             pp,
             pk_and_vk: OnceCell::new(),
@@ -165,15 +160,16 @@ impl<F: CurveCycleEquipped, SC: StepCircuit<F>> From<NovaPublicParams<F, SC>>
 /// An enum representing the two types of proofs that can be generated and verified.
 #[derive(Serialize, Deserialize)]
 #[serde(bound = "")]
-pub enum Proof<F: CurveCycleEquipped, C1: StepCircuit<F>> {
+pub enum Proof<F: CurveCycleEquipped, S> {
     /// 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>, C1, C2<F>>>, usize),
+    Recursive(Box<RecursiveSNARK<E1<F>>>, usize, PhantomData<S>),
     /// A proof for the final step of a recursive computation along with the number
     /// of steps used for verification
     Compressed(
-        Box<CompressedSNARK<E1<F>, E2<F>, C1, C2<F>, SS1<F>, SS2<F>>>,
+        Box<CompressedSNARK<E1<F>, SS1<F>, SS2<F>>>,
         usize,
+        PhantomData<S>,
     ),
 }
 
@@ -189,18 +185,18 @@ pub fn circuit_cache_key<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
 ) -> F {
     let folding_config = Arc::new(FoldingConfig::new_ivc(lang, 2));
     let circuit = C1LEM::<'a, F, C>::blank(folding_config, 0);
-    F::from(rc as u64) * nova::circuit_digest::<F::E1, F::E2, _>(&circuit)
+    F::from(rc as u64) * nova::circuit_digest::<F::E1, _>(&circuit)
 }
 
 /// Generates the public parameters for the Nova proving system.
 pub fn public_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
     reduction_count: usize,
     lang: Arc<Lang<F, C>>,
-) -> PublicParams<F, C1LEM<'a, F, C>> {
+) -> PublicParams<F> {
     let (circuit_primary, circuit_secondary) = circuits(reduction_count, lang);
 
     let commitment_size_hint1 = <SS1<F> as RelaxedR1CSSNARKTrait<E1<F>>>::ck_floor();
-    let commitment_size_hint2 = <SS2<F> as RelaxedR1CSSNARKTrait<E2<F>>>::ck_floor();
+    let commitment_size_hint2 = <SS2<F> as RelaxedR1CSSNARKTrait<DualEng<E1<F>>>>::ck_floor();
 
     let pp = nova::PublicParams::setup(
         &circuit_primary,
@@ -229,13 +225,13 @@ pub fn circuits<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
 impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<'a, F, C>>
     for Proof<F, C1LEM<'a, F, C>>
 {
-    type PublicParams = PublicParams<F, C1LEM<'a, F, C>>;
+    type PublicParams = PublicParams<F>;
 
     type ErrorType = NovaError;
 
     #[tracing::instrument(skip_all, name = "nova::prove_recursively")]
     fn prove_recursively(
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &PublicParams<F>,
         z0: &[F],
         steps: Vec<C1LEM<'a, F, C>>,
         store: &Store<F>,
@@ -252,8 +248,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
         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>>> =
-            None;
+        let mut recursive_snark: Option<RecursiveSNARK<E1<F>>> = None;
 
         // the shadowing here is voluntary
         let recursive_snark = if lurk_config(None, None)
@@ -282,7 +277,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
                     let mut r_snark = recursive_snark.unwrap_or_else(|| {
                         RecursiveSNARK::new(
                             &pp.pp,
-                            &circuit_primary,
+                            &*circuit_primary,
                             &circuit_secondary,
                             z0_primary,
                             &z0_secondary,
@@ -290,7 +285,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
                         .expect("Failed to construct initial recursive snark")
                     });
                     r_snark
-                        .prove_step(&pp.pp, &circuit_primary, &circuit_secondary)
+                        .prove_step(&pp.pp, &*circuit_primary, &circuit_secondary)
                         .expect("failure to prove Nova step");
                     recursive_snark = Some(r_snark);
                 }
@@ -302,7 +297,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
                 if debug {
                     // For debugging purposes, synthesize the circuit and check that the constraint system is satisfied.
                     use bellpepper_core::test_cs::TestConstraintSystem;
-                    let mut cs = TestConstraintSystem::<<E1<F> as Engine>::Scalar>::new();
+                    let mut cs = TestConstraintSystem::<F>::new();
 
                     let zi = store.to_scalar_vector(circuit_primary.input());
                     let zi_allocated: Vec<_> = zi
@@ -339,18 +334,20 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
         Ok(Self::Recursive(
             Box::new(recursive_snark.unwrap()),
             num_steps,
+            PhantomData,
         ))
     }
 
-    fn compress(self, pp: &PublicParams<F, C1LEM<'a, F, C>>) -> Result<Self, ProofError> {
+    fn compress(self, pp: &PublicParams<F>) -> Result<Self, ProofError> {
         match self {
-            Self::Recursive(recursive_snark, num_steps) => Ok(Self::Compressed(
-                Box::new(CompressedSNARK::<_, _, _, _, SS1<F>, SS2<F>>::prove(
+            Self::Recursive(recursive_snark, num_steps, _phantom) => Ok(Self::Compressed(
+                Box::new(CompressedSNARK::<_, SS1<F>, SS2<F>>::prove(
                     &pp.pp,
                     pp.pk(),
                     &recursive_snark,
                 )?),
                 num_steps,
+                PhantomData,
             )),
             Self::Compressed(..) => Ok(self),
         }
@@ -362,10 +359,10 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
         let zi_secondary = &z0_secondary;
 
         let (zi_primary_verified, zi_secondary_verified) = match self {
-            Self::Recursive(p, num_steps) => {
+            Self::Recursive(p, num_steps, _phantom) => {
                 p.verify(&pp.pp, *num_steps, z0_primary, &z0_secondary)?
             }
-            Self::Compressed(p, num_steps) => {
+            Self::Compressed(p, num_steps, _phantom) => {
                 p.verify(pp.vk(), *num_steps, z0_primary, &z0_secondary)?
             }
         };
@@ -399,7 +396,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> NovaProver<'a, F, C> {
     /// Generate a proof from a sequence of frames
     pub fn prove_from_frames(
         &self,
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &PublicParams<F>,
         frames: &[Frame],
         store: &'a Store<F>,
     ) -> Result<(Proof<F, C1LEM<'a, F, C>>, Vec<F>, Vec<F>, usize), ProofError> {
@@ -419,7 +416,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> NovaProver<'a, F, C> {
 impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> Prover<'a, F, C1LEM<'a, F, C>>
     for NovaProver<'a, F, C>
 {
-    type PublicParams = PublicParams<F, C1LEM<'a, F, C>>;
+    type PublicParams = PublicParams<F>;
     type RecursiveSnark = Proof<F, C1LEM<'a, F, C>>;
 
     #[inline]
diff --git a/src/proof/supernova.rs b/src/proof/supernova.rs
index 9809be3fea..619143c143 100644
--- a/src/proof/supernova.rs
+++ b/src/proof/supernova.rs
@@ -3,12 +3,11 @@ use nova::{
         self,
         error::SuperNovaError,
         snark::{CompressedSNARK, ProverKey, VerifierKey},
-        AuxParams, CircuitDigests, NonUniformCircuit, RecursiveSNARK,
-        StepCircuit as SuperStepCircuit, TrivialSecondaryCircuit,
+        AuxParams, CircuitDigests, NonUniformCircuit, RecursiveSNARK, TrivialSecondaryCircuit,
     },
     traits::{
         snark::{BatchedRelaxedR1CSSNARKTrait, RelaxedR1CSSNARKTrait},
-        Engine,
+        Dual as DualEng,
     },
 };
 use once_cell::sync::OnceCell;
@@ -29,7 +28,7 @@ use crate::{
     field::LurkField,
     lem::{interpreter::Frame, pointers::Ptr, store::Store},
     proof::{
-        nova::{CurveCycleEquipped, NovaCircuitShape, E1, E2},
+        nova::{CurveCycleEquipped, Dual, NovaCircuitShape, E1},
         Prover, RecursiveSNARKTrait,
     },
 };
@@ -37,48 +36,46 @@ use crate::{
 use super::{nova::C1LEM, FoldingMode};
 
 /// Type alias for a Trivial Test Circuit with G2 scalar field elements.
-pub type C2<F> = TrivialSecondaryCircuit<<E2<F> as Engine>::Scalar>;
+pub type C2<F> = TrivialSecondaryCircuit<Dual<F>>;
 
 /// Type alias for SuperNova Aux Parameters with the curve cycle types defined above.
-pub type SuperNovaAuxParams<F> = AuxParams<E1<F>, E2<F>>;
+pub type SuperNovaAuxParams<F> = AuxParams<E1<F>>;
 
 /// Type alias for SuperNova Public Parameters with the curve cycle types defined above.
-pub type SuperNovaPublicParams<F, C1> = supernova::PublicParams<E1<F>, E2<F>, C1, C2<F>>;
+pub type SuperNovaPublicParams<F> = supernova::PublicParams<E1<F>>;
 
 /// A struct that contains public parameters for the SuperNova proving system.
-pub struct PublicParams<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> {
+pub struct PublicParams<F: CurveCycleEquipped> {
     /// Public params for SuperNova.
-    pub pp: SuperNovaPublicParams<F, SC>,
+    pub pp: SuperNovaPublicParams<F>,
     /// Prover key and Verifier key for SuperNova
     // TODO: mark as #[serde(skip)] when serializing
     pub pk_and_vk: OnceCell<(
-        ProverKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>,
-        VerifierKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>,
+        ProverKey<E1<F>, SS1<F>, SS2<F>>,
+        VerifierKey<E1<F>, SS1<F>, SS2<F>>,
     )>,
 }
 
-impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> PublicParams<F> {
     /// provides a reference to a ProverKey suitable for producing a CompressedProof
-    pub fn pk(&self) -> &ProverKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>> {
-        let (pk, _vk) = self.pk_and_vk.get_or_init(|| {
-            CompressedSNARK::<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap()
-        });
+    pub fn pk(&self) -> &ProverKey<E1<F>, SS1<F>, SS2<F>> {
+        let (pk, _vk) = self
+            .pk_and_vk
+            .get_or_init(|| CompressedSNARK::<E1<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap());
         pk
     }
 
     /// provides a reference to a VerifierKey suitable for verifying a CompressedProof
-    pub fn vk(&self) -> &VerifierKey<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>> {
-        let (_pk, vk) = self.pk_and_vk.get_or_init(|| {
-            CompressedSNARK::<E1<F>, E2<F>, SC, C2<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap()
-        });
+    pub fn vk(&self) -> &VerifierKey<E1<F>, SS1<F>, SS2<F>> {
+        let (_pk, vk) = self
+            .pk_and_vk
+            .get_or_init(|| CompressedSNARK::<E1<F>, SS1<F>, SS2<F>>::setup(&self.pp).unwrap());
         vk
     }
 }
 
-impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> From<SuperNovaPublicParams<F, SC>>
-    for PublicParams<F, SC>
-{
-    fn from(pp: SuperNovaPublicParams<F, SC>) -> PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> From<SuperNovaPublicParams<F>> for PublicParams<F> {
+    fn from(pp: SuperNovaPublicParams<F>) -> PublicParams<F> {
         PublicParams {
             pp,
             pk_and_vk: OnceCell::new(),
@@ -86,7 +83,7 @@ impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> From<SuperNovaPublicParams<
     }
 }
 
-impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> Index<usize> for PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> Index<usize> for PublicParams<F> {
     type Output = NovaCircuitShape<F>;
 
     fn index(&self, index: usize) -> &Self::Output {
@@ -94,7 +91,7 @@ impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> Index<usize> for PublicPara
     }
 }
 
-impl<F: CurveCycleEquipped, SC: SuperStepCircuit<F>> PublicParams<F, SC> {
+impl<F: CurveCycleEquipped> PublicParams<F> {
     /// return the digest
     pub fn digest(&self) -> F {
         self.pp.digest()
@@ -113,21 +110,21 @@ pub type SS1<F> = nova::spartan::batched::BatchedRelaxedR1CSSNARK<E1<F>, EE1<F>>
 /// Type alias for the Relaxed R1CS Spartan SNARK using G2 group elements, EE2.
 // NOTE: this is not a SNARK that uses computational commitments,
 // that SNARK would be found at nova::spartan::ppsnark::RelaxedR1CSSNARK,
-pub type SS2<F> = nova::spartan::snark::RelaxedR1CSSNARK<E2<F>, EE2<F>>;
+pub type SS2<F> = nova::spartan::snark::RelaxedR1CSSNARK<DualEng<E1<F>>, EE2<F>>;
 
 /// Generates the running claim params for the SuperNova proving system.
-pub fn public_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
+pub fn public_params<F: CurveCycleEquipped, C: Coprocessor<F>>(
     rc: usize,
     lang: Arc<Lang<F, C>>,
-) -> PublicParams<F, C1LEM<'a, F, C>> {
+) -> PublicParams<F> {
     let folding_config = Arc::new(FoldingConfig::new_nivc(lang, rc));
-    let non_uniform_circuit = C1LEM::<'a, F, C>::blank(folding_config, 0);
+    let non_uniform_circuit = C1LEM::<'_, F, C>::blank(folding_config, 0);
 
     // grab hints for the compressed SNARK variants we will use this with
     let commitment_size_hint1 = <SS1<F> as BatchedRelaxedR1CSSNARKTrait<E1<F>>>::ck_floor();
-    let commitment_size_hint2 = <SS2<F> as RelaxedR1CSSNARKTrait<E2<F>>>::ck_floor();
+    let commitment_size_hint2 = <SS2<F> as RelaxedR1CSSNARKTrait<DualEng<E1<F>>>>::ck_floor();
 
-    let pp = SuperNovaPublicParams::<F, C1LEM<'a, F, C>>::setup(
+    let pp = SuperNovaPublicParams::<F>::setup(
         &non_uniform_circuit,
         &*commitment_size_hint1,
         &*commitment_size_hint2,
@@ -141,11 +138,11 @@ pub fn public_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
 /// An enum representing the two types of proofs that can be generated and verified.
 #[derive(Serialize, Deserialize)]
 #[serde(bound = "")]
-pub enum Proof<F: CurveCycleEquipped, C1: SuperStepCircuit<F>> {
+pub enum Proof<F: CurveCycleEquipped, S> {
     /// A proof for the intermediate steps of a recursive computation
-    Recursive(Box<RecursiveSNARK<E1<F>, E2<F>>>),
+    Recursive(Box<RecursiveSNARK<E1<F>>>, PhantomData<S>),
     /// A proof for the final step of a recursive computation
-    Compressed(Box<CompressedSNARK<E1<F>, E2<F>, C1, C2<F>, SS1<F>, SS2<F>>>),
+    Compressed(Box<CompressedSNARK<E1<F>, SS1<F>, SS2<F>>>, PhantomData<S>),
 }
 
 /// A struct for the Nova prover that operates on field elements of type `F`.
@@ -174,7 +171,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> SuperNovaProver<'a, F, C
     /// Generate a proof from a sequence of frames
     pub fn prove_from_frames(
         &self,
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &PublicParams<F>,
         frames: &[Frame],
         store: &'a Store<F>,
     ) -> Result<(Proof<F, C1LEM<'a, F, C>>, Vec<F>, Vec<F>, usize), ProofError> {
@@ -194,18 +191,18 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a> SuperNovaProver<'a, F, C
 impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<'a, F, C>>
     for Proof<F, C1LEM<'a, F, C>>
 {
-    type PublicParams = PublicParams<F, C1LEM<'a, F, C>>;
+    type PublicParams = PublicParams<F>;
 
     type ErrorType = SuperNovaError;
 
     #[tracing::instrument(skip_all, name = "supernova::prove_recursively")]
     fn prove_recursively(
-        pp: &PublicParams<F, C1LEM<'a, F, C>>,
+        pp: &PublicParams<F>,
         z0: &[F],
         steps: Vec<C1LEM<'a, F, C>>,
         store: &Store<F>,
     ) -> Result<Self, ProofError> {
-        let mut recursive_snark_option: Option<RecursiveSNARK<E1<F>, E2<F>>> = None;
+        let mut recursive_snark_option: Option<RecursiveSNARK<E1<F>>> = None;
 
         let z0_primary = z0;
         let z0_secondary = Self::z0_secondary();
@@ -293,20 +290,18 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
         }
 
         // This probably should be made unnecessary.
-        Ok(Self::Recursive(Box::new(
-            recursive_snark_option.expect("RecursiveSNARK missing"),
-        )))
+        Ok(Self::Recursive(
+            Box::new(recursive_snark_option.expect("RecursiveSNARK missing")),
+            PhantomData,
+        ))
     }
 
-    fn compress(self, pp: &PublicParams<F, C1LEM<'a, F, C>>) -> Result<Self, ProofError> {
+    fn compress(self, pp: &PublicParams<F>) -> Result<Self, ProofError> {
         match &self {
-            Self::Recursive(recursive_snark) => {
-                let snark = CompressedSNARK::<_, _, _, _, SS1<F>, SS2<F>>::prove(
-                    &pp.pp,
-                    pp.pk(),
-                    recursive_snark,
-                )?;
-                Ok(Self::Compressed(Box::new(snark)))
+            Self::Recursive(recursive_snark, _phantom) => {
+                let snark =
+                    CompressedSNARK::<_, SS1<F>, SS2<F>>::prove(&pp.pp, pp.pk(), recursive_snark)?;
+                Ok(Self::Compressed(Box::new(snark), PhantomData))
             }
             Self::Compressed(..) => Ok(self),
         }
@@ -318,8 +313,10 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
         let zi_secondary = &z0_secondary;
 
         let (zi_primary_verified, zi_secondary_verified) = match self {
-            Self::Recursive(p) => p.verify(&pp.pp, z0_primary, &z0_secondary)?,
-            Self::Compressed(p) => p.verify(&pp.pp, pp.vk(), z0_primary, &z0_secondary)?,
+            Self::Recursive(p, _phantom) => p.verify(&pp.pp, z0_primary, &z0_secondary)?,
+            Self::Compressed(p, _phantom) => {
+                p.verify(&pp.pp, pp.vk(), z0_primary, &z0_secondary)?
+            }
         };
 
         Ok(zi_primary == zi_primary_verified && zi_secondary == &zi_secondary_verified)
@@ -329,7 +326,7 @@ impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> RecursiveSNARKTrait<F, C1LEM<
 impl<'a, F: CurveCycleEquipped, C: Coprocessor<F>> Prover<'a, F, C1LEM<'a, F, C>>
     for SuperNovaProver<'a, F, C>
 {
-    type PublicParams = PublicParams<F, C1LEM<'a, F, C>>;
+    type PublicParams = PublicParams<F>;
     type RecursiveSnark = Proof<F, C1LEM<'a, F, C>>;
 
     #[inline]
@@ -423,7 +420,7 @@ pub fn circuit_cache_key<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
     let circuit = C1LEM::<'a, F, C>::blank(folding_config, 0);
     let num_circuits = circuit.num_circuits();
     let circuit = circuit.primary_circuit(circuit_index);
-    F::from(rc as u64) * supernova::circuit_digest::<F::E1, F::E2, _>(&circuit, num_circuits)
+    F::from(rc as u64) * supernova::circuit_digest::<F::E1, _>(&circuit, num_circuits)
 }
 
 /// Collects all the cache keys of supernova instance. We need all of them to compute
diff --git a/src/proof/tests/mod.rs b/src/proof/tests/mod.rs
index 649f8d3d10..3bed17ed0b 100644
--- a/src/proof/tests/mod.rs
+++ b/src/proof/tests/mod.rs
@@ -1,4 +1,4 @@
-mod nova_tests_lem;
+mod nova_tests;
 use bellpepper::util_cs::{metric_cs::MetricCS, witness_cs::WitnessCS, Comparable};
 use bellpepper_core::{test_cs::TestConstraintSystem, Circuit, ConstraintSystem, Delta};
 use expect_test::Expect;
@@ -130,7 +130,8 @@ fn nova_test_full_aux2<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
         }
         assert!(res.unwrap());
 
-        let compressed = proof.compress(&pp).unwrap();
+        let compressed: crate::proof::nova::Proof<F, C1LEM<'a, F, C>> =
+            proof.compress(&pp).unwrap();
         let res2 = compressed.verify(&pp, &z0, &zi);
 
         assert!(res2.unwrap());
diff --git a/src/proof/tests/nova_tests_lem.rs b/src/proof/tests/nova_tests.rs
similarity index 100%
rename from src/proof/tests/nova_tests_lem.rs
rename to src/proof/tests/nova_tests.rs
diff --git a/src/public_parameters/disk_cache.rs b/src/public_parameters/disk_cache.rs
index 0f23913fa1..87fa3345eb 100644
--- a/src/public_parameters/disk_cache.rs
+++ b/src/public_parameters/disk_cache.rs
@@ -7,7 +7,7 @@ use camino::{Utf8Path, Utf8PathBuf};
 
 use crate::config::lurk_config;
 use crate::coprocessor::Coprocessor;
-use crate::proof::nova::{CurveCycleEquipped, PublicParams, C1LEM};
+use crate::proof::nova::{CurveCycleEquipped, PublicParams};
 use crate::public_parameters::error::Error;
 
 use super::instance::Instance;
@@ -37,10 +37,7 @@ impl<F: CurveCycleEquipped, C: Coprocessor<F>> DiskCache<F, C> {
         })
     }
 
-    pub(crate) fn read<'a>(
-        &self,
-        instance: &Instance<F, C>,
-    ) -> Result<PublicParams<F, C1LEM<'a, F, C>>, Error> {
+    pub(crate) fn read(&self, instance: &Instance<F, C>) -> Result<PublicParams<F>, Error> {
         let file = instance.open(&self.dir)?;
         let reader = BufReader::new(file);
         bincode::deserialize_from(reader)
@@ -61,7 +58,7 @@ impl<F: CurveCycleEquipped, C: Coprocessor<F>> DiskCache<F, C> {
     pub(crate) fn write(
         &self,
         instance: &Instance<F, C>,
-        data: &PublicParams<F, C1LEM<'_, F, C>>,
+        data: &PublicParams<F>,
     ) -> Result<(), Error> {
         let file = instance.create(&self.dir)?;
         let writer = BufWriter::new(&file);
diff --git a/src/public_parameters/mod.rs b/src/public_parameters/mod.rs
index 1afdbc9c38..01dc7202a2 100644
--- a/src/public_parameters/mod.rs
+++ b/src/public_parameters/mod.rs
@@ -1,12 +1,12 @@
-use ::nova::{supernova::FlatAuxParams, traits::Engine, FlatPublicParams};
+use ::nova::{supernova::FlatAuxParams, FlatPublicParams};
 use abomonation::{decode, Abomonation};
 use once_cell::sync::OnceCell;
 use tap::TapFallible;
 use tracing::{info, warn};
 
 use crate::coprocessor::Coprocessor;
-use crate::proof::nova::{self, NovaCircuitShape, NovaPublicParams, PublicParams, C1LEM};
-use crate::proof::nova::{CurveCycleEquipped, C2, E1, E2};
+use crate::proof::nova::{self, NovaCircuitShape, NovaPublicParams, PublicParams};
+use crate::proof::nova::{CurveCycleEquipped, Dual, E1};
 
 pub mod disk_cache;
 mod error;
@@ -17,12 +17,12 @@ use crate::public_parameters::disk_cache::{public_params_dir, DiskCache};
 use crate::public_parameters::error::Error;
 use crate::public_parameters::instance::Instance;
 
-pub fn public_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'static>(
+pub fn public_params<F: CurveCycleEquipped, C: Coprocessor<F>>(
     instance: &Instance<F, C>,
-) -> Result<PublicParams<F, C1LEM<'a, F, C>>, Error>
+) -> Result<PublicParams<F>, Error>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    <F as ff::PrimeField>::Repr: Abomonation,
+    <Dual<F> as ff::PrimeField>::Repr: Abomonation,
 {
     let default = |instance: &Instance<F, C>| nova::public_params(instance.rc, instance.lang());
 
@@ -35,13 +35,9 @@ where
         match disk_cache.read_bytes(instance, &mut bytes) {
             Ok(()) => {
                 info!("loading abomonated {}", instance.key());
-                let (pp, rest) = unsafe {
-                    decode::<FlatPublicParams<E1<F>, E2<F>, C1LEM<'a, F, C>, C2<F>>>(&mut bytes)
-                        .unwrap()
-                };
+                let (pp, rest) = unsafe { decode::<FlatPublicParams<E1<F>>>(&mut bytes).unwrap() };
                 assert!(rest.is_empty());
-                let pp =
-                    PublicParams::from(NovaPublicParams::<F, C1LEM<'a, F, C>>::from(pp.clone())); // this clone is VERY expensive
+                let pp = PublicParams::from(NovaPublicParams::<F>::from(pp.clone())); // this clone is VERY expensive
                 Ok(pp)
             }
             Err(Error::IO(e)) => {
@@ -54,9 +50,7 @@ where
                     .write_abomonated(instance, &fp)
                     .tap_ok(|_| info!("writing public params to disk-cache: {}", instance.key()))
                     .map_err(|e| Error::Cache(format!("Disk write error: {e}")))?;
-                Ok(PublicParams::from(
-                    NovaPublicParams::<F, C1LEM<'a, F, C>>::from(fp),
-                ))
+                Ok(PublicParams::from(NovaPublicParams::<F>::from(fp)))
             }
             _ => unreachable!(),
         }
@@ -80,8 +74,8 @@ pub fn supernova_circuit_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + '
     instance: &Instance<F, C>,
 ) -> Result<NovaCircuitShape<F>, Error>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    <F as ff::PrimeField>::Repr: Abomonation,
+    <Dual<F> as ff::PrimeField>::Repr: Abomonation,
 {
     let disk_cache = DiskCache::<F, C>::new(public_params_dir()).unwrap();
 
@@ -101,15 +95,15 @@ pub fn supernova_aux_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
     instance: &Instance<F, C>,
 ) -> Result<SuperNovaAuxParams<F>, Error>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    <F as ff::PrimeField>::Repr: Abomonation,
+    <Dual<F> as ff::PrimeField>::Repr: Abomonation,
 {
     let disk_cache = DiskCache::<F, C>::new(public_params_dir()).unwrap();
 
     let mut bytes = vec![];
     disk_cache.read_bytes(instance, &mut bytes).and_then(|()| {
         if let Some((flat_aux_params, remaining)) =
-            unsafe { decode::<FlatAuxParams<E1<F>, E2<F>>>(&mut bytes) }
+            unsafe { decode::<FlatAuxParams<E1<F>>>(&mut bytes) }
         {
             assert!(remaining.is_empty());
             Ok(SuperNovaAuxParams::<F>::from(flat_aux_params.clone()))
@@ -122,14 +116,13 @@ where
 /// Attempts to extract abomonated public parameters.
 pub fn supernova_public_params<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a>(
     instance_primary: &Instance<F, C>,
-) -> Result<supernova::PublicParams<F, C1LEM<'a, F, C>>, Error>
+) -> Result<supernova::PublicParams<F>, Error>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    <F as ff::PrimeField>::Repr: Abomonation,
+    <Dual<F> as ff::PrimeField>::Repr: Abomonation,
 {
-    let default = |instance: &Instance<F, C>| {
-        supernova::public_params::<'a, F, C>(instance.rc, instance.lang())
-    };
+    let default =
+        |instance: &Instance<F, C>| supernova::public_params::<F, C>(instance.rc, instance.lang());
     let disk_cache = DiskCache::<F, C>::new(public_params_dir()).unwrap();
 
     let maybe_circuit_params_vec = instance_primary
@@ -145,10 +138,7 @@ where
     {
         println!("generating public params");
 
-        let pp = SuperNovaPublicParams::<F, C1LEM<'a, F, C>>::from_parts_unchecked(
-            circuit_params_vec,
-            aux_params,
-        );
+        let pp = SuperNovaPublicParams::<F>::from_parts_unchecked(circuit_params_vec, aux_params);
 
         supernova::PublicParams {
             pp,
@@ -160,7 +150,7 @@ where
 
         let (circuit_params_vec, aux_params) = pp.pp.into_parts();
 
-        let flat_aux_params = FlatAuxParams::<E1<F>, E2<F>>::try_from(aux_params).unwrap();
+        let flat_aux_params = FlatAuxParams::<E1<F>>::try_from(aux_params).unwrap();
         disk_cache.write_abomonated(instance_primary, &flat_aux_params)?;
         let aux_params = SuperNovaAuxParams::<F>::from(flat_aux_params);
 
@@ -169,10 +159,7 @@ where
             disk_cache.write_abomonated(&instance, circuit_params)?;
         }
 
-        let pp = SuperNovaPublicParams::<F, C1LEM<'a, F, C>>::from_parts_unchecked(
-            circuit_params_vec,
-            aux_params,
-        );
+        let pp = SuperNovaPublicParams::<F>::from_parts_unchecked(circuit_params_vec, aux_params);
 
         supernova::PublicParams {
             pp,
@@ -197,7 +184,7 @@ mod tests {
         let tmp_dir = Builder::new().prefix("tmp").tempdir().unwrap();
         std::env::set_var("LURK_PUBLIC_PARAMS", tmp_dir.path());
 
-        let lang: Arc<Lang<S1, Coproc<S1>>> = Arc::new(Lang::new());
+        let lang: Arc<Lang<S1>> = Arc::new(Lang::new());
         let instance = Instance::new(10, lang, true, Kind::NovaPublicParams);
         // Without disk cache, writes to tmpfile
         let _public_params = public_params::<S1, Coproc<S1>>(&instance).unwrap();