diff --git a/src/cyclefold/gadgets.rs b/src/cyclefold/gadgets.rs
index bdf59eb7b..6a2c0043d 100644
--- a/src/cyclefold/gadgets.rs
+++ b/src/cyclefold/gadgets.rs
@@ -61,8 +61,6 @@ pub mod emulated {
 
   use super::*;
 
-  use std::marker::PhantomData;
-
   use crate::{
     constants::{/*BN_N_LIMBS,*/ NUM_CHALLENGE_BITS, NUM_FE_IN_EMULATED_POINT, /*NUM_FE_FOR_RO*/},
     gadgets::{
@@ -72,37 +70,34 @@ pub mod emulated {
         conditionally_select_bignat, le_bits_to_num, /*scalar_as_base,*/
       },
     },
-    traits::{Group, ROConstantsCircuit},
+    traits::{CurveCycleEquipped, Dual, Group, ROConstantsCircuit},
     RelaxedR1CSInstance,
   };
 
   use ff::Field;
 
   #[derive(Clone)]
-  pub struct AllocatedPoint<E1, E2>
+  pub struct AllocatedPoint<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
-    x: BigNat<E1::Base>,
-    y: BigNat<E1::Base>,
-    is_infinity: AllocatedNum<E1::Base>,
-    _p: PhantomData<E2>,
+    x: BigNat<E::Base>,
+    y: BigNat<E::Base>,
+    is_infinity: AllocatedNum<E::Base>,
   }
 
