From 64db5b586411bc869bde7dd31670977e40d6b140 Mon Sep 17 00:00:00 2001
From: Adrian Hamelink <adrian@hamelink.com>
Date: Tue, 20 Feb 2024 20:20:10 +0100
Subject: [PATCH] Adapt to CurveCycleEquiped

---
 src/parafold/circuit.rs                |  35 ++--
 src/parafold/cycle_fold/circuit.rs     |  53 +++---
 src/parafold/cycle_fold/mod.rs         |  48 ++---
 src/parafold/cycle_fold/prover.rs      |  63 +++---
 src/parafold/ecc.rs                    | 236 +++++++++--------------
 src/parafold/nifs/circuit.rs           |  44 ++---
 src/parafold/nifs/circuit_secondary.rs |  61 +++---
 src/parafold/nifs/prover.rs            | 253 +++++++++++++------------
 src/parafold/nivc/circuit.rs           |  87 ++++-----
 src/parafold/nivc/mod.rs               |  34 ++--
 src/parafold/nivc/prover.rs            |  83 ++++----
 src/parafold/prover.rs                 |  30 ++-
 src/parafold/transcript/circuit.rs     |  31 +--
 src/parafold/transcript/mod.rs         |   4 +-
 src/parafold/transcript/prover.rs      |  35 ++--
 15 files changed, 517 insertions(+), 580 deletions(-)

diff --git a/src/parafold/circuit.rs b/src/parafold/circuit.rs
index 49b4ad066..83a6432f4 100644
--- a/src/parafold/circuit.rs
+++ b/src/parafold/circuit.rs
@@ -5,19 +5,18 @@ use crate::parafold::nivc::{NIVCMergeProof, NIVCUpdateProof, NIVCIO};
 use crate::parafold::transcript::circuit::AllocatedTranscript;
 use crate::parafold::transcript::TranscriptConstants;
 use crate::supernova::StepCircuit;
-use crate::traits::Engine;
+use crate::traits::CurveCycleEquipped;
 
-pub fn synthesize_step<E1, E2, CS, SF>(
+pub fn synthesize_step<E, CS, SF>(
   mut cs: CS,
-  ro_consts: &TranscriptConstants<E1>,
-  proof: NIVCUpdateProof<E1, E2>,
+  ro_consts: &TranscriptConstants<E::Scalar>,
+  proof: NIVCUpdateProof<E>,
   step_circuit: &SF,
-) -> Result<NIVCIO<E1::Scalar>, SynthesisError>
+) -> Result<NIVCIO<E::Scalar>, SynthesisError>
 where
-  E1: Engine,
-  E2: Engine<Scalar = E1::Base, Base = E1::Scalar>,
-  CS: ConstraintSystem<E1::Scalar>,
-  SF: StepCircuit<E1::Scalar>,
+  E: CurveCycleEquipped,
+  CS: ConstraintSystem<E::Scalar>,
+  SF: StepCircuit<E::Scalar>,
 {
   // Fold proof for previous state
   let (mut state, transcript) =
@@ -30,18 +29,18 @@ where
 
   io
 }
+
 /// Circuit
-pub fn synthesize_merge<E1, E2, CS>(
+pub fn synthesize_merge<E, CS>(
   mut cs: CS,
-  ro_consts: &TranscriptConstants<E1>,
-  proof_L: NIVCUpdateProof<E1, E2>,
-  proof_R: NIVCUpdateProof<E1, E2>,
-  proof_merge: NIVCMergeProof<E1, E2>,
-) -> Result<NIVCIO<E1::Scalar>, SynthesisError>
+  ro_consts: &TranscriptConstants<E::Scalar>,
+  proof_L: NIVCUpdateProof<E>,
+  proof_R: NIVCUpdateProof<E>,
+  proof_merge: NIVCMergeProof<E>,
+) -> Result<NIVCIO<E::Scalar>, SynthesisError>
 where