-  impl<E1, E2> AllocatedPoint<E1, E2>
+  impl<E> AllocatedPoint<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
     pub fn alloc<CS>(
       mut cs: CS,
-      coords: Option<(E2::Base, E2::Base, bool)>,
+      coords: Option<(<Dual<E> as Engine>::Base, <Dual<E> as Engine>::Base, bool)>,
       limb_width: usize,
       n_limbs: usize,
     ) -> Result<Self, SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       let x = BigNat::alloc_from_nat(
         cs.namespace(|| "x"),
@@ -128,9 +123,9 @@ pub mod emulated {
 
       let is_infinity = AllocatedNum::alloc(cs.namespace(|| "is_infinity"), || {
         Ok(if coords.map_or(true, |c| c.2) {
-          E1::Base::ONE
+          E::Base::ONE
         } else {
-          E1::Base::ZERO
+          E::Base::ZERO
         })
       })?;
       cs.enforce(
@@ -139,17 +134,12 @@ pub mod emulated {
         |lc| lc + CS::one() - is_infinity.get_variable(),
         |lc| lc,
       );
-      Ok(Self {
-        x,
-        y,
-        is_infinity,
-        _p: PhantomData,
-      })
+      Ok(Self { x, y, is_infinity })
     }
 
-    pub fn absorb_in_ro<CS>(&self, mut cs: CS, ro: &mut E1::ROCircuit) -> Result<(), SynthesisError>
+    pub fn absorb_in_ro<CS>(&self, mut cs: CS, ro: &mut E::ROCircuit) -> Result<(), SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       let x_bn = self
         .x
@@ -159,7 +149,7 @@ pub mod emulated {
         .map(|(i, limb)| {
           limb.as_allocated_num(cs.namespace(|| format!("convert limb {i} of comm.x to num")))
         })
-        .collect::<Result<Vec<AllocatedNum<E1::Base>>, _>>()?;
+        .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
       for limb in x_bn {
         ro.absorb(&limb)
@@ -173,7 +163,7 @@ pub mod emulated {
         .map(|(i, limb)| {
           limb.as_allocated_num(cs.namespace(|| format!("convert limb {i} of comm.y to num")))
         })
-        .collect::<Result<Vec<AllocatedNum<E1::Base>>, _>>()?;
+        .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
       for limb in y_bn {
         ro.absorb(&limb)
@@ -191,25 +181,25 @@ pub mod emulated {
       n_limbs: usize,
     ) -> Result<(), SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       let m_bn = alloc_bignat_constant(
         cs.namespace(|| "alloc m"),
-        &E1::GE::group_params().3,
+        &E::GE::group_params().3,
         limb_width,
         n_limbs,
       )?;
 
       let A_bn = alloc_bignat_constant(
         cs.namespace(|| "alloc A"),
-        &f_to_nat(&E1::GE::group_params().0),
+        &f_to_nat(&E::GE::group_params().0),
         limb_width,
         n_limbs,
       )?;
 
       let B_bn = alloc_bignat_constant(
         cs.namespace(|| "alloc B"),
-        &f_to_nat(&E1::GE::group_params().1),
+        &f_to_nat(&E::GE::group_params().1),
         limb_width,
         n_limbs,
       )?;
@@ -228,7 +218,7 @@ pub mod emulated {
         self
           .is_infinity
           .get_value()
-          .map(|is_infinity| is_infinity == E1::Base::ONE),
+          .map(|is_infinity| is_infinity == E::Base::ONE),
       )?;
 
       cs.enforce(
@@ -243,7 +233,7 @@ pub mod emulated {
       Ok(())
     }
 
-    fn conditionally_select<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+    fn conditionally_select<CS: ConstraintSystem<E::Base>>(
       &self,
       mut cs: CS,
       other: &Self,
@@ -270,70 +260,57 @@ pub mod emulated {
         condition,
       )?;
 
-      Ok(Self {
-        x,
-        y,
-        is_infinity,
-        _p: PhantomData,
-      })
+      Ok(Self { x, y, is_infinity })
     }
 
-    pub fn default<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+    pub fn default<CS: ConstraintSystem<E::Base>>(
       mut cs: CS,
       limb_width: usize,
       n_limbs: usize,
     ) -> Result<Self, SynthesisError> {
       let x = BigNat::alloc_from_nat(
         cs.namespace(|| "allocate x_default = 0"),
-        || Ok(f_to_nat(&E1::Scalar::ZERO)),
+        || Ok(f_to_nat(&E::Scalar::ZERO)),
         limb_width,
         n_limbs,
       )?;
 
       let y = BigNat::alloc_from_nat(
         cs.namespace(|| "allocate y_default = 0"),
-        || Ok(f_to_nat(&E1::Scalar::ZERO)),
+        || Ok(f_to_nat(&E::Scalar::ZERO)),
         limb_width,
         n_limbs,
       )?;
 
       let is_infinity = alloc_one(cs.namespace(|| "one"));
 
-      Ok(Self {
-        x,
-        y,
-        is_infinity,
-        _p: PhantomData,
-      })
+      Ok(Self { x, y, is_infinity })
     }
   }
 
-  pub struct AllocatedRelaxedR1CSInstance<E1, E2>
+  pub struct AllocatedRelaxedR1CSInstance<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
-    comm_W: AllocatedPoint<E1, E2>,
-    comm_E: AllocatedPoint<E1, E2>,
-    u: AllocatedNum<E1::Base>,
-    x0: AllocatedNum<E1::Base>,
-    x1: AllocatedNum<E1::Base>,
-    pub _p: PhantomData<E2>,
+    comm_W: AllocatedPoint<E>,
+    comm_E: AllocatedPoint<E>,
+    u: AllocatedNum<E::Base>,
+    x0: AllocatedNum<E::Base>,
+    x1: AllocatedNum<E::Base>,
   }
 
-  impl<E1, E2> AllocatedRelaxedR1CSInstance<E1, E2>
+  impl<E> AllocatedRelaxedR1CSInstance<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
     pub fn alloc<CS>(
       mut cs: CS,
-      inst: Option<&RelaxedR1CSInstance<E2>>,
+      inst: Option<&RelaxedR1CSInstance<Dual<E>>>,
       limb_width: usize,
       n_limbs: usize,
     ) -> Result<Self, SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       let comm_W = AllocatedPoint::alloc(
         cs.namespace(|| "allocate comm_W"),
@@ -350,15 +327,15 @@ pub mod emulated {
       )?;
 
       let u = AllocatedNum::alloc(cs.namespace(|| "allocate u"), || {
-        inst.map_or(Ok(E1::Base::ZERO), |inst| Ok(inst.u))
+        inst.map_or(Ok(E::Base::ZERO), |inst| Ok(inst.u))
       })?;
 
       let x0 = AllocatedNum::alloc(cs.namespace(|| "allocate x0"), || {
-        inst.map_or(Ok(E1::Base::ZERO), |inst| Ok(inst.X[0]))
+        inst.map_or(Ok(E::Base::ZERO), |inst| Ok(inst.X[0]))
       })?;
 
       let x1 = AllocatedNum::alloc(cs.namespace(|| "allocate x1"), || {
-        inst.map_or(Ok(E1::Base::ZERO), |inst| Ok(inst.X[1]))
+        inst.map_or(Ok(E::Base::ZERO), |inst| Ok(inst.X[1]))
       })?;
 
       Ok(Self {
@@ -367,23 +344,22 @@ pub mod emulated {
         u,
         x0,
         x1,
-        _p: PhantomData,
       })
     }
 
-    pub fn fold_with_r1cs<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+    pub fn fold_with_r1cs<CS: ConstraintSystem<E::Base>>(
       &self,
       mut cs: CS,
-      pp_digest: &AllocatedNum<E1::Base>,
-      W_new: AllocatedPoint<E1, E2>,
-      E_new: AllocatedPoint<E1, E2>,
-      u_W: &AllocatedPoint<E1, E2>,
-      u_x0: &AllocatedNum<E1::Base>,
-      u_x1: &AllocatedNum<E1::Base>,
-      comm_T: &AllocatedPoint<E1, E2>,
-      ro_consts: ROConstantsCircuit<E1>,
+      pp_digest: &AllocatedNum<E::Base>,
+      W_new: AllocatedPoint<E>,
+      E_new: AllocatedPoint<E>,
+      u_W: &AllocatedPoint<E>,
+      u_x0: &AllocatedNum<E::Base>,
+      u_x1: &AllocatedNum<E::Base>,
+      comm_T: &AllocatedPoint<E>,
+      ro_consts: ROConstantsCircuit<E>,
     ) -> Result<Self, SynthesisError> {
-      let mut ro = E1::ROCircuit::new(
+      let mut ro = E::ROCircuit::new(
         ro_consts,
         1 + NUM_FE_IN_EMULATED_POINT + 2 + NUM_FE_IN_EMULATED_POINT, // pp_digest + u.W + u.x + comm_T
       );
@@ -439,13 +415,12 @@ pub mod emulated {
         u: u_fold,
         x0: x0_fold,
         x1: x1_fold,
-        _p: PhantomData,
       })
     }
 
-    pub fn absorb_in_ro<CS>(&self, mut cs: CS, ro: &mut E1::ROCircuit) -> Result<(), SynthesisError>
+    pub fn absorb_in_ro<CS>(&self, mut cs: CS, ro: &mut E::ROCircuit) -> Result<(), SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       self
         .comm_E
@@ -461,7 +436,7 @@ pub mod emulated {
       Ok(())
     }
 
-    pub fn conditionally_select<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+    pub fn conditionally_select<CS: ConstraintSystem<E::Base>>(
       &self,
       mut cs: CS,
       other: &Self,
@@ -506,11 +481,10 @@ pub mod emulated {
         u,
         x0,
         x1,
-        _p: PhantomData,
       })
     }
 
-    pub fn default<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+    pub fn default<CS: ConstraintSystem<E::Base>>(
       mut cs: CS,
       limb_width: usize,
       n_limbs: usize,
@@ -529,36 +503,32 @@ pub mod emulated {
         u,
         x0,
         x1,
-        _p: PhantomData,
       })
     }
   }
-  pub struct AllocatedFoldingData<E1, E2>
+  pub struct AllocatedFoldingData<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
-    pub U: AllocatedRelaxedR1CSInstance<E1, E2>,
-    pub u_W: AllocatedPoint<E1, E2>,
-    pub u_x0: AllocatedNum<E1::Base>,
-    pub u_x1: AllocatedNum<E1::Base>,
-    pub T: AllocatedPoint<E1, E2>,
-    _p: PhantomData<E2>,
+    pub U: AllocatedRelaxedR1CSInstance<E>,
+    pub u_W: AllocatedPoint<E>,
+    pub u_x0: AllocatedNum<E::Base>,
+    pub u_x1: AllocatedNum<E::Base>,
+    pub T: AllocatedPoint<E>,
   }
 
-  impl<E1, E2> AllocatedFoldingData<E1, E2>
+  impl<E> AllocatedFoldingData<E>
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
     pub fn alloc<CS>(
       mut cs: CS,
-      inst: Option<&FoldingData<E2>>,
+      inst: Option<&FoldingData<Dual<E>>>,
       limb_width: usize,
       n_limbs: usize,
     ) -> Result<Self, SynthesisError>
     where
-      CS: ConstraintSystem<<E1 as Engine>::Base>,
+      CS: ConstraintSystem<E::Base>,
     {
       let U = AllocatedRelaxedR1CSInstance::alloc(
         cs.namespace(|| "allocate U"),
@@ -575,11 +545,11 @@ pub mod emulated {
       )?;
 
       let u_x0 = AllocatedNum::alloc(cs.namespace(|| "allocate u_x0"), || {
-        inst.map_or(Ok(E1::Base::ZERO), |inst| Ok(inst.u.X[0]))
+        inst.map_or(Ok(E::Base::ZERO), |inst| Ok(inst.u.X[0]))
       })?;
 
       let u_x1 = AllocatedNum::alloc(cs.namespace(|| "allocate u_x1"), || {
-        inst.map_or(Ok(E1::Base::ZERO), |inst| Ok(inst.u.X[1]))
+        inst.map_or(Ok(E::Base::ZERO), |inst| Ok(inst.u.X[1]))
       })?;
 
       let T = AllocatedPoint::alloc(
@@ -597,7 +567,6 @@ pub mod emulated {
         u_x0,
         u_x1,
         T,
-        _p: PhantomData,
       })
     }
 
diff --git a/src/cyclefold/nifs.rs b/src/cyclefold/nifs.rs
index c6cf0cb67..1d145cc86 100644
--- a/src/cyclefold/nifs.rs
+++ b/src/cyclefold/nifs.rs
@@ -1,7 +1,5 @@
 //! This module defines the needed wrong-field NIFS prover
 
-use std::marker::PhantomData;
-
 use ff::Field;
 
 use crate::{
@@ -12,15 +10,14 @@ use crate::{
     utils::scalar_as_base,
   },
   r1cs::{R1CSInstance, R1CSShape, R1CSWitness, RelaxedR1CSInstance, RelaxedR1CSWitness},
-  traits::{commitment::CommitmentTrait, /*AbsorbInROTrait,*/ Engine, ROConstants, ROTrait},
+  traits::{commitment::CommitmentTrait, CurveCycleEquipped, Dual, Engine, ROConstants, ROTrait},
   Commitment, CommitmentKey, CompressedCommitment,
 };
 
 /// TODO: Docs
-pub fn absorb_commitment<E1, E2>(comm: &Commitment<E1>, ro: &mut E2::RO)
+pub fn absorb_commitment<E>(comm: &Commitment<E>, ro: &mut <Dual<E> as Engine>::RO)
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
   let (x, y, is_infinity) = comm.to_coordinates();
 
@@ -28,24 +25,23 @@ where
   let y_limbs = nat_to_limbs(&f_to_nat(&y), BN_LIMB_WIDTH, BN_N_LIMBS).unwrap();
 
   for limb in x_limbs {
-    ro.absorb(scalar_as_base::<E2>(limb));
+    ro.absorb(scalar_as_base::<Dual<E>>(limb));
   }
   for limb in y_limbs {
-    ro.absorb(scalar_as_base::<E2>(limb));
+    ro.absorb(scalar_as_base::<Dual<E>>(limb));
   }
   if is_infinity {
-    ro.absorb(<E1 as Engine>::Scalar::ONE);
+    ro.absorb(E::Scalar::ONE);
   } else {
-    ro.absorb(<E1 as Engine>::Scalar::ZERO);
+    ro.absorb(E::Scalar::ZERO);
   }
 }
 
-fn absorb_r1cs<E1, E2>(u: &R1CSInstance<E1>, ro: &mut E2::RO)
+fn absorb_r1cs<E>(u: &R1CSInstance<E>, ro: &mut <Dual<E> as Engine>::RO)
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
-  absorb_commitment::<E1, E2>(&u.comm_W, ro);
+  absorb_commitment::<E>(&u.comm_W, ro);
   for x in &u.X {
     ro.absorb(*x);
   }
@@ -53,51 +49,48 @@ where
 
 /// A SNARK that holds the proof of a step of an incremental computation
 #[derive(Debug)]
-pub struct NIFS<E1, E2>
+pub struct NIFS<E>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
-  pub(crate) comm_T: CompressedCommitment<E1>,
-  _p: PhantomData<E2>,
+  pub(crate) comm_T: CompressedCommitment<E>,
 }
 
-impl<E1, E2> NIFS<E1, E2>
+impl<E> NIFS<E>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
   /// Takes a relaxed R1CS instance-witness pair (U1, W1) and an R1CS instance-witness pair (U2, W)
   /// and folds them into a new relaxed R1CS instance-witness pair (U, W) and a commitment to the
   /// cross term T. It also provides the challenge r used to fold the instances.
   pub fn prove(
-    ck: &CommitmentKey<E1>,
-    ro_consts: &ROConstants<E2>,
-    pp_digest: &E1::Scalar,
-    S: &R1CSShape<E1>,
-    U1: &RelaxedR1CSInstance<E1>,
-    W1: &RelaxedR1CSWitness<E1>,
-    U2: &R1CSInstance<E1>,
-    W2: &R1CSWitness<E1>,
+    ck: &CommitmentKey<E>,
+    ro_consts: &ROConstants<Dual<E>>,
+    pp_digest: &<Dual<E> as Engine>::Base,
+    S: &R1CSShape<E>,
+    U1: &RelaxedR1CSInstance<E>,
+    W1: &RelaxedR1CSWitness<E>,
+    U2: &R1CSInstance<E>,
+    W2: &R1CSWitness<E>,
   ) -> Result<
     (
       Self,
-      (RelaxedR1CSInstance<E1>, RelaxedR1CSWitness<E1>),
-      E1::Scalar,
+      (RelaxedR1CSInstance<E>, RelaxedR1CSWitness<E>),
+      <Dual<E> as Engine>::Base,
     ),
     NovaError,
   > {
-    let mut ro = E2::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
+    let mut ro = <Dual<E> as Engine>::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
 
     ro.absorb(*pp_digest);
 
-    absorb_r1cs::<E1, E2>(U2, &mut ro);
+    absorb_r1cs::<E>(U2, &mut ro);
 
     let (T, comm_T) = S.commit_T(ck, U1, W1, U2, W2)?;
 
-    absorb_commitment::<E1, E2>(&comm_T, &mut ro);
+    absorb_commitment::<E>(&comm_T, &mut ro);
 
-    let r = scalar_as_base::<E2>(ro.squeeze(NUM_CHALLENGE_BITS));
+    let r: E::Scalar = scalar_as_base::<Dual<E>>(ro.squeeze(NUM_CHALLENGE_BITS));
 
     let U = U1.fold(U2, &comm_T, &r);
 
@@ -106,7 +99,6 @@ where
     Ok((
       Self {
         comm_T: comm_T.compress(),
-        _p: PhantomData,
       },
       (U, W),
       r,
diff --git a/src/cyclefold/nova_circuit.rs b/src/cyclefold/nova_circuit.rs
index 6155684d6..08a58f7d0 100644
--- a/src/cyclefold/nova_circuit.rs
+++ b/src/cyclefold/nova_circuit.rs
@@ -10,7 +10,8 @@ use crate::{
   },
   r1cs::{R1CSInstance, RelaxedR1CSInstance},
   traits::{
-    circuit::StepCircuit, commitment::CommitmentTrait, Engine, ROCircuitTrait, ROConstantsCircuit,
+    circuit::StepCircuit, commitment::CommitmentTrait, CurveCycleEquipped, Dual, Engine,
+    ROCircuitTrait, ROConstantsCircuit,
   },
   Commitment,
 };
@@ -55,40 +56,38 @@ impl<E: Engine> FoldingData<E> {
 // TODO: This needs to take in the initial cyclefold relaxed R1CS instance as well
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct AugmentedCircuitInputs<E1, E2>
+pub struct AugmentedCircuitInputs<E>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
-  pp_digest: E1::Scalar,
-  i: E1::Base,
-  z0: Vec<E1::Base>,
+  pp_digest: <Dual<E> as Engine>::Base,
+  i: E::Base,
+  z0: Vec<E::Base>,
 
-  zi: Option<Vec<E1::Base>>,
-  data_p: Option<FoldingData<E2>>,
+  zi: Option<Vec<E::Base>>,
+  data_p: Option<FoldingData<Dual<E>>>,
 
-  data_c_1: Option<FoldingData<E1>>,
-  data_c_2: Option<FoldingData<E1>>,
+  data_c_1: Option<FoldingData<E>>,
+  data_c_2: Option<FoldingData<E>>,
 
-  E_new: Option<Commitment<E2>>,
-  W_new: Option<Commitment<E2>>,
+  E_new: Option<Commitment<Dual<E>>>,
+  W_new: Option<Commitment<Dual<E>>>,
 }
 
-impl<E1, E2> AugmentedCircuitInputs<E1, E2>
+impl<E> AugmentedCircuitInputs<E>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
   pub fn new(
-    pp_digest: E1::Scalar,
-    i: E1::Base,
-    z0: Vec<E1::Base>,
-    zi: Option<Vec<E1::Base>>,
-    data_p: Option<FoldingData<E2>>,
-    data_c_1: Option<FoldingData<E1>>,
-    data_c_2: Option<FoldingData<E1>>,
-    E_new: Option<Commitment<E2>>,
-    W_new: Option<Commitment<E2>>,
+    pp_digest: <Dual<E> as Engine>::Base,
+    i: E::Base,
+    z0: Vec<E::Base>,
+    zi: Option<Vec<E::Base>>,
+    data_p: Option<FoldingData<Dual<E>>>,
+    data_c_1: Option<FoldingData<E>>,
+    data_c_2: Option<FoldingData<E>>,
+    E_new: Option<Commitment<Dual<E>>>,
+    W_new: Option<Commitment<Dual<E>>>,
   ) -> Self {
     Self {
       pp_digest,
@@ -103,28 +102,26 @@ where
     }
   }
 }
-pub struct AugmentedCircuit<'a, E1, E2, SC>
+pub struct AugmentedCircuit<'a, E, SC>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  SC: StepCircuit<E2::Scalar>,
+  E: CurveCycleEquipped,
+  SC: StepCircuit<E::Base>,
 {
   params: &'a AugmentedCircuitParams,
-  ro_consts: ROConstantsCircuit<E1>,
-  inputs: Option<AugmentedCircuitInputs<E1, E2>>,
+  ro_consts: ROConstantsCircuit<E>,
+  inputs: Option<AugmentedCircuitInputs<E>>,
   step_circuit: &'a SC,
 }
 
-impl<'a, E1, E2, SC> AugmentedCircuit<'a, E1, E2, SC>
+impl<'a, E, SC> AugmentedCircuit<'a, E, SC>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  SC: StepCircuit<E2::Scalar>,
+  E: CurveCycleEquipped,
+  SC: StepCircuit<E::Base>,
 {
   pub const fn new(
     params: &'a AugmentedCircuitParams,
-    ro_consts: ROConstantsCircuit<E1>,
-    inputs: Option<AugmentedCircuitInputs<E1, E2>>,
+    ro_consts: ROConstantsCircuit<E>,
+    inputs: Option<AugmentedCircuitInputs<E>>,
     step_circuit: &'a SC,
   ) -> Self {
     Self {
@@ -135,25 +132,25 @@ where
     }
   }
 
-  fn alloc_witness<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+  fn alloc_witness<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
     arity: usize,
   ) -> Result<
     (
-      AllocatedNum<E1::Base>,                 // pp_digest
-      AllocatedNum<E1::Base>,                 // i
-      Vec<AllocatedNum<E1::Base>>,            // z0
-      Vec<AllocatedNum<E1::Base>>,            // zi
-      emulated::AllocatedFoldingData<E1, E2>, //data_p
-      AllocatedFoldingData<E1>,               // data_c_1
-      AllocatedFoldingData<E1>,               // data_c_2
-      emulated::AllocatedPoint<E1, E2>,       // E_new
-      emulated::AllocatedPoint<E1, E2>,       // W_new
+      AllocatedNum<E::Base>,             // pp_digest
+      AllocatedNum<E::Base>,             // i
+      Vec<AllocatedNum<E::Base>>,        // z0
+      Vec<AllocatedNum<E::Base>>,        // zi
+      emulated::AllocatedFoldingData<E>, //data_p
+      AllocatedFoldingData<E>,           // data_c_1
+      AllocatedFoldingData<E>,           // data_c_2
+      emulated::AllocatedPoint<E>,       // E_new
+      emulated::AllocatedPoint<E>,       // W_new
     ),
     SynthesisError,
   > {
-    let pp_digest = alloc_scalar_as_base::<E1, _>(
+    let pp_digest = alloc_scalar_as_base::<E, _>(
       cs.namespace(|| "params"),
       self.inputs.as_ref().map(|inputs| inputs.pp_digest),
     )?;
@@ -174,17 +171,17 @@ where
           Ok(self.inputs.get()?.z0[i])
         })
       })
-      .collect::<Result<Vec<AllocatedNum<E1::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     // Allocate zi. If inputs.zi is not provided (base case) allocate default value 0
-    let zero = vec![E1::Base::ZERO; arity];
+    let zero = vec![E::Base::ZERO; arity];
     let z_i = (0..arity)
       .map(|i| {
         AllocatedNum::alloc(cs.namespace(|| format!("zi_{i}")), || {
           Ok(self.inputs.get()?.zi.as_ref().unwrap_or(&zero)[i])
         })
       })
-      .collect::<Result<Vec<AllocatedNum<E1::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     let data_p = emulated::AllocatedFoldingData::alloc(
       cs.namespace(|| "data_p"),
@@ -255,13 +252,13 @@ where
     ))
   }
 
-  pub fn synthesize_base_case<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+  pub fn synthesize_base_case<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
   ) -> Result<
     (
-      AllocatedRelaxedR1CSInstance<E1>,
-      emulated::AllocatedRelaxedR1CSInstance<E1, E2>,
+      AllocatedRelaxedR1CSInstance<E>,
+      emulated::AllocatedRelaxedR1CSInstance<E>,
     ),
     SynthesisError,
   > {
@@ -280,29 +277,29 @@ where
     Ok((U_c_default, U_p_default))
   }
 