-  E1: Engine,
-  E2: Engine<Scalar = E1::Base, Base = E1::Scalar>,
-  CS: ConstraintSystem<E1::Scalar>,
+  E: CurveCycleEquipped,
+  CS: ConstraintSystem<E::Scalar>,
 {
   // Verify L
   let (self_L, transcript_L) =
diff --git a/src/parafold/cycle_fold/circuit.rs b/src/parafold/cycle_fold/circuit.rs
index c003712e5..c1baa95cd 100644
--- a/src/parafold/cycle_fold/circuit.rs
+++ b/src/parafold/cycle_fold/circuit.rs
@@ -6,18 +6,14 @@ use crate::parafold::cycle_fold::AllocatedHashedCommitment;
 use crate::parafold::nifs::circuit_secondary::AllocatedSecondaryRelaxedR1CSInstance;
 use crate::parafold::nifs::FoldProof;
 use crate::parafold::transcript::circuit::AllocatedTranscript;
-
-use crate::traits::Engine;
+use crate::traits::{CurveCycleEquipped, Engine};
 
 #[derive(Debug, Clone)]
-pub struct AllocatedScalarMulAccumulator<E1: Engine> {
-  deferred: Vec<AllocatedScalarMulInstance<E1>>,
+pub struct AllocatedScalarMulAccumulator<E: Engine> {
+  deferred: Vec<AllocatedScalarMulInstance<E>>,
 }
 
-impl<E1> AllocatedScalarMulAccumulator<E1>
-where
-  E1: Engine,
-{
+impl<E: Engine> AllocatedScalarMulAccumulator<E> {
   pub fn new() -> Self {
     Self { deferred: vec![] }
   }
@@ -26,13 +22,13 @@ where
   pub fn scalar_mul<CS>(
     &mut self,
     mut cs: CS,
-    A: AllocatedHashedCommitment<E1>,
-    B: AllocatedHashedCommitment<E1>,
-    x: AllocatedNum<E1::Scalar>,
-    transcript: &mut AllocatedTranscript<E1>,
-  ) -> Result<AllocatedHashedCommitment<E1>, SynthesisError>
+    A: AllocatedHashedCommitment<E>,
+    B: AllocatedHashedCommitment<E>,
+    x: AllocatedNum<E::Scalar>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
+  ) -> Result<AllocatedHashedCommitment<E>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let A_value = A.value;
     let B_value = B.value;
@@ -59,17 +55,18 @@ where
     self_L.deferred.append(&mut self_R.deferred);
     self_L
   }
+}
 
-  pub fn finalize<CS, E2>(
+impl<E: CurveCycleEquipped> AllocatedScalarMulAccumulator<E> {
+  pub fn finalize<CS>(
     self,
     mut cs: CS,
-    mut acc_cf: AllocatedSecondaryRelaxedR1CSInstance<E1, E2>,
-    proofs: impl IntoIterator<Item = FoldProof<E2>>,
-    transcript: &mut AllocatedTranscript<E1>,
-  ) -> Result<AllocatedSecondaryRelaxedR1CSInstance<E1, E2>, SynthesisError>
+    mut acc_cf: AllocatedSecondaryRelaxedR1CSInstance<E>,
+    proofs: impl IntoIterator<Item = FoldProof<E::Secondary>>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
+  ) -> Result<AllocatedSecondaryRelaxedR1CSInstance<E>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
-    E2: Engine<Base = E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     for (instance, proof) in zip_eq(self.deferred, proofs) {
       let AllocatedScalarMulInstance { A, B, x, C } = instance;
@@ -91,15 +88,15 @@ where
 }
 
 #[derive(Debug, Clone)]
-pub struct AllocatedScalarMulInstance<E1: Engine> {
-  A: AllocatedHashedCommitment<E1>,
-  B: AllocatedHashedCommitment<E1>,
-  x: AllocatedNum<E1::Scalar>,
-  C: AllocatedHashedCommitment<E1>,
+pub struct AllocatedScalarMulInstance<E: Engine> {
+  A: AllocatedHashedCommitment<E>,
+  B: AllocatedHashedCommitment<E>,
+  x: AllocatedNum<E::Scalar>,
+  C: AllocatedHashedCommitment<E>,
 }
 
-impl<E1: Engine> AllocatedScalarMulInstance<E1> {
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E1::Scalar>> + '_ {
+impl<E: Engine> AllocatedScalarMulInstance<E> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E::Scalar>> + '_ {
     chain![
       self.A.as_preimage(),
       self.B.as_preimage(),
diff --git a/src/parafold/cycle_fold/mod.rs b/src/parafold/cycle_fold/mod.rs
index f8838bdf5..9179b1a0c 100644
--- a/src/parafold/cycle_fold/mod.rs
+++ b/src/parafold/cycle_fold/mod.rs
@@ -45,24 +45,24 @@ pub mod prover;
 /// so this additional hashing that occurs in the secondary circuit ensure we only need to perform this expensive
 /// operation 4 times. Moreover, the fact that r<q ensures that the scalar x \in F_r can be trivially embedded into F_q.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct HashedCommitment<E1: Engine> {
-  point: Commitment<E1>,
+pub struct HashedCommitment<E: Engine> {
+  point: Commitment<E>,
   // Poseidon hash of (x,y) = point. We set hash = 0 when `point` = infinity
-  hash: E1::Base,
+  hash: E::Base,
   // E1 representation of `hash` with `BN_N_LIMBS` limbs of BN_LIMB_WIDTH bits.
-  hash_limbs: [E1::Scalar; BN_N_LIMBS],
+  hash_limbs: [E::Scalar; BN_N_LIMBS],
 }
 
-impl<E1: Engine> HashedCommitment<E1> {
+impl<E: Engine> HashedCommitment<E> {
   /// Convert a [Commitment] to it's compressed representation.
-  pub fn new(point: Commitment<E1>) -> Self {
-    let constants = PoseidonConstants::<E1::Base, U2>::new();
+  pub fn new(point: Commitment<E>) -> Self {
+    let constants = PoseidonConstants::<E::Base, U2>::new();
     let (x, y, infinity) = point.to_coordinates();
     if infinity {
       Self {
         point,
-        hash: E1::Base::ZERO,
-        hash_limbs: [E1::Scalar::ZERO; BN_N_LIMBS],
+        hash: E::Base::ZERO,
+        hash_limbs: [E::Scalar::ZERO; BN_N_LIMBS],
       }
     } else {
       let hash = Poseidon::new_with_preimage(&[x, y], &constants).hash();
@@ -71,17 +71,17 @@ impl<E1: Engine> HashedCommitment<E1> {
         .chunks_exact(BN_LIMB_WIDTH)
         .map(|limb_bits| {
           // TODO: Find more efficient trick
-          let mut limb = E1::Scalar::ZERO;
+          let mut limb = E::Scalar::ZERO;
           for bit in limb_bits.iter().rev() {
             // double limb
             limb += limb;
             if *bit {
-              limb += E1::Scalar::ONE;
+              limb += E::Scalar::ONE;
             }
           }
           limb
         })
-        .collect::<Vec<E1::Scalar>>();
+        .collect::<Vec<E::Scalar>>();
 
       Self {
         point,
@@ -91,7 +91,7 @@ impl<E1: Engine> HashedCommitment<E1> {
     }
   }
 
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = E1::Scalar> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = E::Scalar> {
     self.hash_limbs
   }
 }
@@ -106,18 +106,18 @@ impl<E1: Engine> HashedCommitment<E1> {
 /// - Investigate whether a `is_infinity` flag is needed. It could be used to avoid synthesizing secondary circuits
 ///   when the scalar multiplication is trivial.
 #[derive(Debug, Clone)]
-pub struct AllocatedHashedCommitment<E1: Engine> {
-  value: Commitment<E1>,
+pub struct AllocatedHashedCommitment<E: Engine> {
+  value: Commitment<E>,
   // hash = if let Some(point) = value { H_secondary(point) } else { 0 }
-  hash_limbs: [AllocatedNum<E1::Scalar>; BN_N_LIMBS],
+  hash_limbs: [AllocatedNum<E::Scalar>; BN_N_LIMBS],
 }
 
-impl<E1: Engine> AllocatedHashedCommitment<E1> {
-  pub fn alloc<CS>(mut cs: CS, c: Commitment<E1>) -> Self
+impl<E: Engine> AllocatedHashedCommitment<E> {
+  pub fn alloc<CS>(mut cs: CS, c: Commitment<E>) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
-    let hashed = HashedCommitment::<E1>::new(c);
+    let hashed = HashedCommitment::<E>::new(c);
     let hash_limbs = hashed
       .hash_limbs
       .map(|limb| AllocatedNum::alloc_infallible(cs.namespace(|| "alloc limb"), || limb));
@@ -130,18 +130,18 @@ impl<E1: Engine> AllocatedHashedCommitment<E1> {
 
   pub fn alloc_transcript<CS>(
     mut cs: CS,
-    c: Commitment<E1>,
-    transcript: &mut AllocatedTranscript<E1>,
+    c: Commitment<E>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let c = AllocatedHashedCommitment::alloc(&mut cs, c);
     transcript.absorb(c.as_preimage());
     c
   }
 
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E1::Scalar>> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E::Scalar>> {
     self.hash_limbs.clone()
   }
 }
diff --git a/src/parafold/cycle_fold/prover.rs b/src/parafold/cycle_fold/prover.rs
index cd99e4b74..145dcc4f1 100644
--- a/src/parafold/cycle_fold/prover.rs
+++ b/src/parafold/cycle_fold/prover.rs
@@ -5,7 +5,7 @@ use crate::parafold::nifs::prover::RelaxedR1CS;
 use crate::parafold::nifs::FoldProof;
 use crate::parafold::transcript::prover::Transcript;
 use crate::r1cs::R1CSShape;
-use crate::traits::Engine;
+use crate::traits::{CurveCycleEquipped, Dual, Engine};
 use crate::{Commitment, CommitmentKey};
 
 /// A [ScalarMulAccumulator] represents a coprocessor for efficiently computing non-native ECC scalar multiplications
@@ -18,11 +18,11 @@ use crate::{Commitment, CommitmentKey};
 ///
 /// All operations are proved in a batch at the end of the circuit in order to minimize latency for the prover.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ScalarMulAccumulator<E1: Engine> {
-  deferred: Vec<ScalarMulInstance<E1>>,
+pub struct ScalarMulAccumulator<E: Engine> {
+  deferred: Vec<ScalarMulInstance<E>>,
 }
 
-impl<E1: Engine> ScalarMulAccumulator<E1> {
+impl<E: Engine> ScalarMulAccumulator<E> {
   pub fn new() -> Self {
     Self { deferred: vec![] }
   }
@@ -34,60 +34,59 @@ impl<E1: Engine> ScalarMulAccumulator<E1> {
   /// The tuple `[A, B, x, C]` is added to the `deferred` list which will be proved in a batch later on.
   pub fn scalar_mul(
     &mut self,
-    A: Commitment<E1>,
-    B: Commitment<E1>,
-    x: E1::Scalar,
-    transcript: &mut Transcript<E1>,
-  ) -> Commitment<E1> {
-    let C: Commitment<E1> = A + B * x;
+    A: Commitment<E>,
+    B: Commitment<E>,
+    x: E::Scalar,
+    transcript: &mut Transcript<E::Scalar>,
+  ) -> Commitment<E> {
+    let C: Commitment<E> = A + B * x;
 
-    transcript.absorb_commitment_primary(C.clone());
+    transcript.absorb_commitment_primary::<E>(C.clone());
 
     self.deferred.push(ScalarMulInstance { A, B, x, C });
 
     C
   }
+}
 
+impl<E: CurveCycleEquipped> ScalarMulAccumulator<E> {
   /// Consume all deferred scalar multiplication instances and create a folding proof for each result.
   /// The proofs are folded into a mutable RelaxedR1CS for the corresponding circuit over the secondary curve.
-  pub fn finalize<E2>(
+  pub fn finalize(
     self,
-    ck: &CommitmentKey<E2>,
-    shape: &R1CSShape<E2>,
-    acc_cf: &mut RelaxedR1CS<E2>,
-    transcript: &mut Transcript<E1>,
-  ) -> Vec<FoldProof<E2>>
-  where
-    E2: Engine<Scalar = E1::Base, Base = E1::Scalar>,
-  {
+    ck: &CommitmentKey<E::Secondary>,
+    shape: &R1CSShape<E::Secondary>,
+    acc_cf: &mut RelaxedR1CS<E::Secondary>,
+    transcript: &mut Transcript<E::Scalar>,
+  ) -> Vec<FoldProof<E::Secondary>> {
     self
       .deferred
       .into_iter()
       .map(|_instance| {
-        let cs = SatisfyingAssignment::<E2>::new();
+        let cs = SatisfyingAssignment::<Dual<E>>::new();
         // TODO: synthesize the circuit that proves `instance`
         let (X, W) = cs.to_assignments();
-        acc_cf.fold_secondary(ck, shape, X, &W, transcript)
+        acc_cf.fold_secondary::<E>(ck, shape, X, &W, transcript)
       })
       .collect()
   }
 
-  pub fn simulate_finalize<E2>(self, transcript: &mut Transcript<E1>) -> Vec<FoldProof<E2>>
-  where
-    E2: Engine<Scalar = E1::Base, Base = E1::Scalar>,
-  {
+  pub fn simulate_finalize(
+    self,
+    transcript: &mut Transcript<E::Scalar>,
+  ) -> Vec<FoldProof<E::Secondary>> {
     self
       .deferred
       .into_iter()
-      .map(|_| RelaxedR1CS::<E2>::simulate_fold_secondary(transcript))
+      .map(|_| RelaxedR1CS::simulate_fold_secondary::<E>(transcript))
       .collect()
   }
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct ScalarMulInstance<E1: Engine> {
-  A: Commitment<E1>,
-  B: Commitment<E1>,
-  x: E1::Scalar,
-  C: Commitment<E1>,
+pub struct ScalarMulInstance<E: Engine> {
+  A: Commitment<E>,
+  B: Commitment<E>,
+  x: E::Scalar,
+  C: Commitment<E>,
 }
diff --git a/src/parafold/ecc.rs b/src/parafold/ecc.rs
index 657e63dc4..96736ac06 100644
--- a/src/parafold/ecc.rs
+++ b/src/parafold/ecc.rs
@@ -1,10 +1,8 @@
-use std::marker::PhantomData;
-
 use bellpepper::gadgets::Assignment;
 use bellpepper_core::boolean::{AllocatedBit, Boolean};
 use bellpepper_core::num::AllocatedNum;
 use bellpepper_core::{ConstraintSystem, SynthesisError};
-use ff::PrimeField;
+use ff::{Field, PrimeField};
 
 use crate::gadgets::utils::{
   alloc_num_equals, alloc_one, alloc_zero, conditionally_select, conditionally_select2,
@@ -13,26 +11,21 @@ use crate::gadgets::utils::{
 };
 use crate::parafold::transcript::circuit::AllocatedTranscript;
 use crate::traits::commitment::CommitmentTrait;
-use crate::traits::{Engine, Group};
+use crate::traits::{CurveCycleEquipped, Engine, Group};
 use crate::Commitment;
 
 /// `AllocatedPoint` provides an elliptic curve abstraction inside a circuit.
 #[derive(Debug, Clone)]
-pub struct AllocatedPoint<F: PrimeField, G: Group> {
-  pub(crate) x: AllocatedNum<F>,
-  pub(crate) y: AllocatedNum<F>,
-  pub(crate) is_infinity: AllocatedNum<F>,
-  _marker: PhantomData<G>,
+pub struct AllocatedPoint<G: Group> {
+  pub(crate) x: AllocatedNum<G::Base>,
+  pub(crate) y: AllocatedNum<G::Base>,
+  pub(crate) is_infinity: AllocatedNum<G::Base>,
 }
 
-impl<F, G> AllocatedPoint<F, G>
-where
-  F: PrimeField,
-  G: Group<Base = F>,
-{
+impl<G: Group> AllocatedPoint<G> {
   pub fn select_default<CS>(self, mut cs: CS, is_default: &Boolean) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     let zero = alloc_zero(cs.namespace(|| "alloc 0"));
     let one = alloc_one(cs.namespace(|| "alloc 1"));
@@ -47,17 +40,12 @@ where
       &is_infinity,
       is_default,
     )?;
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: Default::default(),
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
   pub fn enforce_trivial<CS>(&self, mut cs: CS, is_trivial: &Boolean)
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     // is_trivial => (is_identity == 1)
     // is_trivial == is_identity
@@ -65,19 +53,19 @@ where
       || "is_trivial - E.is_infinity = 0",
       |lc| lc,
       |lc| lc,
-      |_| is_trivial.lc(CS::one(), F::ONE) - self.is_infinity.get_variable(),
+      |_| is_trivial.lc(CS::one(), G::Base::ONE) - self.is_infinity.get_variable(),
     );
   }
 
-  pub fn alloc_transcript<CS, E1, E2>(
+  pub fn alloc_transcript<CS, E, E2>(
     mut cs: CS,
-    c: Commitment<E2>,
-    transcript: &mut AllocatedTranscript<E1>,
+    c: Commitment<E::Secondary>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Self
   where
-    CS: ConstraintSystem<F>,
-    E1: Engine<Scalar = F>,
-    E2: Engine<Base = E1::Scalar, GE = G>,
+    CS: ConstraintSystem<G::Base>,
+    E: CurveCycleEquipped<Secondary = E2, Scalar = G::Base>,
+    E2: Engine<Base = G::Base>,
   {
     let c = Self::alloc(&mut cs, Some(c.to_coordinates())).unwrap();
     c.check_on_curve(cs.namespace(|| "check on curve")).unwrap();
@@ -87,17 +75,24 @@ where
 
   /// Allocates a new point on the curve using coordinates provided by `coords`.
   /// If coords = None, it allocates the default infinity point
-  pub fn alloc<CS>(mut cs: CS, coords: Option<(F, F, bool)>) -> Result<Self, SynthesisError>
+  pub fn alloc<CS>(
+    mut cs: CS,
+    coords: Option<(G::Base, G::Base, bool)>,
+  ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
-    let x = AllocatedNum::alloc(cs.namespace(|| "x"), || Ok(coords.map_or(F::ZERO, |c| c.0)))?;
-    let y = AllocatedNum::alloc(cs.namespace(|| "y"), || Ok(coords.map_or(F::ZERO, |c| c.1)))?;
+    let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
+      Ok(coords.map_or(G::Base::ZERO, |c| c.0))
+    })?;
+    let y = AllocatedNum::alloc(cs.namespace(|| "y"), || {
+      Ok(coords.map_or(G::Base::ZERO, |c| c.1))
+    })?;
     let is_infinity = AllocatedNum::alloc(cs.namespace(|| "is_infinity"), || {
       Ok(if coords.map_or(true, |c| c.2) {
-        F::ONE
+        G::Base::ONE
       } else {
-        F::ZERO
+        G::Base::ZERO
       })
     })?;
     cs.enforce(
@@ -107,18 +102,13 @@ where
       |lc| lc,
     );
 
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
   /// checks if `self` is on the curve or if it is infinity
   pub fn check_on_curve<CS>(&self, mut cs: CS) -> Result<(), SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     // check that (x,y) is on the curve if it is not infinity
     // we will check that (1- is_infinity) * y^2 = (1-is_infinity) * (x^3 + Ax + B)
@@ -128,8 +118,8 @@ where
     let x_cube = self.x.mul(cs.namespace(|| "x_cube"), &x_square)?;
 
     let rhs = AllocatedNum::alloc(cs.namespace(|| "rhs"), || {
-      if *self.is_infinity.get_value().get()? == F::ONE {
-        Ok(F::ZERO)
+      if *self.is_infinity.get_value().get()? == G::Base::ONE {
+        Ok(G::Base::ZERO)
       } else {
         Ok(
           *x_cube.get_value().get()?
@@ -164,7 +154,7 @@ where
   /// Allocates a default point on the curve, set to the identity point.
   pub fn default<CS>(mut cs: CS) -> Self
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     let zero = alloc_zero(cs.namespace(|| "zero"));
     let one = alloc_one(cs.namespace(|| "one"));
@@ -173,19 +163,24 @@ where
       x: zero.clone(),
       y: zero,
       is_infinity: one,
-      _marker: PhantomData,
     }
   }
 
   /// Returns coordinates associated with the point.
-  pub const fn get_coordinates(&self) -> (&AllocatedNum<F>, &AllocatedNum<F>, &AllocatedNum<F>) {
+  pub const fn get_coordinates(
+    &self,
+  ) -> (
+    &AllocatedNum<G::Base>,
+    &AllocatedNum<G::Base>,
+    &AllocatedNum<G::Base>,
+  ) {
     (&self.x, &self.y, &self.is_infinity)
   }
 
   /// Negates the provided point
   pub fn negate<CS>(&self, mut cs: CS) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     let y = AllocatedNum::alloc(cs.namespace(|| "y"), || Ok(-*self.y.get_value().get()?))?;
 
@@ -200,14 +195,13 @@ where
       x: self.x.clone(),
       y,
       is_infinity: self.is_infinity.clone(),
-      _marker: PhantomData,
     })
   }
 
   /// Add two points (may be equal)
   pub fn add<CS>(&self, mut cs: CS, other: &Self) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     // Compute boolean equal indicating if self = other
 
@@ -260,7 +254,7 @@ where
     equal_x: &AllocatedBit,
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     //************************************************************************/
     // lambda = (other.y - self.y) * (other.x - self.x).invert().unwrap();
@@ -274,9 +268,9 @@ where
     // NOT(NOT(self.is_ifninity) AND NOT(other.is_infinity))
     let at_least_one_inf = AllocatedNum::alloc(cs.namespace(|| "at least one inf"), || {
       Ok(
-        F::ONE
-          - (F::ONE - *self.is_infinity.get_value().get()?)
-            * (F::ONE - *other.is_infinity.get_value().get()?),
+        G::Base::ONE
+          - (G::Base::ONE - *self.is_infinity.get_value().get()?)
+            * (G::Base::ONE - *other.is_infinity.get_value().get()?),
       )
     })?;
     cs.enforce(
@@ -290,7 +284,7 @@ where
     let x_diff_is_actual =
       AllocatedNum::alloc(cs.namespace(|| "allocate x_diff_is_actual"), || {
         Ok(if *equal_x.get_value().get()? {
-          F::ONE
+          G::Base::ONE
         } else {
           *at_least_one_inf.get_value().get()?
         })
@@ -312,9 +306,9 @@ where
     )?;
 
     let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
-      let x_diff_inv = if *x_diff_is_actual.get_value().get()? == F::ONE {
+      let x_diff_inv = if *x_diff_is_actual.get_value().get()? == G::Base::ONE {
         // Set to default
-        F::ONE
+        G::Base::ONE
       } else {
         // Set to the actual inverse
         (*other.x.get_value().get()? - *self.x.get_value().get()?)
@@ -415,18 +409,13 @@ where
       &self.is_infinity,
     )?;
 
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
   /// Doubles the supplied point.
   pub fn double<CS>(&self, mut cs: CS) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     //*************************************************************/
     // lambda = (G::Base::from(3) * self.x * self.x + G::A())
@@ -449,19 +438,19 @@ where
     // Now compute lambda as (G::Base::from(3) * self.x * self.x + G::A()) * tmp_inv
 
     let prod_1 = AllocatedNum::alloc(cs.namespace(|| "alloc prod 1"), || {
-      Ok(F::from(3) * self.x.get_value().get()? * self.x.get_value().get()?)
+      Ok(G::Base::from(3) * self.x.get_value().get()? * self.x.get_value().get()?)
     })?;
     cs.enforce(
       || "Check prod 1",
-      |lc| lc + (F::from(3), self.x.get_variable()),
+      |lc| lc + (G::Base::from(3), self.x.get_variable()),
       |lc| lc + self.x.get_variable(),
       |lc| lc + prod_1.get_variable(),
     );
 
     let lambda = AllocatedNum::alloc(cs.namespace(|| "alloc lambda"), || {
-      let tmp_inv = if *self.is_infinity.get_value().get()? == F::ONE {
+      let tmp_inv = if *self.is_infinity.get_value().get()? == G::Base::ONE {
         // Return default value 1
-        F::ONE
+        G::Base::ONE
       } else {
         // Return the actual inverse
         (*tmp.get_value().get()?).invert().unwrap()
@@ -525,12 +514,7 @@ where
     // is_infinity
     let is_infinity = self.is_infinity.clone();
 
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
   /// A gadget for scalar multiplication, optimized to use incomplete addition law.
@@ -542,9 +526,9 @@ where
     scalar_bits: &[AllocatedBit],
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
-    let split_len = core::cmp::min(scalar_bits.len(), (F::NUM_BITS - 2) as usize);
+    let split_len = core::cmp::min(scalar_bits.len(), (G::Base::NUM_BITS - 2) as usize);
     let (incomplete_bits, complete_bits) = scalar_bits.split_at(split_len);
 
     // we convert AllocatedPoint into AllocatedPointNonInfinity; we deal with the case where self.is_infinity = 1 below
@@ -609,7 +593,6 @@ where
       x,
       y,
       is_infinity: res.is_infinity,
-      _marker: PhantomData,
     };
     let mut p_complete = p.to_allocated_point(&self.is_infinity);
 
@@ -636,7 +619,7 @@ where
     condition: &Boolean,
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     let x = conditionally_select(cs.namespace(|| "select x"), &a.x, &b.x, condition)?;
 
@@ -649,12 +632,7 @@ where
       condition,
     )?;
 
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
   /// If condition outputs a otherwise infinity
@@ -664,7 +642,7 @@ where
     condition: &Boolean,
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     let x = select_num_or_zero(cs.namespace(|| "select x"), &a.x, condition)?;
 
@@ -676,45 +654,31 @@ where
       condition,
     )?;
 
-    Ok(Self {
-      x,
-      y,
-      is_infinity,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y, is_infinity })
   }
 
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<F>> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<G::Base>> {
     [self.x.clone(), self.y.clone(), self.is_infinity.clone()]
   }
 }
 
 #[derive(Clone)]
 /// `AllocatedPoint` but one that is guaranteed to be not infinity
-pub struct AllocatedPointNonInfinity<F: PrimeField, G: Group> {
-  x: AllocatedNum<F>,
-  y: AllocatedNum<F>,
-  _marker: PhantomData<G>,
+pub struct AllocatedPointNonInfinity<G: Group> {
+  x: AllocatedNum<G::Base>,
+  y: AllocatedNum<G::Base>,
 }
 
-impl<F, G> AllocatedPointNonInfinity<F, G>
-where
-  F: PrimeField,
-  G: Group<Base = F>,
-{
+impl<G: Group> AllocatedPointNonInfinity<G> {
   /// Creates a new `AllocatedPointNonInfinity` from the specified coordinates
-  pub fn new(x: AllocatedNum<F>, y: AllocatedNum<F>) -> Self {
-    Self {
-      x,
-      y,
-      _marker: PhantomData,
-    }
+  pub fn new(x: AllocatedNum<G::Base>, y: AllocatedNum<G::Base>) -> Self {
+    Self { x, y }
   }
 
   /// Allocates a new point on the curve using coordinates provided by `coords`.
-  pub fn alloc<CS: ConstraintSystem<F>>(
+  pub fn alloc<CS: ConstraintSystem<G::Base>>(
     mut cs: CS,
-    coords: Option<(F, F)>,
+    coords: Option<(G::Base, G::Base)>,
   ) -> Result<Self, SynthesisError> {
     let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
       coords.map_or(Err(SynthesisError::AssignmentMissing), |c| Ok(c.0))
@@ -723,46 +687,40 @@ where
       coords.map_or(Err(SynthesisError::AssignmentMissing), |c| Ok(c.1))
     })?;
 
-    Ok(Self {
-      x,
-      y,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y })
   }
 
   /// Turns an `AllocatedPoint` into an `AllocatedPointNonInfinity` (assumes it is not infinity)
-  pub fn from_allocated_point(p: &AllocatedPoint<F, G>) -> Self {
+  pub fn from_allocated_point(p: &AllocatedPoint<G>) -> Self {
     Self {
       x: p.x.clone(),
       y: p.y.clone(),
-      _marker: PhantomData,
     }
   }
 
   /// Returns an `AllocatedPoint` from an `AllocatedPointNonInfinity`
-  pub fn to_allocated_point(&self, is_infinity: &AllocatedNum<F>) -> AllocatedPoint<F, G> {
+  pub fn to_allocated_point(&self, is_infinity: &AllocatedNum<G::Base>) -> AllocatedPoint<G> {
     AllocatedPoint {
       x: self.x.clone(),
       y: self.y.clone(),
       is_infinity: is_infinity.clone(),
-      _marker: PhantomData,
     }
   }
 
   /// Returns coordinates associated with the point.
-  pub const fn get_coordinates(&self) -> (&AllocatedNum<F>, &AllocatedNum<F>) {
+  pub const fn get_coordinates(&self) -> (&AllocatedNum<G::Base>, &AllocatedNum<G::Base>) {
     (&self.x, &self.y)
   }
 
   /// Add two points assuming self != +/- other
   pub fn add_incomplete<CS>(&self, mut cs: CS, other: &Self) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<F>,
+    CS: ConstraintSystem<G::Base>,
   {
     // allocate a free variable that an honest prover sets to lambda = (y2-y1)/(x2-x1)
     let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
       if *other.x.get_value().get()? == *self.x.get_value().get()? {
-        Ok(F::ONE)
+        Ok(G::Base::ONE)
       } else {
         Ok(
           (*other.y.get_value().get()? - *self.y.get_value().get()?)
@@ -813,15 +771,11 @@ where
       |lc| lc + y.get_variable() + self.y.get_variable(),
     );
 
-    Ok(Self {
-      x,
-      y,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y })
   }
 
   /// doubles the point; since this is called with a point not at infinity, it is guaranteed to be not infinity
-  pub fn double_incomplete<CS: ConstraintSystem<F>>(
+  pub fn double_incomplete<CS: ConstraintSystem<G::Base>>(
     &self,
     mut cs: CS,
   ) -> Result<Self, SynthesisError> {
@@ -830,10 +784,10 @@ where
     let x_sq = self.x.square(cs.namespace(|| "x_sq"))?;
 
     let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
-      let n = F::from(3) * x_sq.get_value().get()? + G::group_params().0;
-      let d = F::from(2) * *self.y.get_value().get()?;
-      if d == F::ZERO {
-        Ok(F::ONE)
+      let n = G::Base::from(3) * x_sq.get_value().get()? + G::group_params().0;
+      let d = G::Base::from(2) * *self.y.get_value().get()?;
+      if d == G::Base::ZERO {
+        Ok(G::Base::ONE)
       } else {
         Ok(n * d.invert().unwrap())
       }
@@ -841,8 +795,8 @@ where
     cs.enforce(
       || "Check that lambda is computed correctly",
       |lc| lc + lambda.get_variable(),
-      |lc| lc + (F::from(2), self.y.get_variable()),
-      |lc| lc + (F::from(3), x_sq.get_variable()) + (G::group_params().0, CS::one()),
+      |lc| lc + (G::Base::from(2), self.y.get_variable()),
+      |lc| lc + (G::Base::from(3), x_sq.get_variable()) + (G::group_params().0, CS::one()),
     );
 
     let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
@@ -857,7 +811,7 @@ where
       || "check that x is correct",
       |lc| lc + lambda.get_variable(),
       |lc| lc + lambda.get_variable(),
-      |lc| lc + x.get_variable() + (F::from(2), self.x.get_variable()),
+      |lc| lc + x.get_variable() + (G::Base::from(2), self.x.get_variable()),
     );
 
     let y = AllocatedNum::alloc(cs.namespace(|| "y"), || {
@@ -874,15 +828,11 @@ where
       |lc| lc + y.get_variable() + self.y.get_variable(),
     );
 
-    Ok(Self {
-      x,
-      y,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y })
   }
 
   /// If condition outputs a otherwise outputs b
-  pub fn conditionally_select<CS: ConstraintSystem<F>>(
+  pub fn conditionally_select<CS: ConstraintSystem<G::Base>>(
     mut cs: CS,
     a: &Self,
     b: &Self,
@@ -891,10 +841,6 @@ where
     let x = conditionally_select(cs.namespace(|| "select x"), &a.x, &b.x, condition)?;
     let y = conditionally_select(cs.namespace(|| "select y"), &a.y, &b.y, condition)?;
 
-    Ok(Self {
-      x,
-      y,
-      _marker: PhantomData,
-    })
+    Ok(Self { x, y })
   }
 }
diff --git a/src/parafold/nifs/circuit.rs b/src/parafold/nifs/circuit.rs
index 8d9401b0e..182d6f286 100644
--- a/src/parafold/nifs/circuit.rs
+++ b/src/parafold/nifs/circuit.rs
@@ -12,25 +12,25 @@ use crate::traits::Engine;
 
 /// Allocated [RelaxedR1CSInstance] for a circuit over the primary curve.
 #[derive(Debug, Clone)]
-pub struct AllocatedRelaxedR1CSInstance<E1: Engine> {
-  u: AllocatedNum<E1::Scalar>,
-  X: Vec<AllocatedNum<E1::Scalar>>,
-  W: AllocatedHashedCommitment<E1>,
-  E: AllocatedHashedCommitment<E1>,
+pub struct AllocatedRelaxedR1CSInstance<E: Engine> {
+  u: AllocatedNum<E::Scalar>,
+  X: Vec<AllocatedNum<E::Scalar>>,
+  W: AllocatedHashedCommitment<E>,
+  E: AllocatedHashedCommitment<E>,
 }
 
-impl<E1: Engine> AllocatedRelaxedR1CSInstance<E1> {
+impl<E: Engine> AllocatedRelaxedR1CSInstance<E> {
   /// Folds an R1CSInstance into `self`
   pub fn fold<CS>(
     self,
     mut cs: CS,
-    X_new: Vec<AllocatedNum<E1::Scalar>>,
-    acc_sm: &mut AllocatedScalarMulAccumulator<E1>,
-    fold_proof: FoldProof<E1>,
-    transcript: &mut AllocatedTranscript<E1>,
+    X_new: Vec<AllocatedNum<E::Scalar>>,
+    acc_sm: &mut AllocatedScalarMulAccumulator<E>,
+    fold_proof: FoldProof<E>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let FoldProof { W: W_new, T } = fold_proof;
 
@@ -87,12 +87,12 @@ impl<E1: Engine> AllocatedRelaxedR1CSInstance<E1> {
     mut cs: CS,
     accs_L: Vec<Self>,
     accs_R: Vec<Self>,
-    acc_sm: &mut AllocatedScalarMulAccumulator<E1>,
-    proofs: Vec<MergeProof<E1>>,
-    transcript: &mut AllocatedTranscript<E1>,
+    acc_sm: &mut AllocatedScalarMulAccumulator<E>,
+    proofs: Vec<MergeProof<E>>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Result<Vec<Self>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // Add all cross-term commitments to the transcript.
     let Ts = proofs
@@ -171,19 +171,19 @@ impl<E1: Engine> AllocatedRelaxedR1CSInstance<E1> {
   pub fn hash<CS>(
     &self,
     mut cs: CS,
-    constants: &TranscriptConstants<E1>,
-  ) -> Result<AllocatedNum<E1::Scalar>, SynthesisError>
+    constants: &TranscriptConstants<E::Scalar>,
+  ) -> Result<AllocatedNum<E::Scalar>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
-    let mut transcript = AllocatedTranscript::<E1>::new(constants.clone());
+    let mut transcript = AllocatedTranscript::new(constants.clone());
     transcript.absorb(self.as_preimage());
     transcript.squeeze(&mut cs)
   }
 
-  pub fn alloc<CS>(mut cs: CS, instance: RelaxedR1CSInstance<E1>) -> Self
+  pub fn alloc<CS>(mut cs: CS, instance: RelaxedR1CSInstance<E>) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // TODO: Add the circuit digest
     let RelaxedR1CSInstance { u, X, W, E } = instance;
@@ -199,7 +199,7 @@ impl<E1: Engine> AllocatedRelaxedR1CSInstance<E1> {
     Self { u, X, W, E }
   }
 
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E1::Scalar>> + '_ {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E::Scalar>> + '_ {
     // TODO: Add the circuit digest
     chain![
       [self.u.clone()],
diff --git a/src/parafold/nifs/circuit_secondary.rs b/src/parafold/nifs/circuit_secondary.rs
index c9fdce3a8..423e89473 100644
--- a/src/parafold/nifs/circuit_secondary.rs
+++ b/src/parafold/nifs/circuit_secondary.rs
@@ -13,36 +13,32 @@ use crate::gadgets::utils::{alloc_bignat_constant, conditionally_select_bignat,
 use crate::parafold::ecc::AllocatedPoint;
 use crate::parafold::nifs::{FoldProof, MergeProof, RelaxedR1CSInstance};
 use crate::parafold::transcript::circuit::AllocatedTranscript;
-use crate::traits::Engine;
+use crate::traits::{CurveCycleEquipped, Engine};
 
 #[derive(Debug, Clone)]
-pub struct AllocatedSecondaryRelaxedR1CSInstance<E1: Engine, E2: Engine> {
-  pub u: BigNat<E1::Scalar>,
-  pub X: Vec<BigNat<E1::Scalar>>,
-  pub W: AllocatedPoint<E1::Scalar, E2::GE>,
-  pub E: AllocatedPoint<E1::Scalar, E2::GE>,
+pub struct AllocatedSecondaryRelaxedR1CSInstance<E: CurveCycleEquipped> {
+  pub u: BigNat<E::Scalar>,
+  pub X: Vec<BigNat<E::Scalar>>,
+  pub W: AllocatedPoint<<E::Secondary as Engine>::GE>,
+  pub E: AllocatedPoint<<E::Secondary as Engine>::GE>,
   // q: BigNat<E1::Scalar>, // = E2::Base::MODULUS
 }
 
-impl<E1, E2> AllocatedSecondaryRelaxedR1CSInstance<E1, E2>
-where
-  E1: Engine,
-  E2: Engine<Base = E1::Scalar>,
-{
+impl<E: CurveCycleEquipped> AllocatedSecondaryRelaxedR1CSInstance<E> {
   pub fn fold<CS>(
     &mut self,
     mut cs: CS,
-    X_new: Vec<BigNat<E1::Scalar>>,
-    fold_proof: FoldProof<E2>,
-    transcript: &mut AllocatedTranscript<E1>,
+    X_new: Vec<BigNat<E::Scalar>>,
+    fold_proof: FoldProof<E::Secondary>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Result<(), SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // Allocate the order of the non-native field as a constant
     let q_bn = alloc_bignat_constant(
       cs.namespace(|| "alloc G::Base::modulus"),
-      &BigInt::from_str_radix(E2::Scalar::MODULUS, 16).unwrap(),
+      &BigInt::from_str_radix(E::Base::MODULUS, 16).unwrap(),
       BN_LIMB_WIDTH,
       BN_N_LIMBS,
     )?;
@@ -50,13 +46,12 @@ where
     let FoldProof { W: W_new, T } = fold_proof;
 
     // Allocate W_new, T and add them to the transcript
-    let W_new = AllocatedPoint::alloc_transcript::<_, E1, E2>(
+    let W_new = AllocatedPoint::alloc_transcript::<_, E, _>(
       cs.namespace(|| "alloc W_new"),
       W_new,
       transcript,
     );
-    let T =
-      AllocatedPoint::alloc_transcript::<_, E1, E2>(cs.namespace(|| "alloc T"), T, transcript);
+    let T = AllocatedPoint::alloc_transcript::<_, E, _>(cs.namespace(|| "alloc T"), T, transcript);
 
     // Get challenge `r` but truncate the bits for more efficient scalar multiplication
     let r_bits = transcript.squeeze_bits(cs.namespace(|| "r bits"), NUM_CHALLENGE_BITS)?;
@@ -109,20 +104,21 @@ where
 
     Ok(())
   }
+
   pub fn merge<CS>(
     mut cs: CS,
     self_L: Self,
     self_R: Self,
-    merge_proof: MergeProof<E2>,
-    transcript: &mut AllocatedTranscript<E1>,
+    merge_proof: MergeProof<E::Secondary>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // Allocate the order of the non-native field as a constant
     let q_bn = alloc_bignat_constant(
       cs.namespace(|| "alloc G::Base::modulus"),
-      &BigInt::from_str_radix(E2::Scalar::MODULUS, 16).unwrap(),
+      &BigInt::from_str_radix(E::Base::MODULUS, 16).unwrap(),
       BN_LIMB_WIDTH,
       BN_N_LIMBS,
     )?;
@@ -130,8 +126,7 @@ where
     let MergeProof { T } = merge_proof;
 
     // Allocate T and add to transcript
-    let T =
-      AllocatedPoint::alloc_transcript::<_, E1, E2>(cs.namespace(|| "alloc T"), T, transcript);
+    let T = AllocatedPoint::alloc_transcript::<_, E, _>(cs.namespace(|| "alloc T"), T, transcript);
     transcript.absorb(T.as_preimage());
 
     // Get truncated challenge
@@ -193,7 +188,7 @@ where
 
   pub fn enforce_trivial<CS>(&self, mut cs: CS, is_trivial: &Boolean)
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // TODO: If is_trivial
     // u = 0
@@ -206,9 +201,9 @@ where
       .enforce_trivial(cs.namespace(|| "enforce trivial E"), is_trivial);
   }
 
-  fn alloc<CS>(/*mut*/ _cs: CS, _instance: RelaxedR1CSInstance<E2>) -> Self
+  fn alloc<CS>(/*mut*/ _cs: CS, _instance: RelaxedR1CSInstance<E::Secondary>) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // Both u, X need to be allocated as BigInt
     todo!()
@@ -233,11 +228,11 @@ where
   /// Allocate and add the result to the transcript
   pub fn alloc_transcript<CS>(
     mut cs: CS,
-    instance: RelaxedR1CSInstance<E2>,
-    transcript: &mut AllocatedTranscript<E1>,
+    instance: RelaxedR1CSInstance<E::Secondary>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let instance = Self::alloc(&mut cs, instance);
     transcript.absorb(instance.as_preimage());
@@ -246,7 +241,7 @@ where
 
   pub fn select_default<CS>(self, mut cs: CS, is_default: &Boolean) -> Result<Self, SynthesisError>
   where
-    CS: ConstraintSystem<E2::Base>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let bn_zero = alloc_bignat_constant(
       cs.namespace(|| "alloc zero"),
@@ -265,7 +260,7 @@ where
     Ok(Self { u, X, W, E })
   }
 
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E1::Scalar>> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E::Scalar>> {
     vec![]
   }
 }
diff --git a/src/parafold/nifs/prover.rs b/src/parafold/nifs/prover.rs
index eb3bb5e16..79310a78e 100644
--- a/src/parafold/nifs/prover.rs
+++ b/src/parafold/nifs/prover.rs
@@ -9,7 +9,7 @@ use crate::parafold::transcript::prover::Transcript;
 use crate::parafold::transcript::TranscriptConstants;
 use crate::r1cs::R1CSShape;
 use crate::traits::commitment::{CommitmentEngineTrait, CommitmentTrait};
-use crate::traits::Engine;
+use crate::traits::{CurveCycleEquipped, Engine};
 use crate::{zip_with, Commitment, CommitmentKey, CE};
 
 /// A full Relaxed-R1CS accumulator for a circuit
@@ -46,33 +46,22 @@ impl<E: Engine> RelaxedR1CS<E> {
   /// while updating the transcript with the standard pattern.
   pub fn simulate_fold_primary(
     acc_sm: &mut ScalarMulAccumulator<E>,
-    transcript: &mut Transcript<E>,
+    transcript: &mut Transcript<E::Scalar>,
   ) -> FoldProof<E> {
     let W = Commitment::<E>::default();
     let T = Commitment::<E>::default();
-    transcript.absorb_commitment_primary(W);
-    transcript.absorb_commitment_primary(T);
+    transcript.absorb_commitment_primary::<E>(W);
+    transcript.absorb_commitment_primary::<E>(T);
     let r = transcript.squeeze();
     let _ = acc_sm.scalar_mul(W, W, r, transcript);
     let _ = acc_sm.scalar_mul(T, T, r, transcript);
     FoldProof { W, T }
   }
 
-  pub fn simulate_fold_secondary<E1: Engine<Scalar = E::Base, Base = E::Scalar>>(
-    transcript: &mut Transcript<E1>,
-  ) -> FoldProof<E> {
-    let W = Commitment::<E>::default();
-    let T = Commitment::<E>::default();
-    transcript.absorb_commitment_secondary::<E>(W);
-    transcript.absorb_commitment_secondary::<E>(T);
-    let _r = transcript.squeeze();
-    FoldProof { W, T }
-  }
-
   /// Given the public IO `X_new` for a circuit with R1CS representation `shape`,
   /// along with a satisfying witness vector `W_new`, and assuming `self` is a valid accumulator for the same circuit,
   /// this function will fold the statement into `self` and return a [FoldProof] that will allow the verifier to perform
-  /// the same transformation over the corresponding [RelaxedR1CSInstance] of the input `self`.  
+  /// the same transformation over the corresponding [RelaxedR1CSInstance] of the input `self`.
   ///
   /// # Warning
   /// We assume the R1CS IO `X_new` has already been absorbed in some form into the transcript in order to avoid
@@ -84,14 +73,14 @@ impl<E: Engine> RelaxedR1CS<E> {
     X_new: Vec<E::Scalar>,
     W_new: &[E::Scalar],
     acc_sm: &mut ScalarMulAccumulator<E>,
-    transcript: &mut Transcript<E>,
+    transcript: &mut Transcript<E::Scalar>,
   ) -> FoldProof<E> {
     // TODO: Parallelize both of these operations
     let W_comm_new = { E::CE::commit(ck, W_new) };
     let (T, T_comm) = { self.compute_fold_proof(ck, shape, None, &X_new, W_new) };
 
-    transcript.absorb_commitment_primary(W_comm_new);
-    transcript.absorb_commitment_primary(T_comm);
+    transcript.absorb_commitment_primary::<E>(W_comm_new);
+    transcript.absorb_commitment_primary::<E>(T_comm);
 
     let r = transcript.squeeze();
 
@@ -128,51 +117,6 @@ impl<E: Engine> RelaxedR1CS<E> {
     }
   }
 
-  pub fn fold_secondary<E1: Engine<Scalar = E::Base, Base = E::Scalar>>(
-    &mut self,
-    ck: &CommitmentKey<E>,
-    shape: &R1CSShape<E>,
-    X_new: Vec<E::Scalar>,
-    W_new: &[E::Scalar],
-    transcript: &mut Transcript<E1>,
-  ) -> FoldProof<E> {
-    // TODO: Parallelize both of these operations
-    let W_comm_new = { E::CE::commit(ck, W_new) };
-    let (T, T_comm) = { self.compute_fold_proof(ck, shape, None, &X_new, W_new) };
-
-    transcript.absorb(comm_to_base::<E>(&W_comm_new));
-    transcript.absorb(comm_to_base::<E>(&T_comm));
-    // TODO: Squeeze
-    let r = transcript.squeeze_bits_secondary(NUM_CHALLENGE_BITS);
-
-    self
-      .W
-      .par_iter_mut()
-      .zip_eq(W_new.par_iter())
-      .for_each(|(w, w_new)| *w += r * w_new);
-    self
-      .E
-      .par_iter_mut()
-      .zip_eq(T.par_iter())
-      .for_each(|(e, t)| *e += r * t);
-
-    // For non-relaxed instances, u_new = 1
-    self.instance.u += r;
-    self
-      .instance
-      .X
-      .iter_mut()
-      .zip_eq(X_new)
-      .for_each(|(x, x_new)| *x += r * x_new);
-    self.instance.W = self.instance.W + W_comm_new * r;
-    self.instance.E = self.instance.E + T_comm * r;
-
-    FoldProof {
-      W: W_comm_new,
-      T: T_comm,
-    }
-  }
-
   /// Given two lists of [RelaxedR1CS] accumulators,
   pub fn merge_many(
     ck: &CommitmentKey<E>,
@@ -180,7 +124,7 @@ impl<E: Engine> RelaxedR1CS<E> {
     mut accs_L: Vec<Self>,
     accs_R: &[Self],
     acc_sm: &mut ScalarMulAccumulator<E>,
-    transcript: &mut Transcript<E>,
+    transcript: &mut Transcript<E::Scalar>,
   ) -> (Vec<Self>, Vec<MergeProof<E>>) {
     // TODO: parallelize
     let (Ts, T_comms): (Vec<_>, Vec<_>) = zip_with!(
@@ -198,7 +142,7 @@ impl<E: Engine> RelaxedR1CS<E> {
     .unzip();
 
     for T_comm in &T_comms {
-      transcript.absorb_commitment_primary(*T_comm);
+      transcript.absorb_commitment_primary::<E>(*T_comm);
     }
     let r = transcript.squeeze();
 
@@ -249,57 +193,6 @@ impl<E: Engine> RelaxedR1CS<E> {
     .unzip()
   }
 
-  /// Given two lists of [RelaxedR1CS] accumulators,
-  pub fn merge_secondary<E1: Engine<Scalar = E::Base, Base = E::Scalar>>(
-    ck: &CommitmentKey<E>,
-    shape: &R1CSShape<E>,
-    acc_L: Self,
-    acc_R: &Self,
-    transcript: &mut Transcript<E1>,
-  ) -> (Self, MergeProof<E>) {
-    let (T, T_comm) = acc_L.compute_fold_proof(
-      ck,
-      shape,
-      Some(acc_R.instance.u),
-      &acc_R.instance.X,
-      &acc_R.W,
-    );
-
-    transcript.absorb(comm_to_base::<E>(&T_comm));
-    let r = transcript.squeeze_bits_secondary(NUM_CHALLENGE_BITS);
-
-    let W = zip_with!(
-      (acc_L.W.into_par_iter(), acc_R.W.par_iter()),
-      |w_L, w_R| w_L + r * w_R
-    )
-    .collect();
-
-    let E = zip_with!(
-      (acc_L.E.into_par_iter(), T.par_iter(), acc_R.E.par_iter()),
-      |e_L, t, e_R| e_L + r * (*t + r * e_R)
-    )
-    .collect();
-
-    let instance = {
-      let u = acc_L.instance.u + r * acc_R.instance.u;
-      let X = zip_eq(acc_L.instance.X, &acc_R.instance.X)
-        .map(|(x_L, x_R)| x_L + r * x_R)
-        .collect();
-
-      let W = acc_L.instance.W + acc_R.instance.W * r;
-      let E_tmp = T_comm + acc_R.instance.E * r;
-      let E = acc_L.instance.E + E_tmp * r;
-
-      RelaxedR1CSInstance { u, X, W, E }
-    };
-
-    let acc = Self { instance, W, E };
-
-    let merge_proof = MergeProof { T: T_comm };
-
-    (acc, merge_proof)
-  }
-
   fn compute_fold_proof(
     &self,
     ck: &CommitmentKey<E>,
@@ -355,6 +248,122 @@ impl<E: Engine> RelaxedR1CS<E> {
   }
 }
 
+impl<E2: Engine> RelaxedR1CS<E2> {
+  pub fn simulate_fold_secondary<E>(transcript: &mut Transcript<E::Scalar>) -> FoldProof<E2>
+  where
+    E: CurveCycleEquipped<Secondary = E2, Scalar = E2::Base>,
+  {
+    let W = Commitment::<E2>::default();
+    let T = Commitment::<E2>::default();
+    transcript.absorb_commitment_secondary::<E2>(W);
+    transcript.absorb_commitment_secondary::<E2>(T);
+    let _r = transcript.squeeze();
+    FoldProof { W, T }
+  }
+
+  pub fn fold_secondary<E>(
+    &mut self,
+    ck: &CommitmentKey<E2>,
+    shape: &R1CSShape<E2>,
+    X_new: Vec<E2::Scalar>,
+    W_new: &[E2::Scalar],
+    transcript: &mut Transcript<E::Scalar>,
+  ) -> FoldProof<E2>
+  where
+    E: CurveCycleEquipped<Secondary = E2, Scalar = E2::Base>,
+  {
+    // TODO: Parallelize both of these operations
+    let W_comm_new = { E2::CE::commit(ck, W_new) };
+    let (T, T_comm) = { self.compute_fold_proof(ck, shape, None, &X_new, W_new) };
+
+    transcript.absorb(comm_to_base::<E2>(&W_comm_new));
+    transcript.absorb(comm_to_base::<E2>(&T_comm));
+    // TODO: Squeeze
+    let r = transcript.squeeze_bits_secondary(NUM_CHALLENGE_BITS);
+
+    self
+      .W
+      .par_iter_mut()
+      .zip_eq(W_new.par_iter())
+      .for_each(|(w, w_new)| *w += r * w_new);
+    self
+      .E
+      .par_iter_mut()
+      .zip_eq(T.par_iter())
+      .for_each(|(e, t)| *e += r * t);
+
+    // For non-relaxed instances, u_new = 1
+    self.instance.u += r;
+    self
+      .instance
+      .X
+      .iter_mut()
+      .zip_eq(X_new)
+      .for_each(|(x, x_new)| *x += r * x_new);
+    self.instance.W = self.instance.W + W_comm_new * r;
+    self.instance.E = self.instance.E + T_comm * r;
+
+    FoldProof {
+      W: W_comm_new,
+      T: T_comm,
+    }
+  }
+
+  /// Given two lists of [RelaxedR1CS] accumulators,
+  pub fn merge_secondary<E>(
+    ck: &CommitmentKey<E2>,
+    shape: &R1CSShape<E2>,
+    acc_L: Self,
+    acc_R: &Self,
+    transcript: &mut Transcript<E::Scalar>,
+  ) -> (Self, MergeProof<E2>)
+  where
+    E: CurveCycleEquipped<Secondary = E2, Scalar = E2::Base>,
+  {
+    let (T, T_comm) = acc_L.compute_fold_proof(
+      ck,
+      shape,
+      Some(acc_R.instance.u),
+      &acc_R.instance.X,
+      &acc_R.W,
+    );
+
+    transcript.absorb(comm_to_base::<E2>(&T_comm));
+    let r = transcript.squeeze_bits_secondary(NUM_CHALLENGE_BITS);
+
+    let W = zip_with!(
+      (acc_L.W.into_par_iter(), acc_R.W.par_iter()),
+      |w_L, w_R| w_L + r * w_R
+    )
+    .collect();
+
+    let E = zip_with!(
+      (acc_L.E.into_par_iter(), T.par_iter(), acc_R.E.par_iter()),
+      |e_L, t, e_R| e_L + r * (*t + r * e_R)
+    )
+    .collect();
+
+    let instance = {
+      let u = acc_L.instance.u + r * acc_R.instance.u;
+      let X = zip_eq(acc_L.instance.X, &acc_R.instance.X)
+        .map(|(x_L, x_R)| x_L + r * x_R)
+        .collect();
+
+      let W = acc_L.instance.W + acc_R.instance.W * r;
+      let E_tmp = T_comm + acc_R.instance.E * r;
+      let E = acc_L.instance.E + E_tmp * r;
+
+      RelaxedR1CSInstance { u, X, W, E }
+    };
+
+    let acc = Self { instance, W, E };
+
+    let merge_proof = MergeProof { T: T_comm };
+
+    (acc, merge_proof)
+  }
+}
+
 impl<E: Engine> RelaxedR1CSInstance<E> {
   pub(crate) fn default(num_io: usize) -> Self {
     Self {
@@ -388,16 +397,16 @@ impl<E2: Engine> RelaxedR1CSInstance<E2> {
   }
 }
 
-impl<E1: Engine> RelaxedR1CSInstance<E1> {
+impl<E: Engine> RelaxedR1CSInstance<E> {
   /// On the primary curve, the instances are stored as hashes in the recursive state.
-  pub fn hash(&self, transcript_constants: &TranscriptConstants<E1>) -> E1::Scalar {
-    let mut transcript = Transcript::<E1>::new(transcript_constants.clone());
+  pub fn hash(&self, transcript_constants: &TranscriptConstants<E::Scalar>) -> E::Scalar {
+    let mut transcript = Transcript::new(transcript_constants.clone());
     let Self { u, X, W, E } = self;
 
     transcript.absorb([*u]);
     transcript.absorb(X.iter().cloned());
-    transcript.absorb_commitment_primary(*W);
-    transcript.absorb_commitment_primary(*E);
+    transcript.absorb_commitment_primary::<E>(*W);
+    transcript.absorb_commitment_primary::<E>(*E);
 
     transcript.squeeze()
   }
diff --git a/src/parafold/nivc/circuit.rs b/src/parafold/nivc/circuit.rs
index a8327f665..866c04a97 100644
--- a/src/parafold/nivc/circuit.rs
+++ b/src/parafold/nivc/circuit.rs
@@ -15,31 +15,26 @@ use crate::parafold::nivc::{
 use crate::parafold::transcript::circuit::AllocatedTranscript;
 use crate::parafold::transcript::TranscriptConstants;
 use crate::supernova::EnforcingStepCircuit;
-
-use crate::traits::Engine;
+use crate::traits::CurveCycleEquipped;
 
 /// A representation of a NIVC state, where `io` represents the computations inputs and outputs,
 /// and the `accs` are the accumulators for each step function that was used to produce this result.
 #[derive(Debug, Clone)]
-pub struct AllocatedNIVCState<E1: Engine, E2: Engine> {
-  io: AllocatedNIVCIO<E1::Scalar>,
-  accs_hash: Vec<AllocatedNum<E1::Scalar>>,
-  acc_cf: AllocatedSecondaryRelaxedR1CSInstance<E1, E2>,
+pub struct AllocatedNIVCState<E: CurveCycleEquipped> {
+  io: AllocatedNIVCIO<E::Scalar>,
+  accs_hash: Vec<AllocatedNum<E::Scalar>>,
+  acc_cf: AllocatedSecondaryRelaxedR1CSInstance<E>,
 }
 
-impl<E1, E2> AllocatedNIVCState<E1, E2>
-where
-  E1: Engine,
-  E2: Engine<Base = E1::Scalar>,
-{
+impl<E: CurveCycleEquipped> AllocatedNIVCState<E> {
   /// Loads a previously proved state from a proof of its correctness.
   pub fn from_proof<CS>(
     mut cs: CS,
-    ro_consts: &TranscriptConstants<E1>,
-    proof: NIVCUpdateProof<E1, E2>,
-  ) -> Result<(Self, AllocatedTranscript<E1>), SynthesisError>
+    ro_consts: &TranscriptConstants<E::Scalar>,
+    proof: NIVCUpdateProof<E>,
+  ) -> Result<(Self, AllocatedTranscript<E::Scalar>), SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let NIVCUpdateProof {
       transcript_init,
@@ -112,10 +107,10 @@ where
     &mut self,
     mut cs: CS,
     step_circuit: &SF,
-  ) -> Result<NIVCIO<E1::Scalar>, SynthesisError>
+  ) -> Result<NIVCIO<E::Scalar>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
-    SF: EnforcingStepCircuit<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
+    SF: EnforcingStepCircuit<E::Scalar>,
   {
     // Run the step circuit
     let cs_step = &mut cs.namespace(|| "synthesize");
@@ -134,12 +129,12 @@ where
     mut cs: CS,
     self_L: Self,
     self_R: Self,
-    ro_consts: &TranscriptConstants<E1>,
-    proof: NIVCMergeProof<E1, E2>,
-    transcript: &mut AllocatedTranscript<E1>,
-  ) -> Result<(Self, NIVCIO<E1::Scalar>), SynthesisError>
+    ro_consts: &TranscriptConstants<E::Scalar>,
+    proof: NIVCMergeProof<E>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
+  ) -> Result<(Self, NIVCIO<E::Scalar>), SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let mut acc_sm = AllocatedScalarMulAccumulator::new();
 
@@ -218,7 +213,7 @@ where
 
   pub fn inputize<CS>(&self, mut cs: CS) -> Result<(), SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     for x in self.as_preimage() {
       x.inputize(cs.namespace(|| "inputize"))?
@@ -228,11 +223,11 @@ where
 
   fn alloc_transcript<CS>(
     mut cs: CS,
-    state: NIVCStateInstance<E1, E2>,
-    transcript: &mut AllocatedTranscript<E1>,
+    state: NIVCStateInstance<E>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Self
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let NIVCStateInstance {
       io,
@@ -240,7 +235,7 @@ where
       acc_cf,
     } = state;
 
-    let io = AllocatedNIVCIO::alloc_transcript(cs.namespace(|| "alloc io"), io, transcript);
+    let io = AllocatedNIVCIO::alloc_transcript::<_, E>(cs.namespace(|| "alloc io"), io, transcript);
 
     let accs_hash = accs_hash
       .into_iter()
@@ -267,7 +262,7 @@ where
 
   fn enforce_base_case<CS>(&self, mut cs: CS, is_base_case: &Boolean)
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     // We only need to enforce that the NIVC IO is trivial.
     // We do not need to check that `accs` and `acc_sm` are trivial, the only requirement is that they are
@@ -286,17 +281,17 @@ where
   fn update_accs<CS>(
     &mut self,
     mut cs: CS,
-    ro_consts: &TranscriptConstants<E1>,
-    transcript_init: AllocatedNum<E1::Scalar>,
-    acc_prev: RelaxedR1CSInstance<E1>,
+    ro_consts: &TranscriptConstants<E::Scalar>,
+    transcript_init: AllocatedNum<E::Scalar>,
+    acc_prev: RelaxedR1CSInstance<E>,
     index_prev: Option<usize>,
-    nifs_fold_proof: FoldProof<E1>,
+    nifs_fold_proof: FoldProof<E>,
     is_base_case: &Boolean,
-    acc_sm: &mut AllocatedScalarMulAccumulator<E1>,
-    transcript: &mut AllocatedTranscript<E1>,
+    acc_sm: &mut AllocatedScalarMulAccumulator<E>,
+    transcript: &mut AllocatedTranscript<E::Scalar>,
   ) -> Result<(), SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     let (acc_prev_hash, acc_curr_hash) = {
       // Load pre-image of accumulator to be updated
@@ -361,7 +356,7 @@ where
         || "is_base.not = ∑_i bits[i]",
         |lc| lc,
         |lc| lc,
-        |_| is_base_case.not().lc(CS::one(), E1::Scalar::ONE) - &lc_sum,
+        |_| is_base_case.not().lc(CS::one(), E::Scalar::ONE) - &lc_sum,
       );
 
       bits
@@ -384,7 +379,7 @@ where
     Ok(())
   }
 
-  fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E1::Scalar>> + '_ {
+  fn as_preimage(&self) -> impl IntoIterator<Item = AllocatedNum<E::Scalar>> + '_ {
     chain![
       self.io.as_preimage(),
       self.accs_hash.iter().cloned(),
@@ -394,16 +389,16 @@ where
 
   fn load_accs<CS>(
     mut cs: CS,
-    accs_native: Vec<RelaxedR1CSInstance<E1>>,
-    accs_hash: Vec<AllocatedNum<E1::Scalar>>,
-    ro_consts: &TranscriptConstants<E1>,
-  ) -> Result<Vec<AllocatedRelaxedR1CSInstance<E1>>, SynthesisError>
+    accs_native: Vec<RelaxedR1CSInstance<E>>,
+    accs_hash: Vec<AllocatedNum<E::Scalar>>,
+    ro_consts: &TranscriptConstants<E::Scalar>,
+  ) -> Result<Vec<AllocatedRelaxedR1CSInstance<E>>, SynthesisError>
   where
-    CS: ConstraintSystem<E1::Scalar>,
+    CS: ConstraintSystem<E::Scalar>,
   {
     zip_eq(accs_native, accs_hash)
       .map(
-        |(acc_native, acc_hash): (RelaxedR1CSInstance<E1>, AllocatedNum<E1::Scalar>)| {
+        |(acc_native, acc_hash): (RelaxedR1CSInstance<E>, AllocatedNum<E::Scalar>)| {
           let acc = AllocatedRelaxedR1CSInstance::alloc(cs.namespace(|| "alloc acc"), acc_native);
           let acc_hash_real = acc.hash(cs.namespace(|| "hash acc"), ro_consts)?;
 
@@ -490,10 +485,10 @@ impl<F: PrimeField> AllocatedNIVCIO<F> {
     ]
   }
 
-  pub fn alloc_transcript<CS, E1: Engine<Scalar = F>>(
+  pub fn alloc_transcript<CS, E1: CurveCycleEquipped<Scalar = F>>(
     mut cs: CS,
     state: NIVCIO<F>,
-    transcript: &mut AllocatedTranscript<E1>,
+    transcript: &mut AllocatedTranscript<E1::Scalar>,
   ) -> Self
   where
     CS: ConstraintSystem<F>,
diff --git a/src/parafold/nivc/mod.rs b/src/parafold/nivc/mod.rs
index 7899d0003..4bf171577 100644
--- a/src/parafold/nivc/mod.rs
+++ b/src/parafold/nivc/mod.rs
@@ -2,7 +2,7 @@ use bellpepper_core::num::AllocatedNum;
 use ff::PrimeField;
 
 use crate::parafold::nifs::{FoldProof, MergeProof, RelaxedR1CSInstance};
-use crate::traits::Engine;
+use crate::traits::CurveCycleEquipped;
 
 pub mod circuit;
 pub mod prover;
@@ -30,33 +30,33 @@ pub struct AllocatedNIVCIO<F: PrimeField> {
 
 /// Succinct representation of the recursive NIVC state that is known
 #[derive(Clone, Debug)]
-pub struct NIVCStateInstance<E1: Engine, E2: Engine> {
-  io: NIVCIO<E1::Scalar>,
-  accs_hash: Vec<E1::Scalar>,
-  acc_cf: RelaxedR1CSInstance<E2>,
+pub struct NIVCStateInstance<E: CurveCycleEquipped> {
+  io: NIVCIO<E::Scalar>,
+  accs_hash: Vec<E::Scalar>,
+  acc_cf: RelaxedR1CSInstance<E::Secondary>,
 }
 
 /// A proof for loading a previous NIVC output inside a circuit.
 #[derive(Debug, Clone)]
-pub struct NIVCUpdateProof<E1: Engine, E2: Engine> {
-  transcript_init: E1::Scalar,
+pub struct NIVCUpdateProof<E: CurveCycleEquipped> {
+  transcript_init: E::Scalar,
 
-  state: NIVCStateInstance<E1, E2>,
+  state: NIVCStateInstance<E>,
 
-  acc_prev: RelaxedR1CSInstance<E1>,
+  acc_prev: RelaxedR1CSInstance<E>,
   index_prev: Option<usize>,
-  nifs_fold_proof: FoldProof<E1>,
+  nifs_fold_proof: FoldProof<E>,
 
-  sm_fold_proofs: [FoldProof<E2>; 2],
+  sm_fold_proofs: [FoldProof<E::Secondary>; 2],
 }
 
 #[derive(Debug, Clone)]
-pub struct NIVCMergeProof<E1: Engine, E2: Engine> {
-  accs_L: Vec<RelaxedR1CSInstance<E1>>,
-  accs_R: Vec<RelaxedR1CSInstance<E1>>,
-  nivc_merge_proof: Vec<MergeProof<E1>>,
+pub struct NIVCMergeProof<E: CurveCycleEquipped> {
+  accs_L: Vec<RelaxedR1CSInstance<E>>,
+  accs_R: Vec<RelaxedR1CSInstance<E>>,
+  nivc_merge_proof: Vec<MergeProof<E>>,
 
-  cf_merge_proof: MergeProof<E2>,
+  cf_merge_proof: MergeProof<E::Secondary>,
 
-  sm_fold_proofs: Vec<FoldProof<E2>>,
+  sm_fold_proofs: Vec<FoldProof<E::Secondary>>,
 }
diff --git a/src/parafold/nivc/prover.rs b/src/parafold/nivc/prover.rs
index 339068904..a932f1651 100644
--- a/src/parafold/nivc/prover.rs
+++ b/src/parafold/nivc/prover.rs
@@ -8,28 +8,24 @@ use crate::parafold::nivc::{NIVCMergeProof, NIVCStateInstance, NIVCUpdateProof,
 use crate::parafold::transcript::prover::Transcript;
 use crate::parafold::transcript::TranscriptConstants;
 use crate::r1cs::R1CSShape;
-use crate::traits::Engine;
+use crate::traits::{CurveCycleEquipped, Engine};
 use crate::CommitmentKey;
 
 #[derive(Debug)]
-pub struct NIVCState<E1: Engine, E2: Engine> {
-  transcript: Transcript<E1>,
-  io: NIVCIO<E1::Scalar>,
-  accs: Vec<RelaxedR1CS<E1>>,
-  acc_cf: RelaxedR1CS<E2>,
+pub struct NIVCState<E: CurveCycleEquipped> {
+  transcript: Transcript<E::Scalar>,
+  io: NIVCIO<E::Scalar>,
+  accs: Vec<RelaxedR1CS<E>>,
+  acc_cf: RelaxedR1CS<E::Secondary>,
 }
 
 #[derive(Debug)]
-pub struct NIVCUpdateWitness<E1: Engine> {
+pub struct NIVCUpdateWitness<E: Engine> {
   pub(crate) index: usize,
-  pub(crate) W: Vec<E1::Scalar>,
+  pub(crate) W: Vec<E::Scalar>,
 }
 
-impl<E1, E2> NIVCState<E1, E2>
-where
-  E1: Engine,
-  E2: Engine<Base = E1::Scalar, Scalar = E1::Base>,
-{
+impl<E: CurveCycleEquipped> NIVCState<E> {
   /// Initialize the prover state and create a default proof for the first iteration.
   ///
   /// # Details
@@ -40,13 +36,13 @@ where
   ///
   ///
   pub fn init(
-    shapes: &[R1CSShape<E1>],
-    shape_cf: &R1CSShape<E2>,
-    ro_consts: &TranscriptConstants<E1>,
+    shapes: &[R1CSShape<E>],
+    shape_cf: &R1CSShape<E::Secondary>,
+    ro_consts: &TranscriptConstants<E::Scalar>,
     pc_init: usize,
-    z_init: Vec<E1::Scalar>,
-  ) -> (Self, NIVCUpdateProof<E1, E2>) {
-    let transcript_init = E1::Scalar::ZERO;
+    z_init: Vec<E::Scalar>,
+  ) -> (Self, NIVCUpdateProof<E>) {
+    let transcript_init = E::Scalar::ZERO;
     let mut state = Self {
       transcript: Transcript::new_init(transcript_init, ro_consts.clone()),
       io: NIVCIO::new(pc_init, z_init),
@@ -62,7 +58,7 @@ where
 
     let mut acc_sm = ScalarMulAccumulator::new();
     let nifs_fold_proof = RelaxedR1CS::simulate_fold_primary(&mut acc_sm, &mut state.transcript);
-    let sm_fold_proofs: [FoldProof<E2>; 2] = acc_sm
+    let sm_fold_proofs: [FoldProof<E::Secondary>; 2] = acc_sm
       .simulate_finalize(&mut state.transcript)
       .try_into()
       .unwrap();
@@ -81,14 +77,14 @@ where
 
   fn update(
     &mut self,
-    ck: &CommitmentKey<E1>,
-    ck_cf: &CommitmentKey<E2>,
-    ro_consts: &TranscriptConstants<E1>,
-    shapes: &[R1CSShape<E1>],
-    shape_cf: &R1CSShape<E2>,
-    witness_prev: &NIVCUpdateWitness<E1>,
-  ) -> NIVCUpdateProof<E1, E2> {
-    let mut acc_sm = ScalarMulAccumulator::<E1>::new();
+    ck: &CommitmentKey<E>,
+    ck_cf: &CommitmentKey<E::Secondary>,
+    ro_consts: &TranscriptConstants<E::Scalar>,
+    shapes: &[R1CSShape<E>],
+    shape_cf: &R1CSShape<E::Secondary>,
+    witness_prev: &NIVCUpdateWitness<E>,
+  ) -> NIVCUpdateProof<E> {
+    let mut acc_sm = ScalarMulAccumulator::<E>::new();
     let transcript_init = self.transcript.seal();
 
     let state = self.instance(ro_consts);
@@ -115,7 +111,7 @@ where
       &mut self.transcript,
     );
 
-    let sm_fold_proofs: [FoldProof<E2>; 2] = acc_sm
+    let sm_fold_proofs: [FoldProof<E::Secondary>; 2] = acc_sm
       .finalize(ck_cf, shape_cf, &mut self.acc_cf, &mut self.transcript)
       .try_into()
       .unwrap();
@@ -131,13 +127,13 @@ where
   }
 
   pub fn merge(
-    ck: &CommitmentKey<E1>,
-    ck_cf: &CommitmentKey<E2>,
-    shapes: &[R1CSShape<E1>],
-    shape_cf: &R1CSShape<E2>,
+    ck: &CommitmentKey<E>,
+    ck_cf: &CommitmentKey<E::Secondary>,
+    shapes: &[R1CSShape<E>],
+    shape_cf: &R1CSShape<E::Secondary>,
     self_L: Self,
     self_R: &Self,
-  ) -> (Self, NIVCMergeProof<E1, E2>) {
+  ) -> (Self, NIVCMergeProof<E>) {
     let Self {
       transcript: transcript_L,
       io: io_L,
@@ -170,8 +166,13 @@ where
     let (accs, nivc_merge_proof) =
       RelaxedR1CS::merge_many(ck, shapes, accs_L, accs_R, &mut acc_sm, &mut transcript);
 
-    let (mut acc_cf, cf_merge_proof) =
-      RelaxedR1CS::merge_secondary(ck_cf, shape_cf, acc_cf_L, acc_cf_R, &mut transcript);
+    let (mut acc_cf, cf_merge_proof) = RelaxedR1CS::<E::Secondary>::merge_secondary::<E>(
+      ck_cf,
+      shape_cf,
+      acc_cf_L,
+      acc_cf_R,
+      &mut transcript,
+    );
 
     let sm_fold_proofs = acc_sm.finalize(ck_cf, shape_cf, &mut acc_cf, &mut transcript);
 
@@ -193,7 +194,7 @@ where
     (self_next, merge_proof)
   }
 
-  pub fn instance(&self, ro_consts: &TranscriptConstants<E1>) -> NIVCStateInstance<E1, E2> {
+  pub fn instance(&self, ro_consts: &TranscriptConstants<E::Scalar>) -> NIVCStateInstance<E> {
     let accs_hash = self
       .accs
       .iter()
@@ -208,12 +209,8 @@ where
   }
 }
 
-impl<E1, E2> NIVCStateInstance<E1, E2>
-where
-  E1: Engine,
-  E2: Engine<Base = E1::Scalar>,
-{
-  pub fn as_preimage(&self) -> impl IntoIterator<Item = E1::Scalar> + '_ {
+impl<E: CurveCycleEquipped> NIVCStateInstance<E> {
+  pub fn as_preimage(&self) -> impl IntoIterator<Item = E::Scalar> + '_ {
     chain![
       self.io.as_preimage(),
       self.accs_hash.iter().cloned(),
diff --git a/src/parafold/prover.rs b/src/parafold/prover.rs
index 13f41fb92..676db712c 100644
--- a/src/parafold/prover.rs
+++ b/src/parafold/prover.rs
@@ -2,29 +2,27 @@ use crate::parafold::nivc::prover::NIVCState;
 use crate::parafold::nivc::NIVCUpdateProof;
 use crate::parafold::transcript::TranscriptConstants;
 use crate::r1cs::R1CSShape;
-use crate::{CommitmentKey, Engine};
-pub struct ProvingKey<E1: Engine, E2: Engine> {
+use crate::traits::CurveCycleEquipped;
+use crate::CommitmentKey;
+
+pub struct ProvingKey<E: CurveCycleEquipped> {
   // public params
-  ck: CommitmentKey<E1>,
-  ck_cf: CommitmentKey<E2>,
+  ck: CommitmentKey<E>,
+  ck_cf: CommitmentKey<E::Secondary>,
   // Shapes for each augmented StepCircuit. The last shape is for the merge circuit.
-  shapes: Vec<R1CSShape<E1>>,
-  shape_cf: R1CSShape<E2>,
-  ro_consts: TranscriptConstants<E1>,
+  shapes: Vec<R1CSShape<E>>,
+  shape_cf: R1CSShape<E::Secondary>,
+  ro_consts: TranscriptConstants<E::Scalar>,
 }
 
-pub struct RecursiveSNARK<E1: Engine, E2: Engine> {
+pub struct RecursiveSNARK<E: CurveCycleEquipped> {
   // state
-  state: NIVCState<E1, E2>,
-  proof: NIVCUpdateProof<E1, E2>,
+  state: NIVCState<E>,
+  proof: NIVCUpdateProof<E>,
 }
 
-impl<E1, E2> RecursiveSNARK<E1, E2>
-where
-  E1: Engine,
-  E2: Engine<Scalar = E1::Base, Base = E1::Scalar>,
-{
-  pub fn new(pk: &ProvingKey<E1, E2>, pc_init: usize, z_init: Vec<E1::Scalar>) -> Self {
+impl<E: CurveCycleEquipped> RecursiveSNARK<E> {
+  pub fn new(pk: &ProvingKey<E>, pc_init: usize, z_init: Vec<E::Scalar>) -> Self {
     let num_circuits = pk.shapes.len();
     assert!(pc_init < num_circuits);
     // Check arity z_init.len();
diff --git a/src/parafold/transcript/circuit.rs b/src/parafold/transcript/circuit.rs
index e063c074d..cc59fbd70 100644
--- a/src/parafold/transcript/circuit.rs
+++ b/src/parafold/transcript/circuit.rs
@@ -1,6 +1,7 @@
 use bellpepper_core::boolean::{AllocatedBit, Boolean};
 use bellpepper_core::num::AllocatedNum;
 use bellpepper_core::{ConstraintSystem, SynthesisError};
+use ff::{PrimeField, PrimeFieldBits};
 use neptune::circuit2::Elt;
 use neptune::sponge::api::{IOPattern, SpongeAPI, SpongeOp};
 use neptune::sponge::circuit::SpongeCircuit;
@@ -8,15 +9,14 @@ use neptune::sponge::vanilla::Mode::Simplex;
 use neptune::sponge::vanilla::SpongeTrait;
 
 use crate::parafold::transcript::TranscriptConstants;
-use crate::traits::Engine;
 
-pub struct AllocatedTranscript<E: Engine> {
-  constants: TranscriptConstants<E>,
-  state: Vec<Elt<E::Scalar>>,
+pub struct AllocatedTranscript<F: PrimeField> {
+  constants: TranscriptConstants<F>,
+  state: Vec<Elt<F>>,
 }
 
-impl<E: Engine> AllocatedTranscript<E> {
-  pub fn new(constants: TranscriptConstants<E>) -> Self {
+impl<F: PrimeField> AllocatedTranscript<F> {
+  pub fn new(constants: TranscriptConstants<F>) -> Self {
     Self {
       constants,
       state: vec![],
@@ -25,11 +25,11 @@ impl<E: Engine> AllocatedTranscript<E> {
 
   pub fn new_init<CS>(
     mut cs: CS,
-    init: E::Scalar,
-    constants: TranscriptConstants<E>,
-  ) -> (Self, AllocatedNum<E::Scalar>)
+    init: F,
+    constants: TranscriptConstants<F>,
+  ) -> (Self, AllocatedNum<F>)
   where
-    CS: ConstraintSystem<E::Scalar>,
+    CS: ConstraintSystem<F>,
   {
     let init = AllocatedNum::alloc_infallible(&mut cs, || init);
     let init_elt = Elt::Allocated(init.clone());
@@ -42,22 +42,22 @@ impl<E: Engine> AllocatedTranscript<E> {
     )
   }
 
-  pub fn absorb(&mut self, elements: impl IntoIterator<Item = AllocatedNum<E::Scalar>>) {
+  pub fn absorb(&mut self, elements: impl IntoIterator<Item = AllocatedNum<F>>) {
     self.state.extend(elements.into_iter().map(Elt::Allocated));
   }
 
   pub(crate) fn inputize<CS>(&self, mut cs: CS) -> Result<(), SynthesisError>
   where
-    CS: ConstraintSystem<E::Scalar>,
+    CS: ConstraintSystem<F>,
   {
     assert_eq!(self.state.len(), 1);
     let state = self.state[0].ensure_allocated(&mut cs, false)?;
     state.inputize(&mut cs)
   }
 
-  pub fn squeeze<CS>(&mut self, mut cs: CS) -> Result<AllocatedNum<E::Scalar>, SynthesisError>
+  pub fn squeeze<CS>(&mut self, mut cs: CS) -> Result<AllocatedNum<F>, SynthesisError>
   where
-    CS: ConstraintSystem<E::Scalar>,
+    CS: ConstraintSystem<F>,
   {
     let num_absorbs = self.state.len() as u32;
 
@@ -83,7 +83,8 @@ impl<E: Engine> AllocatedTranscript<E> {
     num_bits: usize,
   ) -> Result<Vec<AllocatedBit>, SynthesisError>
   where
-    CS: ConstraintSystem<E::Scalar>,
+    CS: ConstraintSystem<F>,
+    F: PrimeFieldBits,
   {
     let hash = self.squeeze(&mut cs)?;
 
diff --git a/src/parafold/transcript/mod.rs b/src/parafold/transcript/mod.rs
index 69b4cc0c0..8eb2aed9b 100644
--- a/src/parafold/transcript/mod.rs
+++ b/src/parafold/transcript/mod.rs
@@ -1,10 +1,8 @@
 use generic_array::typenum::U24;
 use neptune::poseidon::PoseidonConstants;
 
-use crate::traits::Engine;
-
 pub mod circuit;
 pub mod prover;
 
 /// Poseidon constants for hashing used for the Fiat-Shamir transcript
-pub type TranscriptConstants<E> = PoseidonConstants<<E as Engine>::Scalar, U24>;
+pub type TranscriptConstants<F> = PoseidonConstants<F, U24>;
diff --git a/src/parafold/transcript/prover.rs b/src/parafold/transcript/prover.rs
index 4ebb32d84..da2b15767 100644
--- a/src/parafold/transcript/prover.rs
+++ b/src/parafold/transcript/prover.rs
@@ -1,4 +1,4 @@
-use ff::{Field, PrimeFieldBits};
+use ff::{Field, PrimeField, PrimeFieldBits};
 use neptune::sponge::api::{IOPattern, SpongeAPI, SpongeOp};
 use neptune::sponge::vanilla::Mode::Simplex;
 use neptune::sponge::vanilla::{Sponge, SpongeTrait};
@@ -10,20 +10,20 @@ use crate::traits::Engine;
 use crate::Commitment;
 
 #[derive(Clone, Debug)]
-pub struct Transcript<E: Engine> {
-  constants: TranscriptConstants<E>,
-  state: Vec<E::Scalar>,
+pub struct Transcript<F: PrimeField> {
+  constants: TranscriptConstants<F>,
+  state: Vec<F>,
 }
 
-impl<E: Engine> Transcript<E> {
-  pub fn new(constants: TranscriptConstants<E>) -> Self {
+impl<F: PrimeField> Transcript<F> {
+  pub fn new(constants: TranscriptConstants<F>) -> Self {
     Self {
       constants,
       state: vec![],
     }
   }
 
-  pub fn new_init(init: E::Scalar, constants: TranscriptConstants<E>) -> Self {
+  pub fn new_init(init: F, constants: TranscriptConstants<F>) -> Self {
     Self {
       constants,
       state: vec![init],
@@ -32,22 +32,22 @@ impl<E: Engine> Transcript<E> {
 
   pub fn absorb<I>(&mut self, elements: I)
   where
-    I: IntoIterator<Item = E::Scalar>,
+    I: IntoIterator<Item = F>,
   {
     self.state.extend(elements);
   }
 
-  pub fn absorb_commitment_primary(&mut self, c: Commitment<E>) {
-    let c_hash = HashedCommitment::<E>::new(c);
+  pub fn absorb_commitment_primary<E1: Engine<Scalar = F>>(&mut self, c: Commitment<E1>) {
+    let c_hash = HashedCommitment::<E1>::new(c);
     self.absorb(c_hash.as_preimage());
   }
 
-  pub fn absorb_commitment_secondary<E2: Engine<Base = E::Scalar>>(&mut self, c: Commitment<E2>) {
+  pub fn absorb_commitment_secondary<E2: Engine<Base = F>>(&mut self, c: Commitment<E2>) {
     let (x, y, _) = c.to_coordinates();
     self.absorb([x, y]);
   }
 
-  pub fn squeeze(&mut self) -> E::Scalar {
+  pub fn squeeze(&mut self) -> F {
     let mut sponge = Sponge::new_with_constants(&self.constants, Simplex);
     let num_absorbs = self.state.len() as u32;
     let acc = &mut ();
@@ -61,13 +61,16 @@ impl<E: Engine> Transcript<E> {
     output
   }
 
-  pub fn squeeze_bits_secondary(&mut self, num_bits: usize) -> E::Base {
+  pub fn squeeze_bits_secondary<Base: Field>(&mut self, num_bits: usize) -> Base
+  where
+    F: PrimeFieldBits,
+  {
     let hash = self.squeeze();
 
     // Only return `num_bits`
     let bits = hash.to_le_bits();
-    let mut res = E::Base::ZERO;
-    let mut coeff = E::Base::ONE;
+    let mut res = Base::ZERO;
+    let mut coeff = Base::ONE;
     for bit in bits.into_iter().take(num_bits) {
       if bit {
         res += coeff;
@@ -77,7 +80,7 @@ impl<E: Engine> Transcript<E> {
     res
   }
 
-  pub fn seal(&self) -> E::Scalar {
+  pub fn seal(&self) -> F {
     assert_eq!(self.state.len(), 1);
     self.state[0]
   }