-  pub fn synthesize_non_base_case<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+  pub fn synthesize_non_base_case<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
-    pp_digest: &AllocatedNum<E1::Base>,
-    i: &AllocatedNum<E1::Base>,
-    z_0: &[AllocatedNum<E1::Base>],
-    z_i: &[AllocatedNum<E1::Base>],
-    data_p: &emulated::AllocatedFoldingData<E1, E2>,
-    data_c_1: &AllocatedFoldingData<E1>,
-    data_c_2: &AllocatedFoldingData<E1>,
-    E_new: &emulated::AllocatedPoint<E1, E2>,
-    W_new: &emulated::AllocatedPoint<E1, E2>,
+    pp_digest: &AllocatedNum<E::Base>,
+    i: &AllocatedNum<E::Base>,
+    z_0: &[AllocatedNum<E::Base>],
+    z_i: &[AllocatedNum<E::Base>],
+    data_p: &emulated::AllocatedFoldingData<E>,
+    data_c_1: &AllocatedFoldingData<E>,
+    data_c_2: &AllocatedFoldingData<E>,
+    E_new: &emulated::AllocatedPoint<E>,
+    W_new: &emulated::AllocatedPoint<E>,
     arity: usize,
   ) -> Result<
     (
-      AllocatedRelaxedR1CSInstance<E1>,
-      emulated::AllocatedRelaxedR1CSInstance<E1, E2>,
+      AllocatedRelaxedR1CSInstance<E>,
+      emulated::AllocatedRelaxedR1CSInstance<E>,
       AllocatedBit,
     ),
     SynthesisError,
   > {
     // Follows the outline written down here https://hackmd.io/@mpenciak/HybHrnNFT
-    let mut ro_p = E1::ROCircuit::new(
+    let mut ro_p = E::ROCircuit::new(
       self.ro_consts.clone(),
       2 + 2 * arity + 2 * NUM_FE_IN_EMULATED_POINT + 3,
     );
@@ -328,7 +325,7 @@ where
       &hash_p,
     )?;
 
-    let mut ro_c = E1::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF);
+    let mut ro_c = E::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF);
 
     ro_c.absorb(pp_digest);
     ro_c.absorb(i);
@@ -362,7 +359,7 @@ where
     )?;
 
     // Calculate h_int = H(pp, U_c_int)
-    let mut ro_c_int = E1::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF - 1);
+    let mut ro_c_int = E::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF - 1);
     ro_c_int.absorb(pp_digest);
     U_int.absorb_in_ro(cs.namespace(|| "absorb U_c_int"), &mut ro_c_int)?;
     let h_c_int_bits =
@@ -370,7 +367,7 @@ where
     let h_c_int = le_bits_to_num(cs.namespace(|| "intermediate hash"), &h_c_int_bits)?;
 
     // Calculate h_1 = H(pp, U_c_1)
-    let mut ro_c_1 = E1::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF - 1);
+    let mut ro_c_1 = E::ROCircuit::new(self.ro_consts.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF - 1);
     ro_c_1.absorb(pp_digest);
     data_c_2
       .U
@@ -411,10 +408,10 @@ where
     Ok((U_c, U_p, checks_pass))
   }
 
-  pub fn synthesize<CS: ConstraintSystem<<E1 as Engine>::Base>>(
+  pub fn synthesize<CS: ConstraintSystem<E::Base>>(
     self,
     cs: &mut CS,
-  ) -> Result<Vec<AllocatedNum<E1::Base>>, SynthesisError> {
+  ) -> Result<Vec<AllocatedNum<E::Base>>, SynthesisError> {
     // TODO: It's written down here https://hackmd.io/@mpenciak/HybHrnNFT
     let arity = self.step_circuit.arity();
 
@@ -468,7 +465,7 @@ where
 
     // Compute i + 1
     let i_new = AllocatedNum::alloc(cs.namespace(|| "i + 1"), || {
-      Ok(*i.get_value().get()? + E1::Base::ONE)
+      Ok(*i.get_value().get()? + E::Base::ONE)
     })?;
     cs.enforce(
       || "check i + 1",
@@ -495,7 +492,7 @@ where
       ));
     }
 
-    let mut ro_p = E1::ROCircuit::new(
+    let mut ro_p = E::ROCircuit::new(
       self.ro_consts.clone(),
       2 + 2 * arity + 2 * NUM_FE_IN_EMULATED_POINT + 3,
     );
@@ -511,7 +508,7 @@ where
     let hash_p_bits = ro_p.squeeze(cs.namespace(|| "hash_p_bits"), NUM_HASH_BITS)?;
     let hash_p = le_bits_to_num(cs.namespace(|| "hash_p"), &hash_p_bits)?;
 
-    let mut ro_c = E1::ROCircuit::new(self.ro_consts, NUM_FE_WITHOUT_IO_FOR_CRHF);
+    let mut ro_c = E::ROCircuit::new(self.ro_consts, NUM_FE_WITHOUT_IO_FOR_CRHF);
     ro_c.absorb(&pp_digest);
     ro_c.absorb(&i_new);
     Unew_c.absorb_in_ro(cs.namespace(|| "absorb Unew_c"), &mut ro_c)?;
@@ -530,32 +527,25 @@ mod test {
   use crate::{
     bellpepper::test_shape_cs::TestShapeCS,
     constants::{BN_LIMB_WIDTH, BN_N_LIMBS},
-    provider::{
-      Bn256Engine, GrumpkinEngine, PallasEngine, Secp256k1Engine, Secq256k1Engine, VestaEngine,
-    },
+    provider::{Bn256Engine, PallasEngine, Secp256k1Engine},
     traits::circuit::TrivialCircuit,
   };
 
   use super::*;
 
-  fn test_circuit_size_with<E1, E2>()
+  fn test_circuit_size_with<E>()
   where
-    E1: Engine<Base = <E2 as Engine>::Scalar>,
-    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E: CurveCycleEquipped,
   {
     let params = AugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS);
 
-    let ro_consts = ROConstantsCircuit::<E1>::default();
+    let ro_consts = ROConstantsCircuit::<E>::default();
 
-    let step_circuit = TrivialCircuit::<E2::Scalar>::default();
+    let step_circuit = TrivialCircuit::<E::Base>::default();
 
-    let circuit = AugmentedCircuit::<E1, E2, TrivialCircuit<E2::Scalar>>::new(
-      &params,
-      ro_consts,
-      None,
-      &step_circuit,
-    );
-    let mut cs: TestShapeCS<E2> = TestShapeCS::default();
+    let circuit =
+      AugmentedCircuit::<E, TrivialCircuit<E::Base>>::new(&params, ro_consts, None, &step_circuit);
+    let mut cs: TestShapeCS<Dual<E>> = TestShapeCS::default();
 
     let _ = circuit.synthesize(&mut cs);
 
@@ -568,8 +558,8 @@ mod test {
 
   #[test]
   fn test_circuit_size() {
-    test_circuit_size_with::<PallasEngine, VestaEngine>();
-    test_circuit_size_with::<Secp256k1Engine, Secq256k1Engine>();
-    test_circuit_size_with::<Bn256Engine, GrumpkinEngine>();
+    test_circuit_size_with::<PallasEngine>();
+    test_circuit_size_with::<Secp256k1Engine>();
+    test_circuit_size_with::<Bn256Engine>();
   }
 }
diff --git a/src/cyclefold/snark.rs b/src/cyclefold/snark.rs
index d0acb2173..7c8621331 100644
--- a/src/cyclefold/snark.rs
+++ b/src/cyclefold/snark.rs
@@ -19,8 +19,8 @@ use crate::{
     RelaxedR1CSWitness,
   },
   traits::{
-    circuit::StepCircuit, commitment::CommitmentTrait, AbsorbInROTrait, Engine, ROConstantsCircuit,
-    ROTrait,
+    circuit::StepCircuit, commitment::CommitmentTrait, AbsorbInROTrait, CurveCycleEquipped, Dual,
+    Engine, ROConstantsCircuit, ROTrait,
   },
   Commitment, CommitmentKey, DigestComputer, R1CSWithArity, ROConstants, ResourceBuffer,
   SimpleDigestible,
@@ -43,65 +43,60 @@ use serde::{Deserialize, Serialize};
 #[serde(bound = "")]
 #[abomonation_bounds(
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
-  <E1::Scalar as PrimeField>::Repr: Abomonation,
-  <E2::Scalar as PrimeField>::Repr: Abomonation,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 )]
-pub struct PublicParams<E1, E2, C1>
+pub struct PublicParams<E, C>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 {
   F_arity_primary: usize,
-  ro_consts_primary: ROConstants<E2>,
-  ro_consts_circuit_primary: ROConstantsCircuit<E2>,
-  ck_primary: CommitmentKey<E1>,
-  circuit_shape_primary: R1CSWithArity<E1>,
+  ro_consts_primary: ROConstants<Dual<E>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E>>,
+  ck_primary: CommitmentKey<E>,
+  circuit_shape_primary: R1CSWithArity<E>,
   augmented_circuit_params: AugmentedCircuitParams,
 
-  ro_consts_cyclefold: ROConstants<E2>,
-  ck_cyclefold: CommitmentKey<E2>,
-  circuit_shape_cyclefold: R1CSWithArity<E2>,
+  ro_consts_cyclefold: ROConstants<Dual<E>>,
+  ck_cyclefold: CommitmentKey<Dual<E>>,
+  circuit_shape_cyclefold: R1CSWithArity<Dual<E>>,
   #[abomonation_skip]
   #[serde(skip, default = "OnceCell::new")]
-  digest: OnceCell<E1::Scalar>,
-  _p: PhantomData<(E1, E2, C1)>,
+  digest: OnceCell<<Dual<E> as Engine>::Base>,
+  _p: PhantomData<C>,
 }
 
-impl<E1, E2, C1> PublicParams<E1, E2, C1>
+impl<E, C> PublicParams<E, C>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 {
   /// TODO: docs
   pub fn setup(
-    c_primary: &C1,
-    ck_hint1: &CommitmentKeyHint<E1>,
-    ck_hint_cyclefold: &CommitmentKeyHint<E2>,
+    c_primary: &C,
+    ck_hint1: &CommitmentKeyHint<E>,
+    ck_hint_cyclefold: &CommitmentKeyHint<Dual<E>>,
   ) -> Self {
     let F_arity_primary = c_primary.arity();
-    let ro_consts_primary = ROConstants::<E2>::default();
-    let ro_consts_circuit_primary = ROConstantsCircuit::<E2>::default();
+    let ro_consts_primary = ROConstants::<Dual<E>>::default();
+    let ro_consts_circuit_primary = ROConstantsCircuit::<Dual<E>>::default();
 
     let augmented_circuit_params = AugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS);
-    let circuit_primary: AugmentedCircuit<'_, E2, E1, C1> = AugmentedCircuit::new(
+    let circuit_primary: AugmentedCircuit<'_, E, C> = AugmentedCircuit::new(
       &augmented_circuit_params,
       ro_consts_circuit_primary.clone(),
       None,
       c_primary,
     );
-    let mut cs: ShapeCS<E1> = ShapeCS::new();
+    let mut cs: ShapeCS<E> = ShapeCS::new();
     let _ = circuit_primary.synthesize(&mut cs);
     let (r1cs_shape_primary, ck_primary) = cs.r1cs_shape_and_key(ck_hint1);
     let circuit_shape_primary = R1CSWithArity::new(r1cs_shape_primary, F_arity_primary);
 
-    let ro_consts_cyclefold = ROConstants::<E2>::default();
-    let mut cs: ShapeCS<E2> = ShapeCS::new();
-    let circuit_cyclefold: CyclefoldCircuit<E1> = CyclefoldCircuit::new(None);
+    let ro_consts_cyclefold = ROConstants::<Dual<E>>::default();
+    let mut cs: ShapeCS<Dual<E>> = ShapeCS::new();
+    let circuit_cyclefold: CyclefoldCircuit<E> = CyclefoldCircuit::new(None);
     let _ = circuit_cyclefold.synthesize(&mut cs);
     let (r1cs_shape_cyclefold, ck_cyclefold) = cs.r1cs_shape_and_key(ck_hint_cyclefold);
     let circuit_shape_cyclefold = R1CSWithArity::new(r1cs_shape_cyclefold, 0);
@@ -122,7 +117,7 @@ where
   }
 
   /// TODO: docs
-  pub fn digest(&self) -> E1::Scalar {
+  pub fn digest(&self) -> <Dual<E> as Engine>::Base {
     self
       .digest
       .get_or_try_init(|| DigestComputer::new(self).digest())
@@ -147,57 +142,54 @@ where
   }
 }
 
-impl<E1, E2, C1> SimpleDigestible for PublicParams<E1, E2, C1>
+impl<E, C> SimpleDigestible for PublicParams<E, C>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 {
 }
 
 /// TODO: docs
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct RecursiveSNARK<E1, E2, C1>
+pub struct RecursiveSNARK<E, C>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 {
   // Input
-  z0_primary: Vec<E1::Scalar>,
+  z0_primary: Vec<E::Scalar>,
 
   // primary circuit data
-  r_W_primary: RelaxedR1CSWitness<E1>,
-  r_U_primary: RelaxedR1CSInstance<E1>,
-  l_w_primary: R1CSWitness<E1>,
-  l_u_primary: R1CSInstance<E1>,
+  r_W_primary: RelaxedR1CSWitness<E>,
+  r_U_primary: RelaxedR1CSInstance<E>,
+  l_w_primary: R1CSWitness<E>,
+  l_u_primary: R1CSInstance<E>,
 
   // cyclefold circuit data
-  r_W_cyclefold: RelaxedR1CSWitness<E2>,
-  r_U_cyclefold: RelaxedR1CSInstance<E2>,
+  r_W_cyclefold: RelaxedR1CSWitness<Dual<E>>,
+  r_U_cyclefold: RelaxedR1CSInstance<Dual<E>>,
 
   // memory buffers for folding steps
-  buffer_primary: ResourceBuffer<E1>,
-  buffer_cyclefold: ResourceBuffer<E2>,
+  buffer_primary: ResourceBuffer<E>,
+  buffer_cyclefold: ResourceBuffer<Dual<E>>,
 
   i: usize,
-  zi_primary: Vec<E1::Scalar>,
+  zi_primary: Vec<E::Scalar>,
 
-  _p: PhantomData<C1>,
+  _p: PhantomData<C>,
 }
 
-impl<E1, E2, C1> RecursiveSNARK<E1, E2, C1>
+impl<E, C> RecursiveSNARK<E, C>
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
-  C1: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  C: StepCircuit<<Dual<E> as Engine>::Base>,
 {
   /// TODO: docs
   pub fn new(
-    pp: &PublicParams<E1, E2, C1>,
-    c_primary: &C1,
-    z0_primary: &[E1::Scalar],
+    pp: &PublicParams<E, C>,
+    c_primary: &C,
+    z0_primary: &[E::Scalar],
   ) -> Result<Self, NovaError> {
     if z0_primary.len() != pp.F_arity_primary {
       return Err(NovaError::InvalidInitialInputLength);
@@ -209,10 +201,10 @@ where
     let r_U_cyclefold = RelaxedR1CSInstance::default(&pp.ck_cyclefold, r1cs_cyclefold);
     let r_W_cyclefold = RelaxedR1CSWitness::default(r1cs_cyclefold);
 
-    let mut cs_primary = SatisfyingAssignment::<E1>::new();
-    let inputs_primary: AugmentedCircuitInputs<E2, E1> = AugmentedCircuitInputs::new(
-      scalar_as_base::<E1>(pp.digest()),
-      <E2 as Engine>::Base::from(0u64),
+    let mut cs_primary = SatisfyingAssignment::<E>::new();
+    let inputs_primary: AugmentedCircuitInputs<E> = AugmentedCircuitInputs::new(
+      scalar_as_base::<E>(pp.digest()),
+      <Dual<E> as Engine>::Base::from(0u64),
       z0_primary.to_vec(),
       None,
       None,
@@ -247,7 +239,7 @@ where
       l_u: None,
       ABC_Z_1: R1CSResult::default(r1cs_primary.num_cons),
       ABC_Z_2: R1CSResult::default(r1cs_primary.num_cons),
-      T: r1cs::default_T::<E1>(r1cs_primary.num_cons),
+      T: r1cs::default_T::<E>(r1cs_primary.num_cons),
     };
 
     let buffer_cyclefold = ResourceBuffer {
@@ -255,7 +247,7 @@ where
       l_u: None,
       ABC_Z_1: R1CSResult::default(r1cs_cyclefold.num_cons),
       ABC_Z_2: R1CSResult::default(r1cs_cyclefold.num_cons),
-      T: r1cs::default_T::<E2>(r1cs_cyclefold.num_cons),
+      T: r1cs::default_T::<Dual<E>>(r1cs_cyclefold.num_cons),
     };
 
     Ok(Self {
@@ -275,17 +267,13 @@ where
   }
 
   /// TODO: docs
-  pub fn prove_step(
-    &mut self,
-    pp: &PublicParams<E1, E2, C1>,
-    c_primary: &C1,
-  ) -> Result<(), NovaError> {
+  pub fn prove_step(&mut self, pp: &PublicParams<E, C>, c_primary: &C) -> Result<(), NovaError> {
     if self.i == 0 {
       self.i = 1;
       return Ok(());
     }
 
-    let (nifs_primary, (r_U_primary, r_W_primary), r) = super::nifs::NIFS::<E1, E2>::prove(
+    let (nifs_primary, (r_U_primary, r_W_primary), r) = super::nifs::NIFS::prove(
       &pp.ck_primary,
       &pp.ro_consts_primary,
       &pp.digest(),
@@ -314,24 +302,24 @@ where
 
     let r_bools = r.to_le_bits().iter().map(|b| Some(*b)).collect::<Vec<_>>();
 
-    let comm_T = Commitment::<E1>::decompress(&nifs_primary.comm_T)?;
+    let comm_T = Commitment::decompress(&nifs_primary.comm_T)?;
     let E_new = self.r_U_primary.comm_E + comm_T * r;
 
     let W_new = self.r_U_primary.comm_W + self.l_u_primary.comm_W * r;
 
-    let mut cs_cyclefold_E = SatisfyingAssignment::<E2>::with_capacity(
+    let mut cs_cyclefold_E = SatisfyingAssignment::<Dual<E>>::with_capacity(
       pp.circuit_shape_cyclefold.r1cs_shape.num_io + 1,
       pp.circuit_shape_cyclefold.r1cs_shape.num_vars,
     );
 
-    let inputs_cyclefold_E: CyclefoldCircuitInputs<E1> = CyclefoldCircuitInputs::new(
+    let inputs_cyclefold_E: CyclefoldCircuitInputs<E> = CyclefoldCircuitInputs::new(
       Some(self.r_U_primary.comm_E),
       Some(comm_T),
       Some(E_new),
       r_bools.clone(),
     );
 
-    let circuit_cyclefold_E: CyclefoldCircuit<E1> = CyclefoldCircuit::new(Some(inputs_cyclefold_E));
+    let circuit_cyclefold_E: CyclefoldCircuit<E> = CyclefoldCircuit::new(Some(inputs_cyclefold_E));
 
     let _output_cyclefold_E = circuit_cyclefold_E.synthesize(&mut cs_cyclefold_E);
 
@@ -343,7 +331,7 @@ where
     let (nifs_cyclefold_E, (r_U_cyclefold_E, r_W_cyclefold_E), _) = NIFS::prove(
       &pp.ck_cyclefold,
       &pp.ro_consts_cyclefold,
-      &scalar_as_base::<E1>(pp.digest()),
+      &scalar_as_base::<E>(pp.digest()),
       &pp.circuit_shape_cyclefold.r1cs_shape,
       &self.r_U_cyclefold,
       &self.r_W_cyclefold,
@@ -351,21 +339,21 @@ where
       &l_w_cyclefold_E,
     )?;
 
-    let comm_T_E = Commitment::<E2>::decompress(&nifs_cyclefold_E.comm_T)?;
+    let comm_T_E = Commitment::<Dual<E>>::decompress(&nifs_cyclefold_E.comm_T)?;
 
-    let mut cs_cyclefold_W = SatisfyingAssignment::<E2>::with_capacity(
+    let mut cs_cyclefold_W = SatisfyingAssignment::<Dual<E>>::with_capacity(
       pp.circuit_shape_cyclefold.r1cs_shape.num_io + 1,
       pp.circuit_shape_cyclefold.r1cs_shape.num_vars,
     );
 
-    let inputs_cyclefold_W: CyclefoldCircuitInputs<E1> = CyclefoldCircuitInputs::new(
+    let inputs_cyclefold_W: CyclefoldCircuitInputs<E> = CyclefoldCircuitInputs::new(
       Some(self.r_U_primary.comm_W),
       Some(self.l_u_primary.comm_W),
       Some(W_new),
       r_bools,
     );
 
-    let circuit_cyclefold_W: CyclefoldCircuit<E1> = CyclefoldCircuit::new(Some(inputs_cyclefold_W));
+    let circuit_cyclefold_W: CyclefoldCircuit<E> = CyclefoldCircuit::new(Some(inputs_cyclefold_W));
 
     let _output_cyclefold_W = circuit_cyclefold_W.synthesize(&mut cs_cyclefold_W);
 
@@ -377,7 +365,7 @@ where
     let (nifs_cyclefold_W, (r_U_cyclefold_W, r_W_cyclefold_W), _) = NIFS::prove(
       &pp.ck_cyclefold,
       &pp.ro_consts_cyclefold,
-      &scalar_as_base::<E1>(pp.digest()),
+      &scalar_as_base::<E>(pp.digest()),
       &pp.circuit_shape_cyclefold.r1cs_shape,
       &r_U_cyclefold_E,
       &r_W_cyclefold_E,
@@ -385,9 +373,9 @@ where
       &l_w_cyclefold_W,
     )?;
 
-    let comm_T_W = Commitment::<E2>::decompress(&nifs_cyclefold_W.comm_T)?;
+    let comm_T_W = Commitment::<Dual<E>>::decompress(&nifs_cyclefold_W.comm_T)?;
 
-    let mut cs_primary = SatisfyingAssignment::<E1>::with_capacity(
+    let mut cs_primary = SatisfyingAssignment::<E>::with_capacity(
       pp.circuit_shape_primary.r1cs_shape.num_io + 1,
       pp.circuit_shape_primary.r1cs_shape.num_vars,
     );
@@ -396,9 +384,9 @@ where
     let data_c_E = FoldingData::new(self.r_U_cyclefold.clone(), l_u_cyclefold_E, comm_T_E);
     let data_c_W = FoldingData::new(r_U_cyclefold_E, l_u_cyclefold_W, comm_T_W);
 
-    let inputs_primary: AugmentedCircuitInputs<E2, E1> = AugmentedCircuitInputs::new(
-      scalar_as_base::<E1>(pp.digest()),
-      <E2 as Engine>::Base::from(self.i as u64),
+    let inputs_primary: AugmentedCircuitInputs<E> = AugmentedCircuitInputs::new(
+      scalar_as_base::<E>(pp.digest()),
+      <Dual<E> as Engine>::Base::from(self.i as u64),
       self.z0_primary.clone(),
       Some(self.zi_primary.clone()),
       Some(data_p),
@@ -408,7 +396,7 @@ where
       Some(W_new),
     );
 
-    let circuit_primary: AugmentedCircuit<'_, E2, E1, C1> = AugmentedCircuit::new(
+    let circuit_primary: AugmentedCircuit<'_, E, C> = AugmentedCircuit::new(
       &pp.augmented_circuit_params,
       pp.ro_consts_circuit_primary.clone(),
       Some(inputs_primary),
@@ -441,10 +429,10 @@ where
   /// TODO: docs
   pub fn verify(
     &self,
-    pp: &PublicParams<E1, E2, C1>,
+    pp: &PublicParams<E, C>,
     num_steps: usize,
-    z0_primary: &[E1::Scalar],
-  ) -> Result<Vec<E1::Scalar>, NovaError> {
+    z0_primary: &[E::Scalar],
+  ) -> Result<Vec<E::Scalar>, NovaError> {
     // number of steps cannot be zero
     let is_num_steps_zero = num_steps == 0;
 
@@ -466,23 +454,23 @@ where
     }
 
     let (hash_primary, hash_cyclefold) = {
-      let mut hasher = <E2 as Engine>::RO::new(
+      let mut hasher = <Dual<E> as Engine>::RO::new(
         pp.ro_consts_primary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * pp.F_arity_primary,
       );
       hasher.absorb(pp.digest());
-      hasher.absorb(E1::Scalar::from(num_steps as u64));
+      hasher.absorb(<Dual<E> as Engine>::Base::from(num_steps as u64));
       for e in z0_primary {
         hasher.absorb(*e);
       }
       for e in &self.zi_primary {
         hasher.absorb(*e);
       }
-      absorb_relaxed_r1cs::<E1, E2>(&self.r_U_primary, &mut hasher);
+      absorb_relaxed_r1cs::<E>(&self.r_U_primary, &mut hasher);
       let hash_primary = hasher.squeeze(NUM_HASH_BITS);
 
       let mut hasher =
-        <E2 as Engine>::RO::new(pp.ro_consts_cyclefold.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF);
+        <Dual<E> as Engine>::RO::new(pp.ro_consts_cyclefold.clone(), NUM_FE_WITHOUT_IO_FOR_CRHF);
       hasher.absorb(pp.digest());
       self.r_U_cyclefold.absorb_in_ro(&mut hasher);
       let hash_cyclefold = hasher.squeeze(NUM_HASH_BITS);
@@ -492,8 +480,8 @@ where
 
     // TODO: This seems like it might be a bad sign, I don't know if I should need to use
     // `scalar_as_base` here
-    if scalar_as_base::<E2>(hash_primary) != self.l_u_primary.X[0]
-      || scalar_as_base::<E2>(hash_cyclefold) != self.l_u_primary.X[1]
+    if scalar_as_base::<Dual<E>>(hash_primary) != self.l_u_primary.X[0]
+      || scalar_as_base::<Dual<E>>(hash_cyclefold) != self.l_u_primary.X[1]
     {
       return Err(NovaError::ProofVerifyError);
     }
@@ -534,13 +522,12 @@ where
   }
 }
 
-fn absorb_relaxed_r1cs<E1, E2>(U: &RelaxedR1CSInstance<E1>, ro: &mut E2::RO)
+fn absorb_relaxed_r1cs<E>(U: &RelaxedR1CSInstance<E>, ro: &mut <Dual<E> as Engine>::RO)
 where
-  E1: Engine<Base = <E2 as Engine>::Scalar>,
-  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  E: CurveCycleEquipped,
 {
-  absorb_commitment::<E1, E2>(&U.comm_W, ro);
-  absorb_commitment::<E1, E2>(&U.comm_E, ro);
+  absorb_commitment::<E>(&U.comm_W, ro);
+  absorb_commitment::<E>(&U.comm_E, ro);
   for e in &U.X {
     ro.absorb(*e);
   }