From 3e4c8ef6359da9ef4a2cc129dead8aa0709f52f3 Mon Sep 17 00:00:00 2001
From: Srinath Setty <srinath@microsoft.com>
Date: Thu, 16 Nov 2023 18:11:20 -0800
Subject: [PATCH] Refactor traits that allows implementing different engines
 for the same curve cycle (#263)

* rename Group to Engine

* port tests

* checkpoint

* checkpoint

* compiles

* update benchmarks and tests to use Engine

* rename GroupExt to DlogGroup

* move get_curve_params to Group and rename

* fix doc test; cargo fmt

* inline single trait requirements; fix comments

* cut comment
---
 benches/compressed-snark.rs     |  65 ++-
 benches/compute-digest.rs       |  23 +-
 benches/recursive-snark.rs      |  37 +-
 benches/sha256.rs               |  20 +-
 examples/minroot.rs             |  51 +-
 examples/signature.rs           | 312 ------------
 src/bellpepper/mod.rs           |  18 +-
 src/bellpepper/r1cs.rs          |  40 +-
 src/bellpepper/shape_cs.rs      |  28 +-
 src/bellpepper/solver.rs        |   4 +-
 src/bellpepper/test_shape_cs.rs |  50 +-
 src/circuit.rs                  | 207 ++++----
 src/digest.rs                   |  39 +-
 src/gadgets/ecc.rs              | 375 +++++++--------
 src/gadgets/nonnative/util.rs   |   8 +-
 src/gadgets/r1cs.rs             | 120 ++---
 src/gadgets/utils.rs            |  28 +-
 src/lib.rs                      | 827 +++++++++++++++-----------------
 src/nifs.rs                     | 143 +++---
 src/provider/bn256_grumpkin.rs  |  16 +-
 src/provider/ipa_pc.rs          | 191 ++++----
 src/provider/keccak.rs          |  66 +--
 src/provider/mod.rs             |  23 +-
 src/provider/pasta.rs           |  33 +-
 src/provider/pedersen.rs        | 227 +++++----
 src/provider/poseidon.rs        |  51 +-
 src/provider/secp_secq.rs       |  16 +-
 src/r1cs/mod.rs                 | 266 +++++-----
 src/r1cs/sparse.rs              |   9 +-
 src/spartan/direct.rs           | 113 +++--
 src/spartan/mod.rs              |  56 +--
 src/spartan/polys/univariate.rs |   5 +-
 src/spartan/ppsnark.rs          | 596 +++++++++++------------
 src/spartan/snark.rs            | 186 +++----
 src/spartan/sumcheck.rs         | 110 ++---
 src/traits/circuit.rs           |   5 +-
 src/traits/commitment.rs        |  46 +-
 src/traits/evaluation.rs        |  26 +-
 src/traits/mod.rs               |  52 +-
 src/traits/snark.rs             |  35 +-
 40 files changed, 2097 insertions(+), 2426 deletions(-)
 delete mode 100644 examples/signature.rs

diff --git a/benches/compressed-snark.rs b/benches/compressed-snark.rs
index 32900e6f6..95fdccd01 100644
--- a/benches/compressed-snark.rs
+++ b/benches/compressed-snark.rs
@@ -5,27 +5,28 @@ use core::marker::PhantomData;
 use criterion::*;
 use ff::PrimeField;
 use nova_snark::{
+  provider::pasta::{PallasEngine, VestaEngine},
   traits::{
     circuit::{StepCircuit, TrivialCircuit},
     snark::RelaxedR1CSSNARKTrait,
-    Group,
+    Engine,
   },
   CompressedSNARK, PublicParams, RecursiveSNARK,
 };
 use std::time::Duration;
 
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
-type EE1 = nova_snark::provider::ipa_pc::EvaluationEngine<G1>;
-type EE2 = nova_snark::provider::ipa_pc::EvaluationEngine<G2>;
+type E1 = PallasEngine;
+type E2 = VestaEngine;
+type EE1 = nova_snark::provider::ipa_pc::EvaluationEngine<E1>;
+type EE2 = nova_snark::provider::ipa_pc::EvaluationEngine<E2>;
 // SNARKs without computational commitments
-type S1 = nova_snark::spartan::snark::RelaxedR1CSSNARK<G1, EE1>;
-type S2 = nova_snark::spartan::snark::RelaxedR1CSSNARK<G2, EE2>;
+type S1 = nova_snark::spartan::snark::RelaxedR1CSSNARK<E1, EE1>;
+type S2 = nova_snark::spartan::snark::RelaxedR1CSSNARK<E2, EE2>;
 // SNARKs with computational commitments
-type SS1 = nova_snark::spartan::ppsnark::RelaxedR1CSSNARK<G1, EE1>;
-type SS2 = nova_snark::spartan::ppsnark::RelaxedR1CSSNARK<G2, EE2>;
-type C1 = NonTrivialCircuit<<G1 as Group>::Scalar>;
-type C2 = TrivialCircuit<<G2 as Group>::Scalar>;
+type SS1 = nova_snark::spartan::ppsnark::RelaxedR1CSSNARK<E1, EE1>;
+type SS2 = nova_snark::spartan::ppsnark::RelaxedR1CSSNARK<E2, EE2>;
+type C1 = NonTrivialCircuit<<E1 as Engine>::Scalar>;
+type C2 = TrivialCircuit<<E2 as Engine>::Scalar>;
 
 // To run these benchmarks, first download `criterion` with `cargo install cargo install cargo-criterion`.
 // Then `cargo criterion --bench compressed-snark`. The results are located in `target/criterion/data/<name-of-benchmark>`.
@@ -66,7 +67,7 @@ fn bench_compressed_snark(c: &mut Criterion) {
     let c_secondary = TrivialCircuit::default();
 
     // Produce public parameters
-    let pp = PublicParams::<G1, G2, C1, C2>::setup(
+    let pp = PublicParams::<E1, E2, C1, C2>::setup(
       &c_primary,
       &c_secondary,
       &*S1::ck_floor(),
@@ -78,12 +79,12 @@ fn bench_compressed_snark(c: &mut Criterion) {
 
     // produce a recursive SNARK
     let num_steps = 3;
-    let mut recursive_snark: RecursiveSNARK<G1, G2, C1, C2> = RecursiveSNARK::new(
+    let mut recursive_snark: RecursiveSNARK<E1, E2, C1, C2> = RecursiveSNARK::new(
       &pp,
       &c_primary,
       &c_secondary,
-      &[<G1 as Group>::Scalar::from(2u64)],
-      &[<G2 as Group>::Scalar::from(2u64)],
+      &[<E1 as Engine>::Scalar::from(2u64)],
+      &[<E2 as Engine>::Scalar::from(2u64)],
     )
     .unwrap();
 
@@ -95,8 +96,8 @@ fn bench_compressed_snark(c: &mut Criterion) {
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &[<G1 as Group>::Scalar::from(2u64)],
-        &[<G2 as Group>::Scalar::from(2u64)],
+        &[<E1 as Engine>::Scalar::from(2u64)],
+        &[<E2 as Engine>::Scalar::from(2u64)],
       );
       assert!(res.is_ok());
     }
@@ -123,8 +124,8 @@ fn bench_compressed_snark(c: &mut Criterion) {
           .verify(
             black_box(&vk),
             black_box(num_steps),
-            black_box(&[<G1 as Group>::Scalar::from(2u64)]),
-            black_box(&[<G2 as Group>::Scalar::from(2u64)]),
+            black_box(&[<E1 as Engine>::Scalar::from(2u64)]),
+            black_box(&[<E2 as Engine>::Scalar::from(2u64)]),
           )
           .is_ok());
       })
@@ -153,7 +154,7 @@ fn bench_compressed_snark_with_computational_commitments(c: &mut Criterion) {
     let c_secondary = TrivialCircuit::default();
 
     // Produce public parameters
-    let pp = PublicParams::<G1, G2, C1, C2>::setup(
+    let pp = PublicParams::<E1, E2, C1, C2>::setup(
       &c_primary,
       &c_secondary,
       &*SS1::ck_floor(),
@@ -164,12 +165,12 @@ fn bench_compressed_snark_with_computational_commitments(c: &mut Criterion) {
 
     // produce a recursive SNARK
     let num_steps = 3;
-    let mut recursive_snark: RecursiveSNARK<G1, G2, C1, C2> = RecursiveSNARK::new(
+    let mut recursive_snark: RecursiveSNARK<E1, E2, C1, C2> = RecursiveSNARK::new(
       &pp,
       &c_primary,
       &c_secondary,
-      &[<G1 as Group>::Scalar::from(2u64)],
-      &[<G2 as Group>::Scalar::from(2u64)],
+      &[<E1 as Engine>::Scalar::from(2u64)],
+      &[<E2 as Engine>::Scalar::from(2u64)],
     )
     .unwrap();
 
@@ -181,8 +182,8 @@ fn bench_compressed_snark_with_computational_commitments(c: &mut Criterion) {
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &[<G1 as Group>::Scalar::from(2u64)],
-        &[<G2 as Group>::Scalar::from(2u64)],
+        &[<E1 as Engine>::Scalar::from(2u64)],
+        &[<E2 as Engine>::Scalar::from(2u64)],
       );
       assert!(res.is_ok());
     }
@@ -209,8 +210,8 @@ fn bench_compressed_snark_with_computational_commitments(c: &mut Criterion) {
           .verify(
             black_box(&vk),
             black_box(num_steps),
-            black_box(&[<G1 as Group>::Scalar::from(2u64)]),
-            black_box(&[<G2 as Group>::Scalar::from(2u64)]),
+            black_box(&[<E1 as Engine>::Scalar::from(2u64)]),
+            black_box(&[<E2 as Engine>::Scalar::from(2u64)]),
           )
           .is_ok());
       })
@@ -226,10 +227,7 @@ struct NonTrivialCircuit<F: PrimeField> {
   _p: PhantomData<F>,
 }
 
-impl<F> NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> NonTrivialCircuit<F> {
   pub fn new(num_cons: usize) -> Self {
     Self {
       num_cons,
@@ -237,10 +235,7 @@ where
     }
   }
 }
-impl<F> StepCircuit<F> for NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> StepCircuit<F> for NonTrivialCircuit<F> {
   fn arity(&self) -> usize {
     1
   }
diff --git a/benches/compute-digest.rs b/benches/compute-digest.rs
index 5d1360466..4f47e7b0b 100644
--- a/benches/compute-digest.rs
+++ b/benches/compute-digest.rs
@@ -4,18 +4,19 @@ use bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use ff::PrimeField;
 use nova_snark::{
+  provider::pasta::{PallasEngine, VestaEngine},
   traits::{
     circuit::{StepCircuit, TrivialCircuit},
     snark::default_ck_hint,
-    Group,
+    Engine,
   },
   PublicParams,
 };
 
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
-type C1 = NonTrivialCircuit<<G1 as Group>::Scalar>;
-type C2 = TrivialCircuit<<G2 as Group>::Scalar>;
+type E1 = PallasEngine;
+type E2 = VestaEngine;
+type C1 = NonTrivialCircuit<<E1 as Engine>::Scalar>;
+type C2 = TrivialCircuit<<E2 as Engine>::Scalar>;
 
 criterion_group! {
 name = compute_digest;
@@ -28,7 +29,7 @@ criterion_main!(compute_digest);
 fn bench_compute_digest(c: &mut Criterion) {
   c.bench_function("compute_digest", |b| {
     b.iter(|| {
-      PublicParams::<G1, G2, C1, C2>::setup(
+      PublicParams::<E1, E2, C1, C2>::setup(
         black_box(&C1::new(10)),
         black_box(&C2::default()),
         black_box(&*default_ck_hint()),
@@ -44,10 +45,7 @@ struct NonTrivialCircuit<F: PrimeField> {
   _p: PhantomData<F>,
 }
 
-impl<F> NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> NonTrivialCircuit<F> {
   pub fn new(num_cons: usize) -> Self {
     Self {
       num_cons,
@@ -55,10 +53,7 @@ where
     }
   }
 }
-impl<F> StepCircuit<F> for NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> StepCircuit<F> for NonTrivialCircuit<F> {
   fn arity(&self) -> usize {
     1
   }
diff --git a/benches/recursive-snark.rs b/benches/recursive-snark.rs
index 9f4dd8cc9..67f817b79 100644
--- a/benches/recursive-snark.rs
+++ b/benches/recursive-snark.rs
@@ -5,19 +5,20 @@ use core::marker::PhantomData;
 use criterion::*;
 use ff::PrimeField;
 use nova_snark::{
+  provider::pasta::{PallasEngine, VestaEngine},
   traits::{
     circuit::{StepCircuit, TrivialCircuit},
     snark::default_ck_hint,
-    Group,
+    Engine,
   },
   PublicParams, RecursiveSNARK,
 };
 use std::time::Duration;
 
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
-type C1 = NonTrivialCircuit<<G1 as Group>::Scalar>;
-type C2 = TrivialCircuit<<G2 as Group>::Scalar>;
+type E1 = PallasEngine;
+type E2 = VestaEngine;
+type C1 = NonTrivialCircuit<<E1 as Engine>::Scalar>;
+type C2 = TrivialCircuit<<E2 as Engine>::Scalar>;
 
 // To run these benchmarks, first download `criterion` with `cargo install cargo install cargo-criterion`.
 // Then `cargo criterion --bench recursive-snark`. The results are located in `target/criterion/data/<name-of-benchmark>`.
@@ -57,7 +58,7 @@ fn bench_recursive_snark(c: &mut Criterion) {
     let c_secondary = TrivialCircuit::default();
 
     // Produce public parameters
-    let pp = PublicParams::<G1, G2, C1, C2>::setup(
+    let pp = PublicParams::<E1, E2, C1, C2>::setup(
       &c_primary,
       &c_secondary,
       &*default_ck_hint(),
@@ -69,12 +70,12 @@ fn bench_recursive_snark(c: &mut Criterion) {
     // the first step is cheaper than other steps owing to the presence of
     // a lot of zeros in the satisfying assignment
     let num_warmup_steps = 10;
-    let mut recursive_snark: RecursiveSNARK<G1, G2, C1, C2> = RecursiveSNARK::new(
+    let mut recursive_snark: RecursiveSNARK<E1, E2, C1, C2> = RecursiveSNARK::new(
       &pp,
       &c_primary,
       &c_secondary,
-      &[<G1 as Group>::Scalar::from(2u64)],
-      &[<G2 as Group>::Scalar::from(2u64)],
+      &[<E1 as Engine>::Scalar::from(2u64)],
+      &[<E2 as Engine>::Scalar::from(2u64)],
     )
     .unwrap();
 
@@ -86,8 +87,8 @@ fn bench_recursive_snark(c: &mut Criterion) {
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &[<G1 as Group>::Scalar::from(2u64)],
-        &[<G2 as Group>::Scalar::from(2u64)],
+        &[<E1 as Engine>::Scalar::from(2u64)],
+        &[<E2 as Engine>::Scalar::from(2u64)],
       );
       assert!(res.is_ok());
     }
@@ -112,8 +113,8 @@ fn bench_recursive_snark(c: &mut Criterion) {
           .verify(
             black_box(&pp),
             black_box(num_warmup_steps),
-            black_box(&[<G1 as Group>::Scalar::from(2u64)]),
-            black_box(&[<G2 as Group>::Scalar::from(2u64)]),
+            black_box(&[<E1 as Engine>::Scalar::from(2u64)]),
+            black_box(&[<E2 as Engine>::Scalar::from(2u64)]),
           )
           .is_ok());
       });
@@ -128,10 +129,7 @@ struct NonTrivialCircuit<F: PrimeField> {
   _p: PhantomData<F>,
 }
 
-impl<F> NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> NonTrivialCircuit<F> {
   pub fn new(num_cons: usize) -> Self {
     Self {
       num_cons,
@@ -139,10 +137,7 @@ where
     }
   }
 }
-impl<F> StepCircuit<F> for NonTrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> StepCircuit<F> for NonTrivialCircuit<F> {
   fn arity(&self) -> usize {
     1
   }
diff --git a/benches/sha256.rs b/benches/sha256.rs
index 0da6b9161..43d3c3215 100644
--- a/benches/sha256.rs
+++ b/benches/sha256.rs
@@ -3,27 +3,29 @@
 //! This code invokes a hand-written SHA-256 gadget from bellman/bellperson.
 //! It also uses code from bellman/bellperson to compare circuit-generated digest with sha2 crate's output
 #![allow(non_snake_case)]
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
 use bellpepper::gadgets::{sha256::sha256, Assignment};
 use bellpepper_core::{
   boolean::{AllocatedBit, Boolean},
   num::{AllocatedNum, Num},
   ConstraintSystem, SynthesisError,
 };
+use core::marker::PhantomData;
 use core::time::Duration;
 use criterion::*;
 use ff::{PrimeField, PrimeFieldBits};
 use nova_snark::{
+  provider::pasta::{PallasEngine, VestaEngine},
   traits::{
     circuit::{StepCircuit, TrivialCircuit},
     snark::default_ck_hint,
-    Group,
+    Engine,
   },
   PublicParams, RecursiveSNARK,
 };
 use sha2::{Digest, Sha256};
-use std::marker::PhantomData;
+
+type E1 = PallasEngine;
+type E2 = VestaEngine;
 
 #[derive(Clone, Debug)]
 struct Sha256Circuit<Scalar: PrimeField> {
@@ -120,8 +122,8 @@ impl<Scalar: PrimeField + PrimeFieldBits> StepCircuit<Scalar> for Sha256Circuit<
   }
 }
 
-type C1 = Sha256Circuit<<G1 as Group>::Scalar>;
-type C2 = TrivialCircuit<<G2 as Group>::Scalar>;
+type C1 = Sha256Circuit<<E1 as Engine>::Scalar>;
+type C2 = TrivialCircuit<<E2 as Engine>::Scalar>;
 
 criterion_group! {
 name = recursive_snark;
@@ -156,7 +158,7 @@ fn bench_recursive_snark(c: &mut Criterion) {
 
     // Produce public parameters
     let ttc = TrivialCircuit::default();
-    let pp = PublicParams::<G1, G2, C1, C2>::setup(
+    let pp = PublicParams::<E1, E2, C1, C2>::setup(
       &circuit_primary,
       &ttc,
       &*default_ck_hint(),
@@ -164,8 +166,8 @@ fn bench_recursive_snark(c: &mut Criterion) {
     );
 
     let circuit_secondary = TrivialCircuit::default();
-    let z0_primary = vec![<G1 as Group>::Scalar::from(2u64)];
-    let z0_secondary = vec![<G2 as Group>::Scalar::from(2u64)];
+    let z0_primary = vec![<E1 as Engine>::Scalar::from(2u64)];
+    let z0_secondary = vec![<E2 as Engine>::Scalar::from(2u64)];
 
     group.bench_function("Prove", |b| {
       b.iter(|| {
diff --git a/examples/minroot.rs b/examples/minroot.rs
index 39771d110..dca39b34f 100644
--- a/examples/minroot.rs
+++ b/examples/minroot.rs
@@ -1,16 +1,15 @@
 //! Demonstrates how to use Nova to produce a recursive proof of the correct execution of
 //! iterations of the `MinRoot` function, thereby realizing a Nova-based verifiable delay function (VDF).
 //! We execute a configurable number of iterations of the `MinRoot` function per step of Nova's recursion.
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
 use bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
 use ff::PrimeField;
 use flate2::{write::ZlibEncoder, Compression};
 use nova_snark::{
+  provider::pasta::{PallasEngine, VestaEngine},
   traits::{
     circuit::{StepCircuit, TrivialCircuit},
     snark::default_ck_hint,
-    Group,
+    Engine,
   },
   CompressedSNARK, PublicParams, RecursiveSNARK,
 };
@@ -19,6 +18,9 @@ use std::time::Instant;
 use tracing_subscriber::{fmt, prelude::*, EnvFilter, Registry};
 use tracing_texray::TeXRayLayer;
 
+type E1 = PallasEngine;
+type E2 = VestaEngine;
+
 #[derive(Clone, Debug)]
 struct MinRootIteration<F: PrimeField> {
   x_i: F,
@@ -74,10 +76,7 @@ struct MinRootCircuit<F: PrimeField> {
   seq: Vec<MinRootIteration<F>>,
 }
 
-impl<F> StepCircuit<F> for MinRootCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> StepCircuit<F> for MinRootCircuit<F> {
   fn arity(&self) -> usize {
     2
   }
@@ -149,10 +148,10 @@ fn main() {
     let circuit_primary = MinRootCircuit {
       seq: vec![
         MinRootIteration {
-          x_i: <G1 as Group>::Scalar::zero(),
-          y_i: <G1 as Group>::Scalar::zero(),
-          x_i_plus_1: <G1 as Group>::Scalar::zero(),
-          y_i_plus_1: <G1 as Group>::Scalar::zero(),
+          x_i: <E1 as Engine>::Scalar::zero(),
+          y_i: <E1 as Engine>::Scalar::zero(),
+          x_i_plus_1: <E1 as Engine>::Scalar::zero(),
+          y_i_plus_1: <E1 as Engine>::Scalar::zero(),
         };
         num_iters_per_step
       ],
@@ -166,10 +165,10 @@ fn main() {
     let start = Instant::now();
     println!("Producing public parameters...");
     let pp = PublicParams::<
-      G1,
-      G2,
-      MinRootCircuit<<G1 as Group>::Scalar>,
-      TrivialCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      MinRootCircuit<<E1 as Engine>::Scalar>,
+      TrivialCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &circuit_primary,
       &circuit_secondary,
@@ -199,8 +198,8 @@ fn main() {
     // produce non-deterministic advice
     let (z0_primary, minroot_iterations) = MinRootIteration::new(
       num_iters_per_step * num_steps,
-      &<G1 as Group>::Scalar::zero(),
-      &<G1 as Group>::Scalar::one(),
+      &<E1 as Engine>::Scalar::zero(),
+      &<E1 as Engine>::Scalar::one(),
     );
     let minroot_circuits = (0..num_steps)
       .map(|i| MinRootCircuit {
@@ -215,14 +214,14 @@ fn main() {
       })
       .collect::<Vec<_>>();
 
-    let z0_secondary = vec![<G2 as Group>::Scalar::zero()];
+    let z0_secondary = vec![<E2 as Engine>::Scalar::zero()];
 
-    type C1 = MinRootCircuit<<G1 as Group>::Scalar>;
-    type C2 = TrivialCircuit<<G2 as Group>::Scalar>;
+    type C1 = MinRootCircuit<<E1 as Engine>::Scalar>;
+    type C2 = TrivialCircuit<<E2 as Engine>::Scalar>;
     // produce a recursive SNARK
     println!("Generating a RecursiveSNARK...");
-    let mut recursive_snark: RecursiveSNARK<G1, G2, C1, C2> =
-      RecursiveSNARK::<G1, G2, C1, C2>::new(
+    let mut recursive_snark: RecursiveSNARK<E1, E2, C1, C2> =
+      RecursiveSNARK::<E1, E2, C1, C2>::new(
         &pp,
         &minroot_circuits[0],
         &circuit_secondary,
@@ -259,10 +258,10 @@ fn main() {
     let (pk, vk) = CompressedSNARK::<_, _, _, _, S1, S2>::setup(&pp).unwrap();
 
     let start = Instant::now();
-    type EE1 = nova_snark::provider::ipa_pc::EvaluationEngine<G1>;
-    type EE2 = nova_snark::provider::ipa_pc::EvaluationEngine<G2>;
-    type S1 = nova_snark::spartan::snark::RelaxedR1CSSNARK<G1, EE1>;
-    type S2 = nova_snark::spartan::snark::RelaxedR1CSSNARK<G2, EE2>;
+    type EE1 = nova_snark::provider::ipa_pc::EvaluationEngine<E1>;
+    type EE2 = nova_snark::provider::ipa_pc::EvaluationEngine<E2>;
+    type S1 = nova_snark::spartan::snark::RelaxedR1CSSNARK<E1, EE1>;
+    type S2 = nova_snark::spartan::snark::RelaxedR1CSSNARK<E2, EE2>;
 
     let res = CompressedSNARK::<_, _, _, _, S1, S2>::prove(&pp, &pk, &recursive_snark);
     println!(
diff --git a/examples/signature.rs b/examples/signature.rs
deleted file mode 100644
index 2d06b73d8..000000000
--- a/examples/signature.rs
+++ /dev/null
@@ -1,312 +0,0 @@
-use bellpepper_core::{
-  boolean::AllocatedBit, test_cs::TestConstraintSystem, ConstraintSystem, SynthesisError,
-};
-use core::ops::{AddAssign, MulAssign};
-use ff::{
-  derive::byteorder::{ByteOrder, LittleEndian},
-  Field, PrimeField, PrimeFieldBits,
-};
-use nova_snark::{gadgets::ecc::AllocatedPoint, traits::Group as NovaGroup};
-use num_bigint::BigUint;
-use pasta_curves::{
-  arithmetic::CurveAffine,
-  group::{Curve, Group},
-};
-use rand::{rngs::OsRng, RngCore};
-use sha3::{Digest, Sha3_512};
-
-#[derive(Debug, Clone, Copy)]
-pub struct SecretKey<G: Group>(G::Scalar);
-
-impl<G> SecretKey<G>
-where
-  G: Group,
-{
-  pub fn random(mut rng: impl RngCore) -> Self {
-    let secret = G::Scalar::random(&mut rng);
-    Self(secret)
-  }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct PublicKey<G: Group>(G);
-
-impl<G> PublicKey<G>
-where
-  G: Group,
-{
-  pub fn from_secret_key(s: &SecretKey<G>) -> Self {
-    let point = G::generator() * s.0;
-    Self(point)
-  }
-}
-
-#[derive(Clone)]
-pub struct Signature<G: Group> {
-  pub r: G,
-  pub s: G::Scalar,
-}
-
-impl<G> SecretKey<G>
-where
-  G: Group,
-{
-  pub fn sign(self, c: G::Scalar, mut rng: impl RngCore) -> Signature<G> {
-    // T
-    let mut t = [0u8; 80];
-    rng.fill_bytes(&mut t[..]);
-
-    // h = H(T || M)
-    let h = Self::hash_to_scalar(b"Nova_Ecdsa_Hash", &t[..], c.to_repr().as_mut());
-
-    // R = [h]G
-    let r = G::generator().mul(h);
-
-    // s = h + c * sk
-    let mut s = c;
-
-    s.mul_assign(&self.0);
-    s.add_assign(&h);
-
-    Signature { r, s }
-  }
-
-  fn mul_bits<B: AsRef<[u64]>>(s: &G::Scalar, bits: BitIterator<B>) -> G::Scalar {
-    let mut x = G::Scalar::ZERO;
-    for bit in bits {
-      x = x.double();
-
-      if bit {
-        x.add_assign(s)
-      }
-    }
-    x
-  }
-
-  fn to_uniform(digest: &[u8]) -> G::Scalar {
-    assert_eq!(digest.len(), 64);
-    let mut bits: [u64; 8] = [0; 8];
-    LittleEndian::read_u64_into(digest, &mut bits);
-    Self::mul_bits(&G::Scalar::ONE, BitIterator::new(bits))
-  }
-
-  pub fn to_uniform_32(digest: &[u8]) -> G::Scalar {
-    assert_eq!(digest.len(), 32);
-    let mut bits: [u64; 4] = [0; 4];
-    LittleEndian::read_u64_into(digest, &mut bits);
-    Self::mul_bits(&G::Scalar::ONE, BitIterator::new(bits))
-  }
-
-  pub fn hash_to_scalar(persona: &[u8], a: &[u8], b: &[u8]) -> G::Scalar {
-    let mut hasher = Sha3_512::new();
-    hasher.update(persona);
-    hasher.update(a);
-    hasher.update(b);
-    let digest = hasher.finalize();
-    Self::to_uniform(digest.as_ref())
-  }
-}
-
-impl<G> PublicKey<G>
-where
-  G: Group,
-  G::Scalar: PrimeFieldBits,
-{
-  pub fn verify(&self, c: G::Scalar, signature: &Signature<G>) -> bool {
-    let modulus = Self::modulus_as_scalar();
-    let order_check_pk = self.0.mul(modulus);
-    if !order_check_pk.eq(&G::identity()) {
-      return false;
-    }
-
-    let order_check_r = signature.r.mul(modulus);
-    if !order_check_r.eq(&G::identity()) {
-      return false;
-    }
-
-    // 0 = [-s]G + R + [c]PK
-    self
-      .0
-      .mul(c)
-      .add(&signature.r)
-      .add(G::generator().mul(signature.s).neg())
-      .eq(&G::identity())
-  }
-
-  fn modulus_as_scalar() -> G::Scalar {
-    let mut bits = G::Scalar::char_le_bits().to_bitvec();
-    let mut acc = BigUint::new(Vec::<u32>::new());
-    while let Some(b) = bits.pop() {
-      acc <<= 1_i32;
-      acc += u8::from(b);
-    }
-    let modulus = acc.to_str_radix(10);
-    G::Scalar::from_str_vartime(&modulus).unwrap()
-  }
-}
-
-#[derive(Debug)]
-pub struct BitIterator<E> {
-  t: E,
-  n: usize,
-}
-
-impl<E: AsRef<[u64]>> BitIterator<E> {
-  pub fn new(t: E) -> Self {
-    let n = t.as_ref().len() * 64;
-
-    BitIterator { t, n }
-  }
-}
-
-impl<E: AsRef<[u64]>> Iterator for BitIterator<E> {
-  type Item = bool;
-
-  fn next(&mut self) -> Option<bool> {
-    if self.n == 0 {
-      None
-    } else {
-      self.n -= 1;
-      let part = self.n / 64;
-      let bit = self.n - (64 * part);
-
-      Some(self.t.as_ref()[part] & (1 << bit) > 0)
-    }
-  }
-}
-
-// Synthesize a bit representation into circuit gadgets.
-pub fn synthesize_bits<F: PrimeField, CS: ConstraintSystem<F>>(
-  cs: &mut CS,
-  bits: &Option<Vec<bool>>,
-) -> Result<Vec<AllocatedBit>, SynthesisError> {
-  (0..F::NUM_BITS)
-    .map(|i| {
-      AllocatedBit::alloc(
-        cs.namespace(|| format!("bit {i}")),
-        Some(bits.as_ref().unwrap()[i as usize]),
-      )
-    })
-    .collect::<Result<Vec<AllocatedBit>, SynthesisError>>()
-}
-
-pub fn verify_signature<G: NovaGroup, CS: ConstraintSystem<G::Base>>(
-  cs: &mut CS,
-  pk: &AllocatedPoint<G>,
-  r: &AllocatedPoint<G>,
-  s_bits: &[AllocatedBit],
-  c_bits: &[AllocatedBit],
-) -> Result<(), SynthesisError> {
-  let g = AllocatedPoint::<G>::alloc(
-    cs.namespace(|| "g"),
-    Some((
-      G::Base::from_str_vartime(
-        "28948022309329048855892746252171976963363056481941647379679742748393362948096",
-      )
-      .unwrap(),
-      G::Base::from_str_vartime("2").unwrap(),
-      false,
-    )),
-  )
-  .unwrap();
-
-  cs.enforce(
-    || "gx is vesta curve",
-    |lc| lc + g.get_coordinates().0.get_variable(),
-    |lc| lc + CS::one(),
-    |lc| {
-      lc + (
-        G::Base::from_str_vartime(
-          "28948022309329048855892746252171976963363056481941647379679742748393362948096",
-        )
-        .unwrap(),
-        CS::one(),
-      )
-    },
-  );
-
-  cs.enforce(
-    || "gy is vesta curve",
-    |lc| lc + g.get_coordinates().1.get_variable(),
-    |lc| lc + CS::one(),
-    |lc| lc + (G::Base::from_str_vartime("2").unwrap(), CS::one()),
-  );
-
-  let sg = g.scalar_mul(cs.namespace(|| "[s]G"), s_bits)?;
-  let cpk = pk.scalar_mul(&mut cs.namespace(|| "[c]PK"), c_bits)?;
-  let rcpk = cpk.add(&mut cs.namespace(|| "R + [c]PK"), r)?;
-
-  let (rcpk_x, rcpk_y, _) = rcpk.get_coordinates();
-  let (sg_x, sg_y, _) = sg.get_coordinates();
-
-  cs.enforce(
-    || "sg_x == rcpk_x",
-    |lc| lc + sg_x.get_variable(),
-    |lc| lc + CS::one(),
-    |lc| lc + rcpk_x.get_variable(),
-  );
-
-  cs.enforce(
-    || "sg_y == rcpk_y",
-    |lc| lc + sg_y.get_variable(),
-    |lc| lc + CS::one(),
-    |lc| lc + rcpk_y.get_variable(),
-  );
-
-  Ok(())
-}
-
-type G1 = pasta_curves::pallas::Point;
-type G2 = pasta_curves::vesta::Point;
-
-fn main() {
-  let mut cs = TestConstraintSystem::<<G1 as Group>::Scalar>::new();
-  assert!(cs.is_satisfied());
-  assert_eq!(cs.num_constraints(), 0);
-
-  let sk = SecretKey::<G2>::random(&mut OsRng);
-  let pk = PublicKey::from_secret_key(&sk);
-
-  // generate a random message to sign
-  let c = <G2 as Group>::Scalar::random(&mut OsRng);
-
-  // sign and verify
-  let signature = sk.sign(c, &mut OsRng);
-  let result = pk.verify(c, &signature);
-  assert!(result);
-
-  // prepare inputs to the circuit gadget
-  let pk = {
-    let pkxy = pk.0.to_affine().coordinates().unwrap();
-
-    AllocatedPoint::<G2>::alloc(
-      cs.namespace(|| "pub key"),
-      Some((*pkxy.x(), *pkxy.y(), false)),
-    )
-    .unwrap()
-  };
-  let r = {
-    let rxy = signature.r.to_affine().coordinates().unwrap();
-    AllocatedPoint::alloc(cs.namespace(|| "r"), Some((*rxy.x(), *rxy.y(), false))).unwrap()
-  };
-  let s = {
-    let s_bits = signature
-      .s
-      .to_le_bits()
-      .iter()
-      .map(|b| *b)
-      .collect::<Vec<bool>>();
-
-    synthesize_bits(&mut cs.namespace(|| "s bits"), &Some(s_bits)).unwrap()
-  };
-  let c = {
-    let c_bits = c.to_le_bits().iter().map(|b| *b).collect::<Vec<bool>>();
-
-    synthesize_bits(&mut cs.namespace(|| "c bits"), &Some(c_bits)).unwrap()
-  };
-
-  // Check the signature was signed by the correct sk using the pk
-  verify_signature(&mut cs, &pk, &r, &s, &c).unwrap();
-
-  assert!(cs.is_satisfied());
-}
diff --git a/src/bellpepper/mod.rs b/src/bellpepper/mod.rs
index 5183a35a5..456f6cb5a 100644
--- a/src/bellpepper/mod.rs
+++ b/src/bellpepper/mod.rs
@@ -15,7 +15,8 @@ mod tests {
       shape_cs::ShapeCS,
       solver::SatisfyingAssignment,
     },
-    traits::{snark::default_ck_hint, Group},
+    provider::{bn256_grumpkin::Bn256Engine, pasta::PallasEngine, secp_secq::Secp256k1Engine},
+    traits::{snark::default_ck_hint, Engine},
   };
   use bellpepper_core::{num::AllocatedNum, ConstraintSystem};
   use ff::PrimeField;
@@ -40,17 +41,14 @@ mod tests {
     );
   }
 
-  fn test_alloc_bit_with<G>()
-  where
-    G: Group,
-  {
+  fn test_alloc_bit_with<E: Engine>() {
     // First create the shape
-    let mut cs: ShapeCS<G> = ShapeCS::new();
+    let mut cs: ShapeCS<E> = ShapeCS::new();
     synthesize_alloc_bit(&mut cs);
     let (shape, ck) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     // Now get the assignment
-    let mut cs = SatisfyingAssignment::<G>::new();
+    let mut cs = SatisfyingAssignment::<E>::new();
     synthesize_alloc_bit(&mut cs);
     let (inst, witness) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
 
@@ -60,8 +58,8 @@ mod tests {
 
   #[test]
   fn test_alloc_bit() {
-    test_alloc_bit_with::<pasta_curves::pallas::Point>();
-    test_alloc_bit_with::<crate::provider::bn256_grumpkin::bn256::Point>();
-    test_alloc_bit_with::<crate::provider::secp_secq::secp256k1::Point>();
+    test_alloc_bit_with::<PallasEngine>();
+    test_alloc_bit_with::<Bn256Engine>();
+    test_alloc_bit_with::<Secp256k1Engine>();
   }
 }
diff --git a/src/bellpepper/r1cs.rs b/src/bellpepper/r1cs.rs
index eecddf317..131c032c3 100644
--- a/src/bellpepper/r1cs.rs
+++ b/src/bellpepper/r1cs.rs
@@ -6,49 +6,49 @@ use super::{shape_cs::ShapeCS, solver::SatisfyingAssignment, test_shape_cs::Test
 use crate::{
   errors::NovaError,
   r1cs::{commitment_key, CommitmentKeyHint, R1CSInstance, R1CSShape, R1CSWitness, SparseMatrix},
-  traits::Group,
+  traits::Engine,
   CommitmentKey,
 };
 use bellpepper_core::{Index, LinearCombination};
 use ff::PrimeField;
 
 /// `NovaWitness` provide a method for acquiring an `R1CSInstance` and `R1CSWitness` from implementers.
-pub trait NovaWitness<G: Group> {
+pub trait NovaWitness<E: Engine> {
   /// Return an instance and witness, given a shape and ck.
   fn r1cs_instance_and_witness(
     &self,
-    shape: &R1CSShape<G>,
-    ck: &CommitmentKey<G>,
-  ) -> Result<(R1CSInstance<G>, R1CSWitness<G>), NovaError>;
+    shape: &R1CSShape<E>,
+    ck: &CommitmentKey<E>,
+  ) -> Result<(R1CSInstance<E>, R1CSWitness<E>), NovaError>;
 }
 
 /// `NovaShape` provides methods for acquiring `R1CSShape` and `CommitmentKey` from implementers.
-pub trait NovaShape<G: Group> {
+pub trait NovaShape<E: Engine> {
   /// Return an appropriate `R1CSShape` and `CommitmentKey` structs.
   /// A `CommitmentKeyHint` should be provided to help guide the construction of the `CommitmentKey`.
   /// This parameter is documented in `r1cs::R1CS::commitment_key`.
-  fn r1cs_shape_and_key(&self, ck_hint: &CommitmentKeyHint<G>) -> (R1CSShape<G>, CommitmentKey<G>) {
+  fn r1cs_shape_and_key(&self, ck_hint: &CommitmentKeyHint<E>) -> (R1CSShape<E>, CommitmentKey<E>) {
     let S = self.r1cs_shape();
     let ck = commitment_key(&S, ck_hint);
 
     (S, ck)
   }
   /// Return an appropriate `R1CSShape`.
-  fn r1cs_shape(&self) -> R1CSShape<G>;
+  fn r1cs_shape(&self) -> R1CSShape<E>;
 }
 
-impl<G: Group> NovaWitness<G> for SatisfyingAssignment<G> {
+impl<E: Engine> NovaWitness<E> for SatisfyingAssignment<E> {
   fn r1cs_instance_and_witness(
     &self,
-    shape: &R1CSShape<G>,
-    ck: &CommitmentKey<G>,
-  ) -> Result<(R1CSInstance<G>, R1CSWitness<G>), NovaError> {
-    let W = R1CSWitness::<G>::new(shape, self.aux_assignment())?;
+    shape: &R1CSShape<E>,
+    ck: &CommitmentKey<E>,
+  ) -> Result<(R1CSInstance<E>, R1CSWitness<E>), NovaError> {
+    let W = R1CSWitness::<E>::new(shape, self.aux_assignment())?;
     let X = &self.input_assignment()[1..];
 
     let comm_W = W.commit(ck);
 
-    let instance = R1CSInstance::<G>::new(shape, &comm_W, X)?;
+    let instance = R1CSInstance::<E>::new(shape, &comm_W, X)?;
 
     Ok((instance, W))
   }
@@ -56,14 +56,14 @@ impl<G: Group> NovaWitness<G> for SatisfyingAssignment<G> {
 
 macro_rules! impl_nova_shape {
   ( $name:ident) => {
-    impl<G: Group> NovaShape<G> for $name<G>
+    impl<E: Engine> NovaShape<E> for $name<E>
     where
-      G::Scalar: PrimeField,
+      E::Scalar: PrimeField,
     {
-      fn r1cs_shape(&self) -> R1CSShape<G> {
-        let mut A = SparseMatrix::<G::Scalar>::empty();
-        let mut B = SparseMatrix::<G::Scalar>::empty();
-        let mut C: SparseMatrix<<G as Group>::Scalar> = SparseMatrix::<G::Scalar>::empty();
+      fn r1cs_shape(&self) -> R1CSShape<E> {
+        let mut A = SparseMatrix::<E::Scalar>::empty();
+        let mut B = SparseMatrix::<E::Scalar>::empty();
+        let mut C: SparseMatrix<<E as Engine>::Scalar> = SparseMatrix::<E::Scalar>::empty();
 
         let mut num_cons_added = 0;
         let mut X = (&mut A, &mut B, &mut C, &mut num_cons_added);
diff --git a/src/bellpepper/shape_cs.rs b/src/bellpepper/shape_cs.rs
index f3a5b7b64..57543401d 100644
--- a/src/bellpepper/shape_cs.rs
+++ b/src/bellpepper/shape_cs.rs
@@ -1,25 +1,25 @@
 //! Support for generating R1CS shape using bellpepper.
 
-use crate::traits::Group;
+use crate::traits::Engine;
 use bellpepper_core::{ConstraintSystem, Index, LinearCombination, SynthesisError, Variable};
 use ff::PrimeField;
 
 /// `ShapeCS` is a `ConstraintSystem` for creating `R1CSShape`s for a circuit.
-pub struct ShapeCS<G: Group>
+pub struct ShapeCS<E: Engine>
 where
-  G::Scalar: PrimeField,
+  E::Scalar: PrimeField,
 {
   /// All constraints added to the `ShapeCS`.
   pub constraints: Vec<(
-    LinearCombination<G::Scalar>,
-    LinearCombination<G::Scalar>,
-    LinearCombination<G::Scalar>,
+    LinearCombination<E::Scalar>,
+    LinearCombination<E::Scalar>,
+    LinearCombination<E::Scalar>,
   )>,
   inputs: usize,
   aux: usize,
 }
 
-impl<G: Group> ShapeCS<G> {
+impl<E: Engine> ShapeCS<E> {
   /// Create a new, default `ShapeCS`,
   pub fn new() -> Self {
     ShapeCS::default()
@@ -41,7 +41,7 @@ impl<G: Group> ShapeCS<G> {
   }
 }
 
-impl<G: Group> Default for ShapeCS<G> {
+impl<E: Engine> Default for ShapeCS<E> {
   fn default() -> Self {
     ShapeCS {
       constraints: vec![],
@@ -51,12 +51,12 @@ impl<G: Group> Default for ShapeCS<G> {
   }
 }
 
-impl<G: Group> ConstraintSystem<G::Scalar> for ShapeCS<G> {
+impl<E: Engine> ConstraintSystem<E::Scalar> for ShapeCS<E> {
   type Root = Self;
 
   fn alloc<F, A, AR>(&mut self, _annotation: A, _f: F) -> Result<Variable, SynthesisError>
   where
-    F: FnOnce() -> Result<G::Scalar, SynthesisError>,
+    F: FnOnce() -> Result<E::Scalar, SynthesisError>,
     A: FnOnce() -> AR,
     AR: Into<String>,
   {
@@ -67,7 +67,7 @@ impl<G: Group> ConstraintSystem<G::Scalar> for ShapeCS<G> {
 
   fn alloc_input<F, A, AR>(&mut self, _annotation: A, _f: F) -> Result<Variable, SynthesisError>
   where
-    F: FnOnce() -> Result<G::Scalar, SynthesisError>,
+    F: FnOnce() -> Result<E::Scalar, SynthesisError>,
     A: FnOnce() -> AR,
     AR: Into<String>,
   {
@@ -80,9 +80,9 @@ impl<G: Group> ConstraintSystem<G::Scalar> for ShapeCS<G> {
   where
     A: FnOnce() -> AR,
     AR: Into<String>,
-    LA: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
-    LB: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
-    LC: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
+    LA: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
+    LB: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
+    LC: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
   {
     let a = a(LinearCombination::zero());
     let b = b(LinearCombination::zero());
diff --git a/src/bellpepper/solver.rs b/src/bellpepper/solver.rs
index 516d0df93..4fc211a3b 100644
--- a/src/bellpepper/solver.rs
+++ b/src/bellpepper/solver.rs
@@ -1,8 +1,8 @@
 //! Support for generating R1CS witness using bellpepper.
 
-use crate::traits::Group;
+use crate::traits::Engine;
 
 use bellpepper::util_cs::witness_cs::WitnessCS;
 
 /// A `ConstraintSystem` which calculates witness values for a concrete instance of an R1CS circuit.
-pub type SatisfyingAssignment<G> = WitnessCS<<G as Group>::Scalar>;
+pub type SatisfyingAssignment<E> = WitnessCS<<E as Engine>::Scalar>;
diff --git a/src/bellpepper/test_shape_cs.rs b/src/bellpepper/test_shape_cs.rs
index 0626d7cf3..ca95ebba2 100644
--- a/src/bellpepper/test_shape_cs.rs
+++ b/src/bellpepper/test_shape_cs.rs
@@ -6,7 +6,7 @@ use std::{
   collections::{BTreeMap, HashMap},
 };
 
-use crate::traits::Group;
+use crate::traits::Engine;
 use bellpepper_core::{ConstraintSystem, Index, LinearCombination, SynthesisError, Variable};
 use core::fmt::Write;
 use ff::{Field, PrimeField};
@@ -48,17 +48,14 @@ impl Ord for OrderedVariable {
 }
 
 /// `TestShapeCS` is a `ConstraintSystem` for creating `R1CSShape`s for a circuit.
-pub struct TestShapeCS<G: Group>
-where
-  G::Scalar: PrimeField + Field,
-{
+pub struct TestShapeCS<E: Engine> {
   named_objects: HashMap<String, NamedObject>,
   current_namespace: Vec<String>,
   /// All constraints added to the `TestShapeCS`.
   pub constraints: Vec<(
-    LinearCombination<G::Scalar>,
-    LinearCombination<G::Scalar>,
-    LinearCombination<G::Scalar>,
+    LinearCombination<E::Scalar>,
+    LinearCombination<E::Scalar>,
+    LinearCombination<E::Scalar>,
     String,
   )>,
   inputs: Vec<String>,
@@ -91,9 +88,9 @@ fn proc_lc<Scalar: PrimeField>(
   map
 }
 
-impl<G: Group> TestShapeCS<G>
+impl<E: Engine> TestShapeCS<E>
 where
-  G::Scalar: PrimeField,
+  E::Scalar: PrimeField,
 {
   #[allow(unused)]
   /// Create a new, default `TestShapeCS`,
@@ -144,16 +141,16 @@ where
       writeln!(s, "INPUT {}", &input).unwrap()
     }
 
-    let negone = -<G::Scalar>::ONE;
+    let negone = -<E::Scalar>::ONE;
 
-    let powers_of_two = (0..G::Scalar::NUM_BITS)
-      .map(|i| G::Scalar::from(2u64).pow_vartime([u64::from(i)]))
+    let powers_of_two = (0..E::Scalar::NUM_BITS)
+      .map(|i| E::Scalar::from(2u64).pow_vartime([u64::from(i)]))
       .collect::<Vec<_>>();
 
-    let pp = |s: &mut String, lc: &LinearCombination<G::Scalar>| {
+    let pp = |s: &mut String, lc: &LinearCombination<E::Scalar>| {
       s.push('(');
       let mut is_first = true;
-      for (var, coeff) in proc_lc::<G::Scalar>(lc) {
+      for (var, coeff) in proc_lc::<E::Scalar>(lc) {
         if coeff == negone {
           s.push_str(" - ")
         } else if !is_first {
@@ -161,7 +158,7 @@ where
         }
         is_first = false;
 
-        if coeff != <G::Scalar>::ONE && coeff != negone {
+        if coeff != <E::Scalar>::ONE && coeff != negone {
           for (i, x) in powers_of_two.iter().enumerate() {
             if x == &coeff {
               write!(s, "2^{i} . ").unwrap();
@@ -216,13 +213,10 @@ where
   }
 }
 
-impl<G: Group> Default for TestShapeCS<G>
-where
-  G::Scalar: PrimeField,
-{
+impl<E: Engine> Default for TestShapeCS<E> {
   fn default() -> Self {
     let mut map = HashMap::new();
-    map.insert("ONE".into(), NamedObject::Var(TestShapeCS::<G>::one()));
+    map.insert("ONE".into(), NamedObject::Var(TestShapeCS::<E>::one()));
     TestShapeCS {
       named_objects: map,
       current_namespace: vec![],
@@ -233,15 +227,15 @@ where
   }
 }
 
-impl<G: Group> ConstraintSystem<G::Scalar> for TestShapeCS<G>
+impl<E: Engine> ConstraintSystem<E::Scalar> for TestShapeCS<E>
 where
-  G::Scalar: PrimeField,
+  E::Scalar: PrimeField,
 {
   type Root = Self;
 
   fn alloc<F, A, AR>(&mut self, annotation: A, _f: F) -> Result<Variable, SynthesisError>
   where
-    F: FnOnce() -> Result<G::Scalar, SynthesisError>,
+    F: FnOnce() -> Result<E::Scalar, SynthesisError>,
     A: FnOnce() -> AR,
     AR: Into<String>,
   {
@@ -253,7 +247,7 @@ where
 
   fn alloc_input<F, A, AR>(&mut self, annotation: A, _f: F) -> Result<Variable, SynthesisError>
   where
-    F: FnOnce() -> Result<G::Scalar, SynthesisError>,
+    F: FnOnce() -> Result<E::Scalar, SynthesisError>,
     A: FnOnce() -> AR,
     AR: Into<String>,
   {
@@ -267,9 +261,9 @@ where
   where
     A: FnOnce() -> AR,
     AR: Into<String>,
-    LA: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
-    LB: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
-    LC: FnOnce(LinearCombination<G::Scalar>) -> LinearCombination<G::Scalar>,
+    LA: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
+    LB: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
+    LC: FnOnce(LinearCombination<E::Scalar>) -> LinearCombination<E::Scalar>,
   {
     let path = compute_path(&self.current_namespace, &annotation().into());
     let index = self.constraints.len();
diff --git a/src/circuit.rs b/src/circuit.rs
index d3d1837f0..332e4abf9 100644
--- a/src/circuit.rs
+++ b/src/circuit.rs
@@ -15,7 +15,7 @@ use crate::{
   },
   r1cs::{R1CSInstance, RelaxedR1CSInstance},
   traits::{
-    circuit::StepCircuit, commitment::CommitmentTrait, Group, ROCircuitTrait, ROConstantsCircuit,
+    circuit::StepCircuit, commitment::CommitmentTrait, Engine, ROCircuitTrait, ROConstantsCircuit,
   },
   Commitment,
 };
@@ -48,26 +48,26 @@ impl NovaAugmentedCircuitParams {
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct NovaAugmentedCircuitInputs<G: Group> {
-  params: G::Scalar,
-  i: G::Base,
-  z0: Vec<G::Base>,
-  zi: Option<Vec<G::Base>>,
-  U: Option<RelaxedR1CSInstance<G>>,
-  u: Option<R1CSInstance<G>>,
-  T: Option<Commitment<G>>,
+pub struct NovaAugmentedCircuitInputs<E: Engine> {
+  params: E::Scalar,
+  i: E::Base,
+  z0: Vec<E::Base>,
+  zi: Option<Vec<E::Base>>,
+  U: Option<RelaxedR1CSInstance<E>>,
+  u: Option<R1CSInstance<E>>,
+  T: Option<Commitment<E>>,
 }
 
-impl<G: Group> NovaAugmentedCircuitInputs<G> {
+impl<E: Engine> NovaAugmentedCircuitInputs<E> {
   /// Create new inputs/witness for the verification circuit
   pub fn new(
-    params: G::Scalar,
-    i: G::Base,
-    z0: Vec<G::Base>,
-    zi: Option<Vec<G::Base>>,
-    U: Option<RelaxedR1CSInstance<G>>,
-    u: Option<R1CSInstance<G>>,
-    T: Option<Commitment<G>>,
+    params: E::Scalar,
+    i: E::Base,
+    z0: Vec<E::Base>,
+    zi: Option<Vec<E::Base>>,
+    U: Option<RelaxedR1CSInstance<E>>,
+    u: Option<R1CSInstance<E>>,
+    T: Option<Commitment<E>>,
   ) -> Self {
     Self {
       params,
@@ -83,20 +83,20 @@ impl<G: Group> NovaAugmentedCircuitInputs<G> {
 
 /// The augmented circuit F' in Nova that includes a step circuit F
 /// and the circuit for the verifier in Nova's non-interactive folding scheme
-pub struct NovaAugmentedCircuit<'a, G: Group, SC: StepCircuit<G::Base>> {
+pub struct NovaAugmentedCircuit<'a, E: Engine, SC: StepCircuit<E::Base>> {
   params: &'a NovaAugmentedCircuitParams,
-  ro_consts: ROConstantsCircuit<G>,
-  inputs: Option<NovaAugmentedCircuitInputs<G>>,
+  ro_consts: ROConstantsCircuit<E>,
+  inputs: Option<NovaAugmentedCircuitInputs<E>>,
   step_circuit: &'a SC, // The function that is applied for each step
 }
 
-impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
+impl<'a, E: Engine, SC: StepCircuit<E::Base>> NovaAugmentedCircuit<'a, E, SC> {
   /// Create a new verification circuit for the input relaxed r1cs instances
   pub const fn new(
     params: &'a NovaAugmentedCircuitParams,
-    inputs: Option<NovaAugmentedCircuitInputs<G>>,
+    inputs: Option<NovaAugmentedCircuitInputs<E>>,
     step_circuit: &'a SC,
-    ro_consts: ROConstantsCircuit<G>,
+    ro_consts: ROConstantsCircuit<E>,
   ) -> Self {
     Self {
       params,
@@ -107,24 +107,24 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
   }
 
   /// Allocate all witnesses and return
-  fn alloc_witness<CS: ConstraintSystem<<G as Group>::Base>>(
+  fn alloc_witness<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     mut cs: CS,
     arity: usize,
   ) -> Result<
     (
-      AllocatedNum<G::Base>,
-      AllocatedNum<G::Base>,
-      Vec<AllocatedNum<G::Base>>,
-      Vec<AllocatedNum<G::Base>>,
-      AllocatedRelaxedR1CSInstance<G>,
-      AllocatedR1CSInstance<G>,
-      AllocatedPoint<G>,
+      AllocatedNum<E::Base>,
+      AllocatedNum<E::Base>,
+      Vec<AllocatedNum<E::Base>>,
+      Vec<AllocatedNum<E::Base>>,
+      AllocatedRelaxedR1CSInstance<E>,
+      AllocatedR1CSInstance<E>,
+      AllocatedPoint<E>,
     ),
     SynthesisError,
   > {
     // Allocate the params
-    let params = alloc_scalar_as_base::<G, _>(
+    let params = alloc_scalar_as_base::<E, _>(
       cs.namespace(|| "params"),
       self.inputs.as_ref().map(|inputs| inputs.params),
     )?;
@@ -139,20 +139,20 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
           Ok(self.inputs.get()?.z0[i])
         })
       })
-      .collect::<Result<Vec<AllocatedNum<G::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     // Allocate zi. If inputs.zi is not provided (base case) allocate default value 0
-    let zero = vec![G::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<G::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     // Allocate the running instance
-    let U: AllocatedRelaxedR1CSInstance<G> = AllocatedRelaxedR1CSInstance::alloc(
+    let U: AllocatedRelaxedR1CSInstance<E> = AllocatedRelaxedR1CSInstance::alloc(
       cs.namespace(|| "Allocate U"),
       self.inputs.as_ref().and_then(|inputs| inputs.U.as_ref()),
       self.params.limb_width,
@@ -179,12 +179,12 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
   }
 
   /// Synthesizes base case and returns the new relaxed `R1CSInstance`
-  fn synthesize_base_case<CS: ConstraintSystem<<G as Group>::Base>>(
+  fn synthesize_base_case<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     mut cs: CS,
-    u: AllocatedR1CSInstance<G>,
-  ) -> Result<AllocatedRelaxedR1CSInstance<G>, SynthesisError> {
-    let U_default: AllocatedRelaxedR1CSInstance<G> = if self.params.is_primary_circuit {
+    u: AllocatedR1CSInstance<E>,
+  ) -> Result<AllocatedRelaxedR1CSInstance<E>, SynthesisError> {
+    let U_default: AllocatedRelaxedR1CSInstance<E> = if self.params.is_primary_circuit {
       // The primary circuit just returns the default R1CS instance
       AllocatedRelaxedR1CSInstance::default(
         cs.namespace(|| "Allocate U_default"),
@@ -205,20 +205,20 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
 
   /// Synthesizes non base case and returns the new relaxed `R1CSInstance`
   /// And a boolean indicating if all checks pass
-  fn synthesize_non_base_case<CS: ConstraintSystem<<G as Group>::Base>>(
+  fn synthesize_non_base_case<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     mut cs: CS,
-    params: &AllocatedNum<G::Base>,
-    i: &AllocatedNum<G::Base>,
-    z_0: &[AllocatedNum<G::Base>],
-    z_i: &[AllocatedNum<G::Base>],
-    U: &AllocatedRelaxedR1CSInstance<G>,
-    u: &AllocatedR1CSInstance<G>,
-    T: &AllocatedPoint<G>,
+    params: &AllocatedNum<E::Base>,
+    i: &AllocatedNum<E::Base>,
+    z_0: &[AllocatedNum<E::Base>],
+    z_i: &[AllocatedNum<E::Base>],
+    U: &AllocatedRelaxedR1CSInstance<E>,
+    u: &AllocatedR1CSInstance<E>,
+    T: &AllocatedPoint<E>,
     arity: usize,
-  ) -> Result<(AllocatedRelaxedR1CSInstance<G>, AllocatedBit), SynthesisError> {
+  ) -> Result<(AllocatedRelaxedR1CSInstance<E>, AllocatedBit), SynthesisError> {
     // Check that u.x[0] = Hash(params, U, i, z0, zi)
-    let mut ro = G::ROCircuit::new(
+    let mut ro = E::ROCircuit::new(
       self.ro_consts.clone(),
       NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * arity,
     );
@@ -255,12 +255,12 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
   }
 }
 
-impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
+impl<'a, E: Engine, SC: StepCircuit<E::Base>> NovaAugmentedCircuit<'a, E, SC> {
   /// synthesize circuit giving constraint system
-  pub fn synthesize<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn synthesize<CS: ConstraintSystem<<E as Engine>::Base>>(
     self,
     cs: &mut CS,
-  ) -> Result<Vec<AllocatedNum<G::Base>>, SynthesisError> {
+  ) -> Result<Vec<AllocatedNum<E::Base>>, SynthesisError> {
     let arity = self.step_circuit.arity();
 
     // Allocate all witnesses
@@ -310,7 +310,7 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
 
     // Compute i + 1
     let i_new = AllocatedNum::alloc(cs.namespace(|| "i + 1"), || {
-      Ok(*i.get_value().get()? + G::Base::ONE)
+      Ok(*i.get_value().get()? + E::Base::ONE)
     })?;
     cs.enforce(
       || "check i + 1",
@@ -338,7 +338,7 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
     }
 
     // Compute the new hash H(params, Unew, i+1, z0, z_{i+1})
-    let mut ro = G::ROCircuit::new(self.ro_consts, NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * arity);
+    let mut ro = E::ROCircuit::new(self.ro_consts, NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * arity);
     ro.absorb(&params);
     ro.absorb(&i_new);
     for e in &z_0 {
@@ -363,55 +363,58 @@ impl<'a, G: Group, SC: StepCircuit<G::Base>> NovaAugmentedCircuit<'a, G, SC> {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::bellpepper::{solver::SatisfyingAssignment, test_shape_cs::TestShapeCS};
-  type PastaG1 = pasta_curves::pallas::Point;
-  type PastaG2 = pasta_curves::vesta::Point;
-
-  use crate::constants::{BN_LIMB_WIDTH, BN_N_LIMBS};
-  use crate::provider;
-  use crate::traits::snark::default_ck_hint;
   use crate::{
-    bellpepper::r1cs::{NovaShape, NovaWitness},
+    bellpepper::{
+      r1cs::{NovaShape, NovaWitness},
+      solver::SatisfyingAssignment,
+      test_shape_cs::TestShapeCS,
+    },
+    constants::{BN_LIMB_WIDTH, BN_N_LIMBS},
     gadgets::utils::scalar_as_base,
-    provider::poseidon::PoseidonConstantsCircuit,
-    traits::circuit::TrivialCircuit,
+    provider::{
+      bn256_grumpkin::{Bn256Engine, GrumpkinEngine},
+      pasta::{PallasEngine, VestaEngine},
+      poseidon::PoseidonConstantsCircuit,
+      secp_secq::{Secp256k1Engine, Secq256k1Engine},
+    },
+    traits::{circuit::TrivialCircuit, snark::default_ck_hint},
   };
 
   // In the following we use 1 to refer to the primary, and 2 to refer to the secondary circuit
-  fn test_recursive_circuit_with<G1, G2>(
+  fn test_recursive_circuit_with<E1, E2>(
     primary_params: &NovaAugmentedCircuitParams,
     secondary_params: &NovaAugmentedCircuitParams,
-    ro_consts1: ROConstantsCircuit<G2>,
-    ro_consts2: ROConstantsCircuit<G1>,
+    ro_consts1: ROConstantsCircuit<E2>,
+    ro_consts2: ROConstantsCircuit<E1>,
     num_constraints_primary: usize,
     num_constraints_secondary: usize,
   ) where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
     let tc1 = TrivialCircuit::default();
     // Initialize the shape and ck for the primary
-    let circuit1: NovaAugmentedCircuit<'_, G2, TrivialCircuit<<G2 as Group>::Base>> =
+    let circuit1: NovaAugmentedCircuit<'_, E2, TrivialCircuit<<E2 as Engine>::Base>> =
       NovaAugmentedCircuit::new(primary_params, None, &tc1, ro_consts1.clone());
-    let mut cs: TestShapeCS<G1> = TestShapeCS::new();
+    let mut cs: TestShapeCS<E1> = TestShapeCS::new();
     let _ = circuit1.synthesize(&mut cs);
     let (shape1, ck1) = cs.r1cs_shape_and_key(&*default_ck_hint());
     assert_eq!(cs.num_constraints(), num_constraints_primary);
 
     let tc2 = TrivialCircuit::default();
     // Initialize the shape and ck for the secondary
-    let circuit2: NovaAugmentedCircuit<'_, G1, TrivialCircuit<<G1 as Group>::Base>> =
+    let circuit2: NovaAugmentedCircuit<'_, E1, TrivialCircuit<<E1 as Engine>::Base>> =
       NovaAugmentedCircuit::new(secondary_params, None, &tc2, ro_consts2.clone());
-    let mut cs: TestShapeCS<G2> = TestShapeCS::new();
+    let mut cs: TestShapeCS<E2> = TestShapeCS::new();
     let _ = circuit2.synthesize(&mut cs);
     let (shape2, ck2) = cs.r1cs_shape_and_key(&*default_ck_hint());
     assert_eq!(cs.num_constraints(), num_constraints_secondary);
 
     // Execute the base case for the primary
-    let zero1 = <<G2 as Group>::Base as Field>::ZERO;
-    let mut cs1 = SatisfyingAssignment::<G1>::new();
-    let inputs1: NovaAugmentedCircuitInputs<G2> = NovaAugmentedCircuitInputs::new(
-      scalar_as_base::<G1>(zero1), // pass zero for testing
+    let zero1 = <<E2 as Engine>::Base as Field>::ZERO;
+    let mut cs1 = SatisfyingAssignment::<E1>::new();
+    let inputs1: NovaAugmentedCircuitInputs<E2> = NovaAugmentedCircuitInputs::new(
+      scalar_as_base::<E1>(zero1), // pass zero for testing
       zero1,
       vec![zero1],
       None,
@@ -419,7 +422,7 @@ mod tests {
       None,
       None,
     );
-    let circuit1: NovaAugmentedCircuit<'_, G2, TrivialCircuit<<G2 as Group>::Base>> =
+    let circuit1: NovaAugmentedCircuit<'_, E2, TrivialCircuit<<E2 as Engine>::Base>> =
       NovaAugmentedCircuit::new(primary_params, Some(inputs1), &tc1, ro_consts1);
     let _ = circuit1.synthesize(&mut cs1);
     let (inst1, witness1) = cs1.r1cs_instance_and_witness(&shape1, &ck1).unwrap();
@@ -427,10 +430,10 @@ mod tests {
     assert!(shape1.is_sat(&ck1, &inst1, &witness1).is_ok());
 
     // Execute the base case for the secondary
-    let zero2 = <<G1 as Group>::Base as Field>::ZERO;
-    let mut cs2 = SatisfyingAssignment::<G2>::new();
-    let inputs2: NovaAugmentedCircuitInputs<G1> = NovaAugmentedCircuitInputs::new(
-      scalar_as_base::<G2>(zero2), // pass zero for testing
+    let zero2 = <<E1 as Engine>::Base as Field>::ZERO;
+    let mut cs2 = SatisfyingAssignment::<E2>::new();
+    let inputs2: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
+      scalar_as_base::<E2>(zero2), // pass zero for testing
       zero2,
       vec![zero2],
       None,
@@ -438,7 +441,7 @@ mod tests {
       Some(inst1),
       None,
     );
-    let circuit2: NovaAugmentedCircuit<'_, G1, TrivialCircuit<<G1 as Group>::Base>> =
+    let circuit2: NovaAugmentedCircuit<'_, E1, TrivialCircuit<<E1 as Engine>::Base>> =
       NovaAugmentedCircuit::new(secondary_params, Some(inputs2), &tc2, ro_consts2);
     let _ = circuit2.synthesize(&mut cs2);
     let (inst2, witness2) = cs2.r1cs_instance_and_witness(&shape2, &ck2).unwrap();
@@ -450,10 +453,10 @@ mod tests {
   fn test_recursive_circuit_pasta() {
     let params1 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
     let params2 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
-    let ro_consts1: ROConstantsCircuit<PastaG2> = PoseidonConstantsCircuit::default();
-    let ro_consts2: ROConstantsCircuit<PastaG1> = PoseidonConstantsCircuit::default();
+    let ro_consts1: ROConstantsCircuit<VestaEngine> = PoseidonConstantsCircuit::default();
+    let ro_consts2: ROConstantsCircuit<PallasEngine> = PoseidonConstantsCircuit::default();
 
-    test_recursive_circuit_with::<PastaG1, PastaG2>(
+    test_recursive_circuit_with::<PallasEngine, VestaEngine>(
       &params1, &params2, ro_consts1, ro_consts2, 9825, 10357,
     );
   }
@@ -462,29 +465,23 @@ mod tests {
   fn test_recursive_circuit_grumpkin() {
     let params1 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
     let params2 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
-    let ro_consts1: ROConstantsCircuit<provider::bn256_grumpkin::grumpkin::Point> =
-      PoseidonConstantsCircuit::default();
-    let ro_consts2: ROConstantsCircuit<provider::bn256_grumpkin::bn256::Point> =
-      PoseidonConstantsCircuit::default();
-
-    test_recursive_circuit_with::<
-      provider::bn256_grumpkin::bn256::Point,
-      provider::bn256_grumpkin::grumpkin::Point,
-    >(&params1, &params2, ro_consts1, ro_consts2, 9993, 10546);
+    let ro_consts1: ROConstantsCircuit<GrumpkinEngine> = PoseidonConstantsCircuit::default();
+    let ro_consts2: ROConstantsCircuit<Bn256Engine> = PoseidonConstantsCircuit::default();
+
+    test_recursive_circuit_with::<Bn256Engine, GrumpkinEngine>(
+      &params1, &params2, ro_consts1, ro_consts2, 9993, 10546,
+    );
   }
 
   #[test]
   fn test_recursive_circuit_secp() {
     let params1 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
     let params2 = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
-    let ro_consts1: ROConstantsCircuit<provider::secp_secq::secq256k1::Point> =
-      PoseidonConstantsCircuit::default();
-    let ro_consts2: ROConstantsCircuit<provider::secp_secq::secp256k1::Point> =
-      PoseidonConstantsCircuit::default();
-
-    test_recursive_circuit_with::<
-      provider::secp_secq::secp256k1::Point,
-      provider::secp_secq::secq256k1::Point,
-    >(&params1, &params2, ro_consts1, ro_consts2, 10272, 10969);
+    let ro_consts1: ROConstantsCircuit<Secq256k1Engine> = PoseidonConstantsCircuit::default();
+    let ro_consts2: ROConstantsCircuit<Secp256k1Engine> = PoseidonConstantsCircuit::default();
+
+    test_recursive_circuit_with::<Secp256k1Engine, Secq256k1Engine>(
+      &params1, &params2, ro_consts1, ro_consts2, 10272, 10969,
+    );
   }
 }
diff --git a/src/digest.rs b/src/digest.rs
index 5eb0c990b..fccf17b83 100644
--- a/src/digest.rs
+++ b/src/digest.rs
@@ -80,25 +80,24 @@ impl<'a, F: PrimeField, T: Digestible> DigestComputer<'a, F, T> {
 
 #[cfg(test)]
 mod tests {
+  use super::{DigestComputer, SimpleDigestible};
+  use crate::{provider::pasta::PallasEngine, traits::Engine};
   use ff::Field;
   use once_cell::sync::OnceCell;
-  use pasta_curves::pallas;
   use serde::{Deserialize, Serialize};
 
-  use crate::traits::Group;
-
-  use super::{DigestComputer, SimpleDigestible};
+  type E = PallasEngine;
 
   #[derive(Serialize, Deserialize)]
-  struct S<G: Group> {
+  struct S<E: Engine> {
     i: usize,
     #[serde(skip, default = "OnceCell::new")]
-    digest: OnceCell<G::Scalar>,
+    digest: OnceCell<E::Scalar>,
   }
 
-  impl<G: Group> SimpleDigestible for S<G> {}
+  impl<E: Engine> SimpleDigestible for S<E> {}
 
-  impl<G: Group> S<G> {
+  impl<E: Engine> S<E> {
     fn new(i: usize) -> Self {
       S {
         i,
@@ -106,7 +105,7 @@ mod tests {
       }
     }
 
-    fn digest(&self) -> G::Scalar {
+    fn digest(&self) -> E::Scalar {
       self
         .digest
         .get_or_try_init(|| DigestComputer::new(self).digest())
@@ -115,23 +114,21 @@ mod tests {
     }
   }
 
-  type G = pallas::Point;
-
   #[test]
   fn test_digest_field_not_ingested_in_computation() {
-    let s1 = S::<G>::new(42);
+    let s1 = S::<E>::new(42);
 
     // let's set up a struct with a weird digest field to make sure the digest computation does not depend of it
     let oc = OnceCell::new();
-    oc.set(<G as Group>::Scalar::ONE).unwrap();
+    oc.set(<E as Engine>::Scalar::ONE).unwrap();
 
-    let s2: S<G> = S { i: 42, digest: oc };
+    let s2: S<E> = S { i: 42, digest: oc };
 
     assert_eq!(
-      DigestComputer::<<G as Group>::Scalar, _>::new(&s1)
+      DigestComputer::<<E as Engine>::Scalar, _>::new(&s1)
         .digest()
         .unwrap(),
-      DigestComputer::<<G as Group>::Scalar, _>::new(&s2)
+      DigestComputer::<<E as Engine>::Scalar, _>::new(&s2)
         .digest()
         .unwrap()
     );
@@ -140,7 +137,7 @@ mod tests {
     // equality will not result in `s1.digest() == s2.digest`
     assert_ne!(
       s2.digest(),
-      DigestComputer::<<G as Group>::Scalar, _>::new(&s2)
+      DigestComputer::<<E as Engine>::Scalar, _>::new(&s2)
         .digest()
         .unwrap()
     );
@@ -148,19 +145,19 @@ mod tests {
 
   #[test]
   fn test_digest_impervious_to_serialization() {
-    let good_s = S::<G>::new(42);
+    let good_s = S::<E>::new(42);
 
     // let's set up a struct with a weird digest field to confuse deserializers
     let oc = OnceCell::new();
-    oc.set(<G as Group>::Scalar::ONE).unwrap();
+    oc.set(<E as Engine>::Scalar::ONE).unwrap();
 
-    let bad_s: S<G> = S { i: 42, digest: oc };
+    let bad_s: S<E> = S { i: 42, digest: oc };
     // this justifies the adjective "bad"
     assert_ne!(good_s.digest(), bad_s.digest());
 
     let naughty_bytes = bincode::serialize(&bad_s).unwrap();
 
-    let retrieved_s: S<G> = bincode::deserialize(&naughty_bytes).unwrap();
+    let retrieved_s: S<E> = bincode::deserialize(&naughty_bytes).unwrap();
     assert_eq!(good_s.digest(), retrieved_s.digest())
   }
 }
diff --git a/src/gadgets/ecc.rs b/src/gadgets/ecc.rs
index ac0090bbc..4c2121fdb 100644
--- a/src/gadgets/ecc.rs
+++ b/src/gadgets/ecc.rs
@@ -6,7 +6,7 @@ use crate::{
     select_num_or_one, select_num_or_zero, select_num_or_zero2, select_one_or_diff2,
     select_one_or_num2, select_zero_or_num2,
   },
-  traits::Group,
+  traits::{Engine, Group},
 };
 use bellpepper::gadgets::Assignment;
 use bellpepper_core::{
@@ -18,39 +18,33 @@ use ff::{Field, PrimeField};
 
 /// `AllocatedPoint` provides an elliptic curve abstraction inside a circuit.
 #[derive(Clone)]
-pub struct AllocatedPoint<G>
-where
-  G: Group,
-{
-  pub(crate) x: AllocatedNum<G::Base>,
-  pub(crate) y: AllocatedNum<G::Base>,
-  pub(crate) is_infinity: AllocatedNum<G::Base>,
+pub struct AllocatedPoint<E: Engine> {
+  pub(crate) x: AllocatedNum<E::Base>,
+  pub(crate) y: AllocatedNum<E::Base>,
+  pub(crate) is_infinity: AllocatedNum<E::Base>,
 }
 
-impl<G> AllocatedPoint<G>
+impl<E> AllocatedPoint<E>
 where
-  G: Group,
+  E: Engine,
 {
   /// 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>(
+  pub fn alloc<CS: ConstraintSystem<E::Base>>(
     mut cs: CS,
-    coords: Option<(G::Base, G::Base, bool)>,
-  ) -> Result<Self, SynthesisError>
-  where
-    CS: ConstraintSystem<G::Base>,
-  {
+    coords: Option<(E::Base, E::Base, bool)>,
+  ) -> Result<Self, SynthesisError> {
     let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
-      Ok(coords.map_or(G::Base::ZERO, |c| c.0))
+      Ok(coords.map_or(E::Base::ZERO, |c| c.0))
     })?;
     let y = AllocatedNum::alloc(cs.namespace(|| "y"), || {
-      Ok(coords.map_or(G::Base::ZERO, |c| c.1))
+      Ok(coords.map_or(E::Base::ZERO, |c| c.1))
     })?;
     let is_infinity = AllocatedNum::alloc(cs.namespace(|| "is_infinity"), || {
       Ok(if coords.map_or(true, |c| c.2) {
-        G::Base::ONE
+        E::Base::ONE
       } else {
-        G::Base::ZERO
+        E::Base::ZERO
       })
     })?;
     cs.enforce(
@@ -66,7 +60,7 @@ where
   /// 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<G::Base>,
+    CS: ConstraintSystem<E::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)
@@ -76,13 +70,13 @@ 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()? == G::Base::ONE {
-        Ok(G::Base::ZERO)
+      if *self.is_infinity.get_value().get()? == E::Base::ONE {
+        Ok(E::Base::ZERO)
       } else {
         Ok(
           *x_cube.get_value().get()?
-            + *self.x.get_value().get()? * G::get_curve_params().0
-            + G::get_curve_params().1,
+            + *self.x.get_value().get()? * E::GE::group_params().0
+            + E::GE::group_params().1,
         )
       }
     })?;
@@ -91,8 +85,8 @@ where
       || "rhs = (1-is_infinity) * (x^3 + Ax + B)",
       |lc| {
         lc + x_cube.get_variable()
-          + (G::get_curve_params().0, self.x.get_variable())
-          + (G::get_curve_params().1, CS::one())
+          + (E::GE::group_params().0, self.x.get_variable())
+          + (E::GE::group_params().1, CS::one())
       },
       |lc| lc + CS::one() - self.is_infinity.get_variable(),
       |lc| lc + rhs.get_variable(),
@@ -110,10 +104,7 @@ where
   }
 
   /// Allocates a default point on the curve, set to the identity point.
-  pub fn default<CS>(mut cs: CS) -> Result<Self, SynthesisError>
-  where
-    CS: ConstraintSystem<G::Base>,
-  {
+  pub fn default<CS: ConstraintSystem<E::Base>>(mut cs: CS) -> Result<Self, SynthesisError> {
     let zero = alloc_zero(cs.namespace(|| "zero"));
     let one = alloc_one(cs.namespace(|| "one"));
 
@@ -128,15 +119,15 @@ where
   pub const fn get_coordinates(
     &self,
   ) -> (
-    &AllocatedNum<G::Base>,
-    &AllocatedNum<G::Base>,
-    &AllocatedNum<G::Base>,
+    &AllocatedNum<E::Base>,
+    &AllocatedNum<E::Base>,
+    &AllocatedNum<E::Base>,
   ) {
     (&self.x, &self.y, &self.is_infinity)
   }
 
   /// Negates the provided point
-  pub fn negate<CS: ConstraintSystem<G::Base>>(&self, mut cs: CS) -> Result<Self, SynthesisError> {
+  pub fn negate<CS: ConstraintSystem<E::Base>>(&self, mut cs: CS) -> Result<Self, SynthesisError> {
     let y = AllocatedNum::alloc(cs.namespace(|| "y"), || Ok(-*self.y.get_value().get()?))?;
 
     cs.enforce(
@@ -154,10 +145,10 @@ where
   }
 
   /// Add two points (may be equal)
-  pub fn add<CS: ConstraintSystem<G::Base>>(
+  pub fn add<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
-    other: &AllocatedPoint<G>,
+    other: &AllocatedPoint<E>,
   ) -> Result<Self, SynthesisError> {
     // Compute boolean equal indicating if self = other
 
@@ -203,10 +194,10 @@ where
 
   /// Adds other point to this point and returns the result. Assumes that the two points are
   /// different and that both `other.is_infinity` and `this.is_infinty` are bits
-  pub fn add_internal<CS: ConstraintSystem<G::Base>>(
+  pub fn add_internal<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
-    other: &AllocatedPoint<G>,
+    other: &AllocatedPoint<E>,
     equal_x: &AllocatedBit,
   ) -> Result<Self, SynthesisError> {
     //************************************************************************/
@@ -221,9 +212,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(
-        G::Base::ONE
-          - (G::Base::ONE - *self.is_infinity.get_value().get()?)
-            * (G::Base::ONE - *other.is_infinity.get_value().get()?),
+        E::Base::ONE
+          - (E::Base::ONE - *self.is_infinity.get_value().get()?)
+            * (E::Base::ONE - *other.is_infinity.get_value().get()?),
       )
     })?;
     cs.enforce(
@@ -237,7 +228,7 @@ where
     let x_diff_is_actual =
       AllocatedNum::alloc(cs.namespace(|| "allocate x_diff_is_actual"), || {
         Ok(if *equal_x.get_value().get()? {
-          G::Base::ONE
+          E::Base::ONE
         } else {
           *at_least_one_inf.get_value().get()?
         })
@@ -259,9 +250,9 @@ where
     )?;
 
     let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
-      let x_diff_inv = if *x_diff_is_actual.get_value().get()? == G::Base::ONE {
+      let x_diff_inv = if *x_diff_is_actual.get_value().get()? == E::Base::ONE {
         // Set to default
-        G::Base::ONE
+        E::Base::ONE
       } else {
         // Set to the actual inverse
         (*other.x.get_value().get()? - *self.x.get_value().get()?)
@@ -366,13 +357,13 @@ where
   }
 
   /// Doubles the supplied point.
-  pub fn double<CS: ConstraintSystem<G::Base>>(&self, mut cs: CS) -> Result<Self, SynthesisError> {
+  pub fn double<CS: ConstraintSystem<E::Base>>(&self, mut cs: CS) -> Result<Self, SynthesisError> {
     //*************************************************************/
-    // lambda = (G::Base::from(3) * self.x * self.x + G::A())
-    //  * (G::Base::from(2)) * self.y).invert().unwrap();
+    // lambda = (E::Base::from(3) * self.x * self.x + E::GE::A())
+    //  * (E::Base::from(2)) * self.y).invert().unwrap();
     /*************************************************************/
 
-    // Compute tmp = (G::Base::ONE + G::Base::ONE)* self.y ? self != inf : 1
+    // Compute tmp = (E::Base::ONE + E::Base::ONE)* self.y ? self != inf : 1
     let tmp_actual = AllocatedNum::alloc(cs.namespace(|| "tmp_actual"), || {
       Ok(*self.y.get_value().get()? + *self.y.get_value().get()?)
     })?;
@@ -385,35 +376,35 @@ where
 
     let tmp = select_one_or_num2(cs.namespace(|| "tmp"), &tmp_actual, &self.is_infinity)?;
 
-    // Now compute lambda as (G::Base::from(3) * self.x * self.x + G::A()) * tmp_inv
+    // Now compute lambda as (E::Base::from(3) * self.x * self.x + E::GE::A()) * tmp_inv
 
     let prod_1 = AllocatedNum::alloc(cs.namespace(|| "alloc prod 1"), || {
-      Ok(G::Base::from(3) * self.x.get_value().get()? * self.x.get_value().get()?)
+      Ok(E::Base::from(3) * self.x.get_value().get()? * self.x.get_value().get()?)
     })?;
     cs.enforce(
       || "Check prod 1",
-      |lc| lc + (G::Base::from(3), self.x.get_variable()),
+      |lc| lc + (E::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()? == G::Base::ONE {
+      let tmp_inv = if *self.is_infinity.get_value().get()? == E::Base::ONE {
         // Return default value 1
-        G::Base::ONE
+        E::Base::ONE
       } else {
         // Return the actual inverse
         (*tmp.get_value().get()?).invert().unwrap()
       };
 
-      Ok(tmp_inv * (*prod_1.get_value().get()? + G::get_curve_params().0))
+      Ok(tmp_inv * (*prod_1.get_value().get()? + E::GE::group_params().0))
     })?;
 
     cs.enforce(
       || "Check lambda",
       |lc| lc + tmp.get_variable(),
       |lc| lc + lambda.get_variable(),
-      |lc| lc + prod_1.get_variable() + (G::get_curve_params().0, CS::one()),
+      |lc| lc + prod_1.get_variable() + (E::GE::group_params().0, CS::one()),
     );
 
     /*************************************************************/
@@ -470,12 +461,12 @@ where
   /// A gadget for scalar multiplication, optimized to use incomplete addition law.
   /// The optimization here is analogous to <https://github.com/arkworks-rs/r1cs-std/blob/6d64f379a27011b3629cf4c9cb38b7b7b695d5a0/src/groups/curves/short_weierstrass/mod.rs#L295>,
   /// except we use complete addition law over affine coordinates instead of projective coordinates for the tail bits
-  pub fn scalar_mul<CS: ConstraintSystem<G::Base>>(
+  pub fn scalar_mul<CS: ConstraintSystem<E::Base>>(
     &self,
     mut cs: CS,
     scalar_bits: &[AllocatedBit],
   ) -> Result<Self, SynthesisError> {
-    let split_len = core::cmp::min(scalar_bits.len(), (G::Base::NUM_BITS - 2) as usize);
+    let split_len = core::cmp::min(scalar_bits.len(), (E::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
@@ -559,7 +550,7 @@ where
   }
 
   /// If condition outputs a otherwise outputs b
-  pub fn conditionally_select<CS: ConstraintSystem<G::Base>>(
+  pub fn conditionally_select<CS: ConstraintSystem<E::Base>>(
     mut cs: CS,
     a: &Self,
     b: &Self,
@@ -580,7 +571,7 @@ where
   }
 
   /// If condition outputs a otherwise infinity
-  pub fn select_point_or_infinity<CS: ConstraintSystem<G::Base>>(
+  pub fn select_point_or_infinity<CS: ConstraintSystem<E::Base>>(
     mut cs: CS,
     a: &Self,
     condition: &Boolean,
@@ -601,28 +592,25 @@ where
 
 #[derive(Clone)]
 /// `AllocatedPoint` but one that is guaranteed to be not infinity
-pub struct AllocatedPointNonInfinity<G>
-where
-  G: Group,
-{
-  x: AllocatedNum<G::Base>,
-  y: AllocatedNum<G::Base>,
+pub struct AllocatedPointNonInfinity<E: Engine> {
+  x: AllocatedNum<E::Base>,
+  y: AllocatedNum<E::Base>,
 }
 
-impl<G> AllocatedPointNonInfinity<G>
+impl<E> AllocatedPointNonInfinity<E>
 where
-  G: Group,
+  E: Engine,
 {
   /// Creates a new `AllocatedPointNonInfinity` from the specified coordinates
-  pub const fn new(x: AllocatedNum<G::Base>, y: AllocatedNum<G::Base>) -> Self {
+  pub const fn new(x: AllocatedNum<E::Base>, y: AllocatedNum<E::Base>) -> Self {
     Self { x, y }
   }
 
   /// Allocates a new point on the curve using coordinates provided by `coords`.
-  pub fn alloc<CS>(mut cs: CS, coords: Option<(G::Base, G::Base)>) -> Result<Self, SynthesisError>
-  where
-    CS: ConstraintSystem<G::Base>,
-  {
+  pub fn alloc<CS: ConstraintSystem<E::Base>>(
+    mut cs: CS,
+    coords: Option<(E::Base, E::Base)>,
+  ) -> Result<Self, SynthesisError> {
     let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
       coords.map_or(Err(SynthesisError::AssignmentMissing), |c| Ok(c.0))
     })?;
@@ -634,7 +622,7 @@ where
   }
 
   /// Turns an `AllocatedPoint` into an `AllocatedPointNonInfinity` (assumes it is not infinity)
-  pub fn from_allocated_point(p: &AllocatedPoint<G>) -> Self {
+  pub fn from_allocated_point(p: &AllocatedPoint<E>) -> Self {
     Self {
       x: p.x.clone(),
       y: p.y.clone(),
@@ -644,8 +632,8 @@ where
   /// Returns an `AllocatedPoint` from an `AllocatedPointNonInfinity`
   pub fn to_allocated_point(
     &self,
-    is_infinity: &AllocatedNum<G::Base>,
-  ) -> Result<AllocatedPoint<G>, SynthesisError> {
+    is_infinity: &AllocatedNum<E::Base>,
+  ) -> Result<AllocatedPoint<E>, SynthesisError> {
     Ok(AllocatedPoint {
       x: self.x.clone(),
       y: self.y.clone(),
@@ -654,19 +642,19 @@ where
   }
 
   /// Returns coordinates associated with the point.
-  pub const fn get_coordinates(&self) -> (&AllocatedNum<G::Base>, &AllocatedNum<G::Base>) {
+  pub const fn get_coordinates(&self) -> (&AllocatedNum<E::Base>, &AllocatedNum<E::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<G::Base>,
+    CS: ConstraintSystem<E::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(G::Base::ONE)
+        Ok(E::Base::ONE)
       } else {
         Ok(
           (*other.y.get_value().get()? - *self.y.get_value().get()?)
@@ -721,19 +709,19 @@ where
   }
 
   /// 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>(&self, mut cs: CS) -> Result<Self, SynthesisError>
-  where
-    CS: ConstraintSystem<G::Base>,
-  {
+  pub fn double_incomplete<CS: ConstraintSystem<E::Base>>(
+    &self,
+    mut cs: CS,
+  ) -> Result<Self, SynthesisError> {
     // lambda = (3 x^2 + a) / 2 * y
 
     let x_sq = self.x.square(cs.namespace(|| "x_sq"))?;
 
     let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
-      let n = G::Base::from(3) * x_sq.get_value().get()? + G::get_curve_params().0;
-      let d = G::Base::from(2) * *self.y.get_value().get()?;
-      if d == G::Base::ZERO {
-        Ok(G::Base::ONE)
+      let n = E::Base::from(3) * x_sq.get_value().get()? + E::GE::group_params().0;
+      let d = E::Base::from(2) * *self.y.get_value().get()?;
+      if d == E::Base::ZERO {
+        Ok(E::Base::ONE)
       } else {
         Ok(n * d.invert().unwrap())
       }
@@ -741,8 +729,8 @@ where
     cs.enforce(
       || "Check that lambda is computed correctly",
       |lc| lc + lambda.get_variable(),
-      |lc| lc + (G::Base::from(2), self.y.get_variable()),
-      |lc| lc + (G::Base::from(3), x_sq.get_variable()) + (G::get_curve_params().0, CS::one()),
+      |lc| lc + (E::Base::from(2), self.y.get_variable()),
+      |lc| lc + (E::Base::from(3), x_sq.get_variable()) + (E::GE::group_params().0, CS::one()),
     );
 
     let x = AllocatedNum::alloc(cs.namespace(|| "x"), || {
@@ -757,7 +745,7 @@ where
       || "check that x is correct",
       |lc| lc + lambda.get_variable(),
       |lc| lc + lambda.get_variable(),
-      |lc| lc + x.get_variable() + (G::Base::from(2), self.x.get_variable()),
+      |lc| lc + x.get_variable() + (E::Base::from(2), self.x.get_variable()),
     );
 
     let y = AllocatedNum::alloc(cs.namespace(|| "y"), || {
@@ -778,7 +766,7 @@ where
   }
 
   /// If condition outputs a otherwise outputs b
-  pub fn conditionally_select<CS: ConstraintSystem<G::Base>>(
+  pub fn conditionally_select<CS: ConstraintSystem<E::Base>>(
     mut cs: CS,
     a: &Self,
     b: &Self,
@@ -794,15 +782,16 @@ where
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::provider::{
-    bn256_grumpkin::{bn256, grumpkin},
-    secp_secq::{secp256k1, secq256k1},
-  };
   use crate::{
     bellpepper::{
       r1cs::{NovaShape, NovaWitness},
       {solver::SatisfyingAssignment, test_shape_cs::TestShapeCS},
     },
+    provider::{
+      bn256_grumpkin::{bn256, grumpkin, Bn256Engine, GrumpkinEngine},
+      pasta::{PallasEngine, VestaEngine},
+      secp_secq::{secp256k1, secq256k1, Secp256k1Engine, Secq256k1Engine},
+    },
     traits::snark::default_ck_hint,
   };
   use ff::{Field, PrimeFieldBits};
@@ -810,27 +799,21 @@ mod tests {
   use rand::rngs::OsRng;
 
   #[derive(Debug, Clone)]
-  pub struct Point<G>
-  where
-    G: Group,
-  {
-    x: G::Base,
-    y: G::Base,
+  pub struct Point<E: Engine> {
+    x: E::Base,
+    y: E::Base,
     is_infinity: bool,
   }
 
-  impl<G> Point<G>
-  where
-    G: Group,
-  {
-    pub fn new(x: G::Base, y: G::Base, is_infinity: bool) -> Self {
+  impl<E: Engine> Point<E> {
+    pub fn new(x: E::Base, y: E::Base, is_infinity: bool) -> Self {
       Self { x, y, is_infinity }
     }
 
     pub fn random_vartime() -> Self {
       loop {
-        let x = G::Base::random(&mut OsRng);
-        let y = (x.square() * x + G::get_curve_params().1).sqrt();
+        let x = E::Base::random(&mut OsRng);
+        let y = (x.square() * x + E::GE::group_params().1).sqrt();
         if y.is_some().unwrap_u8() == 1 {
           return Self {
             x,
@@ -842,7 +825,7 @@ mod tests {
     }
 
     /// Add any two points
-    pub fn add(&self, other: &Point<G>) -> Self {
+    pub fn add(&self, other: &Point<E>) -> Self {
       if self.x == other.x {
         // If self == other then call double
         if self.y == other.y {
@@ -850,8 +833,8 @@ mod tests {
         } else {
           // if self.x == other.x and self.y != other.y then return infinity
           Self {
-            x: G::Base::ZERO,
-            y: G::Base::ZERO,
+            x: E::Base::ZERO,
+            y: E::Base::ZERO,
             is_infinity: true,
           }
         }
@@ -861,7 +844,7 @@ mod tests {
     }
 
     /// Add two different points
-    pub fn add_internal(&self, other: &Point<G>) -> Self {
+    pub fn add_internal(&self, other: &Point<E>) -> Self {
       if self.is_infinity {
         return other.clone();
       }
@@ -883,16 +866,16 @@ mod tests {
     pub fn double(&self) -> Self {
       if self.is_infinity {
         return Self {
-          x: G::Base::ZERO,
-          y: G::Base::ZERO,
+          x: E::Base::ZERO,
+          y: E::Base::ZERO,
           is_infinity: true,
         };
       }
 
-      let lambda = G::Base::from(3)
+      let lambda = E::Base::from(3)
         * self.x
         * self.x
-        * ((G::Base::ONE + G::Base::ONE) * self.y).invert().unwrap();
+        * ((E::Base::ONE + E::Base::ONE) * self.y).invert().unwrap();
       let x = lambda * lambda - self.x - self.x;
       let y = lambda * (self.x - x) - self.y;
       Self {
@@ -902,10 +885,10 @@ mod tests {
       }
     }
 
-    pub fn scalar_mul(&self, scalar: &G::Scalar) -> Self {
+    pub fn scalar_mul(&self, scalar: &E::Scalar) -> Self {
       let mut res = Self {
-        x: G::Base::ZERO,
-        y: G::Base::ZERO,
+        x: E::Base::ZERO,
+        y: E::Base::ZERO,
         is_infinity: true,
       };
 
@@ -921,17 +904,17 @@ mod tests {
   }
 
   // Allocate a random point. Only used for testing
-  pub fn alloc_random_point<G: Group, CS: ConstraintSystem<G::Base>>(
+  pub fn alloc_random_point<E: Engine, CS: ConstraintSystem<E::Base>>(
     mut cs: CS,
-  ) -> Result<AllocatedPoint<G>, SynthesisError> {
+  ) -> Result<AllocatedPoint<E>, SynthesisError> {
     // get a random point
-    let p = Point::<G>::random_vartime();
+    let p = Point::<E>::random_vartime();
     AllocatedPoint::alloc(cs.namespace(|| "alloc p"), Some((p.x, p.y, p.is_infinity)))
   }
 
   /// Make the point io
-  pub fn inputize_allocted_point<G: Group, CS: ConstraintSystem<G::Base>>(
-    p: &AllocatedPoint<G>,
+  pub fn inputize_allocted_point<E: Engine, CS: ConstraintSystem<E::Base>>(
+    p: &AllocatedPoint<E>,
     mut cs: CS,
   ) {
     let _ = p.x.inputize(cs.namespace(|| "Input point.x"));
@@ -943,27 +926,27 @@ mod tests {
 
   #[test]
   fn test_ecc_ops() {
-    test_ecc_ops_with::<pallas::Affine, pallas::Point>();
-    test_ecc_ops_with::<vesta::Affine, vesta::Point>();
+    test_ecc_ops_with::<pallas::Affine, PallasEngine>();
+    test_ecc_ops_with::<vesta::Affine, VestaEngine>();
 
-    test_ecc_ops_with::<bn256::Affine, bn256::Point>();
-    test_ecc_ops_with::<grumpkin::Affine, grumpkin::Point>();
+    test_ecc_ops_with::<bn256::Affine, Bn256Engine>();
+    test_ecc_ops_with::<grumpkin::Affine, GrumpkinEngine>();
 
-    test_ecc_ops_with::<secp256k1::Affine, secp256k1::Point>();
-    test_ecc_ops_with::<secq256k1::Affine, secq256k1::Point>();
+    test_ecc_ops_with::<secp256k1::Affine, Secp256k1Engine>();
+    test_ecc_ops_with::<secq256k1::Affine, Secq256k1Engine>();
   }
 
-  fn test_ecc_ops_with<C, G>()
+  fn test_ecc_ops_with<C, E>()
   where
-    C: CurveAffine<Base = G::Base, ScalarExt = G::Scalar>,
-    G: Group,
+    E: Engine,
+    C: CurveAffine<Base = E::Base, ScalarExt = E::Scalar>,
   {
     // perform some curve arithmetic
-    let a = Point::<G>::random_vartime();
-    let b = Point::<G>::random_vartime();
+    let a = Point::<E>::random_vartime();
+    let b = Point::<E>::random_vartime();
     let c = a.add(&b);
     let d = a.double();
-    let s = <G as Group>::Scalar::random(&mut OsRng);
+    let s = <E as Engine>::Scalar::random(&mut OsRng);
     let e = a.scalar_mul(&s);
 
     // perform the same computation by translating to curve types
@@ -1006,15 +989,15 @@ mod tests {
     assert_eq!(e_curve, e_curve_2);
   }
 
-  fn synthesize_smul<G, CS>(mut cs: CS) -> (AllocatedPoint<G>, AllocatedPoint<G>, G::Scalar)
+  fn synthesize_smul<E, CS>(mut cs: CS) -> (AllocatedPoint<E>, AllocatedPoint<E>, E::Scalar)
   where
-    G: Group,
-    CS: ConstraintSystem<G::Base>,
+    E: Engine,
+    CS: ConstraintSystem<E::Base>,
   {
     let a = alloc_random_point(cs.namespace(|| "a")).unwrap();
     inputize_allocted_point(&a, cs.namespace(|| "inputize a"));
 
-    let s = G::Scalar::random(&mut OsRng);
+    let s = E::Scalar::random(&mut OsRng);
     // Allocate bits for s
     let bits: Vec<AllocatedBit> = s
       .to_le_bits()
@@ -1030,41 +1013,41 @@ mod tests {
 
   #[test]
   fn test_ecc_circuit_ops() {
-    test_ecc_circuit_ops_with::<pallas::Point, vesta::Point>();
-    test_ecc_circuit_ops_with::<vesta::Point, pallas::Point>();
+    test_ecc_circuit_ops_with::<PallasEngine, VestaEngine>();
+    test_ecc_circuit_ops_with::<VestaEngine, PallasEngine>();
 
-    test_ecc_circuit_ops_with::<bn256::Point, grumpkin::Point>();
-    test_ecc_circuit_ops_with::<grumpkin::Point, bn256::Point>();
+    test_ecc_circuit_ops_with::<Bn256Engine, GrumpkinEngine>();
+    test_ecc_circuit_ops_with::<GrumpkinEngine, Bn256Engine>();
 
-    test_ecc_circuit_ops_with::<secp256k1::Point, secq256k1::Point>();
-    test_ecc_circuit_ops_with::<secq256k1::Point, secp256k1::Point>();
+    test_ecc_circuit_ops_with::<Secp256k1Engine, Secq256k1Engine>();
+    test_ecc_circuit_ops_with::<Secq256k1Engine, Secp256k1Engine>();
   }
 
-  fn test_ecc_circuit_ops_with<G1, G2>()
+  fn test_ecc_circuit_ops_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
     // First create the shape
-    let mut cs: TestShapeCS<G2> = TestShapeCS::new();
-    let _ = synthesize_smul::<G1, _>(cs.namespace(|| "synthesize"));
+    let mut cs: TestShapeCS<E2> = TestShapeCS::new();
+    let _ = synthesize_smul::<E1, _>(cs.namespace(|| "synthesize"));
     println!("Number of constraints: {}", cs.num_constraints());
     let (shape, ck) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     // Then the satisfying assignment
-    let mut cs = SatisfyingAssignment::<G2>::new();
-    let (a, e, s) = synthesize_smul::<G1, _>(cs.namespace(|| "synthesize"));
+    let mut cs = SatisfyingAssignment::<E2>::new();
+    let (a, e, s) = synthesize_smul::<E1, _>(cs.namespace(|| "synthesize"));
     let (inst, witness) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
 
-    let a_p: Point<G1> = Point::new(
+    let a_p: Point<E1> = Point::new(
       a.x.get_value().unwrap(),
       a.y.get_value().unwrap(),
-      a.is_infinity.get_value().unwrap() == <G1 as Group>::Base::ONE,
+      a.is_infinity.get_value().unwrap() == <E1 as Engine>::Base::ONE,
     );
-    let e_p: Point<G1> = Point::new(
+    let e_p: Point<E1> = Point::new(
       e.x.get_value().unwrap(),
       e.y.get_value().unwrap(),
-      e.is_infinity.get_value().unwrap() == <G1 as Group>::Base::ONE,
+      e.is_infinity.get_value().unwrap() == <E1 as Engine>::Base::ONE,
     );
     let e_new = a_p.scalar_mul(&s);
     assert!(e_p.x == e_new.x && e_p.y == e_new.y);
@@ -1072,10 +1055,10 @@ mod tests {
     assert!(shape.is_sat(&ck, &inst, &witness).is_ok());
   }
 
-  fn synthesize_add_equal<G, CS>(mut cs: CS) -> (AllocatedPoint<G>, AllocatedPoint<G>)
+  fn synthesize_add_equal<E, CS>(mut cs: CS) -> (AllocatedPoint<E>, AllocatedPoint<E>)
   where
-    G: Group,
-    CS: ConstraintSystem<G::Base>,
+    E: Engine,
+    CS: ConstraintSystem<E::Base>,
   {
     let a = alloc_random_point(cs.namespace(|| "a")).unwrap();
     inputize_allocted_point(&a, cs.namespace(|| "inputize a"));
@@ -1086,40 +1069,40 @@ mod tests {
 
   #[test]
   fn test_ecc_circuit_add_equal() {
-    test_ecc_circuit_add_equal_with::<pallas::Point, vesta::Point>();
-    test_ecc_circuit_add_equal_with::<vesta::Point, pallas::Point>();
+    test_ecc_circuit_add_equal_with::<PallasEngine, VestaEngine>();
+    test_ecc_circuit_add_equal_with::<VestaEngine, PallasEngine>();
 
-    test_ecc_circuit_add_equal_with::<bn256::Point, grumpkin::Point>();
-    test_ecc_circuit_add_equal_with::<grumpkin::Point, bn256::Point>();
+    test_ecc_circuit_add_equal_with::<Bn256Engine, GrumpkinEngine>();
+    test_ecc_circuit_add_equal_with::<GrumpkinEngine, Bn256Engine>();
 
-    test_ecc_circuit_add_equal_with::<secp256k1::Point, secq256k1::Point>();
-    test_ecc_circuit_add_equal_with::<secq256k1::Point, secp256k1::Point>();
+    test_ecc_circuit_add_equal_with::<Secp256k1Engine, Secq256k1Engine>();
+    test_ecc_circuit_add_equal_with::<Secq256k1Engine, Secp256k1Engine>();
   }
 
-  fn test_ecc_circuit_add_equal_with<G1, G2>()
+  fn test_ecc_circuit_add_equal_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
     // First create the shape
-    let mut cs: TestShapeCS<G2> = TestShapeCS::new();
-    let _ = synthesize_add_equal::<G1, _>(cs.namespace(|| "synthesize add equal"));
+    let mut cs: TestShapeCS<E2> = TestShapeCS::new();
+    let _ = synthesize_add_equal::<E1, _>(cs.namespace(|| "synthesize add equal"));
     println!("Number of constraints: {}", cs.num_constraints());
     let (shape, ck) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     // Then the satisfying assignment
-    let mut cs = SatisfyingAssignment::<G2>::new();
-    let (a, e) = synthesize_add_equal::<G1, _>(cs.namespace(|| "synthesize add equal"));
+    let mut cs = SatisfyingAssignment::<E2>::new();
+    let (a, e) = synthesize_add_equal::<E1, _>(cs.namespace(|| "synthesize add equal"));
     let (inst, witness) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
-    let a_p: Point<G1> = Point::new(
+    let a_p: Point<E1> = Point::new(
       a.x.get_value().unwrap(),
       a.y.get_value().unwrap(),
-      a.is_infinity.get_value().unwrap() == <G1 as Group>::Base::ONE,
+      a.is_infinity.get_value().unwrap() == <E1 as Engine>::Base::ONE,
     );
-    let e_p: Point<G1> = Point::new(
+    let e_p: Point<E1> = Point::new(
       e.x.get_value().unwrap(),
       e.y.get_value().unwrap(),
-      e.is_infinity.get_value().unwrap() == <G1 as Group>::Base::ONE,
+      e.is_infinity.get_value().unwrap() == <E1 as Engine>::Base::ONE,
     );
     let e_new = a_p.add(&a_p);
     assert!(e_p.x == e_new.x && e_p.y == e_new.y);
@@ -1127,16 +1110,16 @@ mod tests {
     assert!(shape.is_sat(&ck, &inst, &witness).is_ok());
   }
 
-  fn synthesize_add_negation<G, CS>(mut cs: CS) -> AllocatedPoint<G>
+  fn synthesize_add_negation<E, CS>(mut cs: CS) -> AllocatedPoint<E>
   where
-    G: Group,
-    CS: ConstraintSystem<G::Base>,
+    E: Engine,
+    CS: ConstraintSystem<E::Base>,
   {
     let a = alloc_random_point(cs.namespace(|| "a")).unwrap();
     inputize_allocted_point(&a, cs.namespace(|| "inputize a"));
     let b = &mut a.clone();
     b.y = AllocatedNum::alloc(cs.namespace(|| "allocate negation of a"), || {
-      Ok(G::Base::ZERO)
+      Ok(E::Base::ZERO)
     })
     .unwrap();
     inputize_allocted_point(b, cs.namespace(|| "inputize b"));
@@ -1146,35 +1129,35 @@ mod tests {
 
   #[test]
   fn test_ecc_circuit_add_negation() {
-    test_ecc_circuit_add_negation_with::<pallas::Point, vesta::Point>();
-    test_ecc_circuit_add_negation_with::<vesta::Point, pallas::Point>();
+    test_ecc_circuit_add_negation_with::<PallasEngine, VestaEngine>();
+    test_ecc_circuit_add_negation_with::<VestaEngine, PallasEngine>();
 
-    test_ecc_circuit_add_negation_with::<bn256::Point, grumpkin::Point>();
-    test_ecc_circuit_add_negation_with::<grumpkin::Point, bn256::Point>();
+    test_ecc_circuit_add_negation_with::<Bn256Engine, GrumpkinEngine>();
+    test_ecc_circuit_add_negation_with::<GrumpkinEngine, Bn256Engine>();
 
-    test_ecc_circuit_add_negation_with::<secp256k1::Point, secq256k1::Point>();
-    test_ecc_circuit_add_negation_with::<secq256k1::Point, secp256k1::Point>();
+    test_ecc_circuit_add_negation_with::<Secp256k1Engine, Secq256k1Engine>();
+    test_ecc_circuit_add_negation_with::<Secq256k1Engine, Secp256k1Engine>();
   }
 
-  fn test_ecc_circuit_add_negation_with<G1, G2>()
+  fn test_ecc_circuit_add_negation_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
     // First create the shape
-    let mut cs: TestShapeCS<G2> = TestShapeCS::new();
-    let _ = synthesize_add_negation::<G1, _>(cs.namespace(|| "synthesize add equal"));
+    let mut cs: TestShapeCS<E2> = TestShapeCS::new();
+    let _ = synthesize_add_negation::<E1, _>(cs.namespace(|| "synthesize add equal"));
     println!("Number of constraints: {}", cs.num_constraints());
     let (shape, ck) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     // Then the satisfying assignment
-    let mut cs = SatisfyingAssignment::<G2>::new();
-    let e = synthesize_add_negation::<G1, _>(cs.namespace(|| "synthesize add negation"));
+    let mut cs = SatisfyingAssignment::<E2>::new();
+    let e = synthesize_add_negation::<E1, _>(cs.namespace(|| "synthesize add negation"));
     let (inst, witness) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
-    let e_p: Point<G1> = Point::new(
+    let e_p: Point<E1> = Point::new(
       e.x.get_value().unwrap(),
       e.y.get_value().unwrap(),
-      e.is_infinity.get_value().unwrap() == <G1 as Group>::Base::ONE,
+      e.is_infinity.get_value().unwrap() == <E1 as Engine>::Base::ONE,
     );
     assert!(e_p.is_infinity);
     // Make sure that it is satisfiable
diff --git a/src/gadgets/nonnative/util.rs b/src/gadgets/nonnative/util.rs
index 4e7860f1b..f26c09f6a 100644
--- a/src/gadgets/nonnative/util.rs
+++ b/src/gadgets/nonnative/util.rs
@@ -32,10 +32,10 @@ pub struct Bitvector<Scalar: PrimeField> {
 impl<Scalar: PrimeField> Bit<Scalar> {
   /// Allocate a variable in the constraint system which can only be a
   /// boolean value.
-  pub fn alloc<CS>(mut cs: CS, value: Option<bool>) -> Result<Self, SynthesisError>
-  where
-    CS: ConstraintSystem<Scalar>,
-  {
+  pub fn alloc<CS: ConstraintSystem<Scalar>>(
+    mut cs: CS,
+    value: Option<bool>,
+  ) -> Result<Self, SynthesisError> {
     let var = cs.alloc(
       || "boolean",
       || {
diff --git a/src/gadgets/r1cs.rs b/src/gadgets/r1cs.rs
index ebf8d7f0c..9122578a2 100644
--- a/src/gadgets/r1cs.rs
+++ b/src/gadgets/r1cs.rs
@@ -13,7 +13,7 @@ use crate::{
     },
   },
   r1cs::{R1CSInstance, RelaxedR1CSInstance},
-  traits::{commitment::CommitmentTrait, Group, ROCircuitTrait, ROConstantsCircuit},
+  traits::{commitment::CommitmentTrait, Engine, Group, ROCircuitTrait, ROConstantsCircuit},
 };
 use bellpepper::gadgets::{boolean::Boolean, num::AllocatedNum, Assignment};
 use bellpepper_core::{ConstraintSystem, SynthesisError};
@@ -21,17 +21,17 @@ use ff::Field;
 
 /// An Allocated R1CS Instance
 #[derive(Clone)]
-pub struct AllocatedR1CSInstance<G: Group> {
-  pub(crate) W: AllocatedPoint<G>,
-  pub(crate) X0: AllocatedNum<G::Base>,
-  pub(crate) X1: AllocatedNum<G::Base>,
+pub struct AllocatedR1CSInstance<E: Engine> {
+  pub(crate) W: AllocatedPoint<E>,
+  pub(crate) X0: AllocatedNum<E::Base>,
+  pub(crate) X1: AllocatedNum<E::Base>,
 }
 
-impl<G: Group> AllocatedR1CSInstance<G> {
+impl<E: Engine> AllocatedR1CSInstance<E> {
   /// Takes the r1cs instance and creates a new allocated r1cs instance
-  pub fn alloc<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn alloc<CS: ConstraintSystem<<E as Engine>::Base>>(
     mut cs: CS,
-    u: Option<&R1CSInstance<G>>,
+    u: Option<&R1CSInstance<E>>,
   ) -> Result<Self, SynthesisError> {
     let W = AllocatedPoint::alloc(
       cs.namespace(|| "allocate W"),
@@ -39,14 +39,14 @@ impl<G: Group> AllocatedR1CSInstance<G> {
     )?;
     W.check_on_curve(cs.namespace(|| "check W on curve"))?;
 
-    let X0 = alloc_scalar_as_base::<G, _>(cs.namespace(|| "allocate X[0]"), u.map(|u| u.X[0]))?;
-    let X1 = alloc_scalar_as_base::<G, _>(cs.namespace(|| "allocate X[1]"), u.map(|u| u.X[1]))?;
+    let X0 = alloc_scalar_as_base::<E, _>(cs.namespace(|| "allocate X[0]"), u.map(|u| u.X[0]))?;
+    let X1 = alloc_scalar_as_base::<E, _>(cs.namespace(|| "allocate X[1]"), u.map(|u| u.X[1]))?;
 
     Ok(AllocatedR1CSInstance { W, X0, X1 })
   }
 
   /// Absorb the provided instance in the RO
-  pub fn absorb_in_ro(&self, ro: &mut G::ROCircuit) {
+  pub fn absorb_in_ro(&self, ro: &mut E::ROCircuit) {
     ro.absorb(&self.W.x);
     ro.absorb(&self.W.y);
     ro.absorb(&self.W.is_infinity);
@@ -57,19 +57,19 @@ impl<G: Group> AllocatedR1CSInstance<G> {
 
 /// An Allocated Relaxed R1CS Instance
 #[derive(Clone)]
-pub struct AllocatedRelaxedR1CSInstance<G: Group> {
-  pub(crate) W: AllocatedPoint<G>,
-  pub(crate) E: AllocatedPoint<G>,
-  pub(crate) u: AllocatedNum<G::Base>,
-  pub(crate) X0: BigNat<G::Base>,
-  pub(crate) X1: BigNat<G::Base>,
+pub struct AllocatedRelaxedR1CSInstance<E: Engine> {
+  pub(crate) W: AllocatedPoint<E>,
+  pub(crate) E: AllocatedPoint<E>,
+  pub(crate) u: AllocatedNum<E::Base>,
+  pub(crate) X0: BigNat<E::Base>,
+  pub(crate) X1: BigNat<E::Base>,
 }
 
-impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
+impl<E: Engine> AllocatedRelaxedR1CSInstance<E> {
   /// Allocates the given `RelaxedR1CSInstance` as a witness of the circuit
-  pub fn alloc<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn alloc<CS: ConstraintSystem<<E as Engine>::Base>>(
     mut cs: CS,
-    inst: Option<&RelaxedR1CSInstance<G>>,
+    inst: Option<&RelaxedR1CSInstance<E>>,
     limb_width: usize,
     n_limbs: usize,
   ) -> Result<Self, SynthesisError> {
@@ -86,21 +86,21 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
       inst.map(|inst| inst.comm_E.to_coordinates()),
     )?;
 
-    // u << |G::Base| despite the fact that u is a scalar.
-    // So we parse all of its bytes as a G::Base element
-    let u = alloc_scalar_as_base::<G, _>(cs.namespace(|| "allocate u"), inst.map(|inst| inst.u))?;
+    // u << |E::Base| despite the fact that u is a scalar.
+    // So we parse all of its bytes as a E::Base element
+    let u = alloc_scalar_as_base::<E, _>(cs.namespace(|| "allocate u"), inst.map(|inst| inst.u))?;
 
     // Allocate X0 and X1. If the input instance is None, then allocate default values 0.
     let X0 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate X[0]"),
-      || Ok(f_to_nat(&inst.map_or(G::Scalar::ZERO, |inst| inst.X[0]))),
+      || Ok(f_to_nat(&inst.map_or(E::Scalar::ZERO, |inst| inst.X[0]))),
       limb_width,
       n_limbs,
     )?;
 
     let X1 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate X[1]"),
-      || Ok(f_to_nat(&inst.map_or(G::Scalar::ZERO, |inst| inst.X[1]))),
+      || Ok(f_to_nat(&inst.map_or(E::Scalar::ZERO, |inst| inst.X[1]))),
       limb_width,
       n_limbs,
     )?;
@@ -110,7 +110,7 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
 
   /// Allocates the hardcoded default `RelaxedR1CSInstance` in the circuit.
   /// W = E = 0, u = 0, X0 = X1 = 0
-  pub fn default<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn default<CS: ConstraintSystem<<E as Engine>::Base>>(
     mut cs: CS,
     limb_width: usize,
     n_limbs: usize,
@@ -125,14 +125,14 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
     // relaxed R1CS instance with the the checked default values of W, E, and u must still be satisfying
     let X0 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate x_default[0]"),
-      || Ok(f_to_nat(&G::Scalar::ZERO)),
+      || Ok(f_to_nat(&E::Scalar::ZERO)),
       limb_width,
       n_limbs,
     )?;
 
     let X1 = BigNat::alloc_from_nat(
       cs.namespace(|| "allocate x_default[1]"),
-      || Ok(f_to_nat(&G::Scalar::ZERO)),
+      || Ok(f_to_nat(&E::Scalar::ZERO)),
       limb_width,
       n_limbs,
     )?;
@@ -142,9 +142,9 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
 
   /// Allocates the R1CS Instance as a `RelaxedR1CSInstance` in the circuit.
   /// E = 0, u = 1
-  pub fn from_r1cs_instance<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn from_r1cs_instance<CS: ConstraintSystem<<E as Engine>::Base>>(
     mut cs: CS,
-    inst: AllocatedR1CSInstance<G>,
+    inst: AllocatedR1CSInstance<E>,
     limb_width: usize,
     n_limbs: usize,
   ) -> Result<Self, SynthesisError> {
@@ -176,10 +176,10 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
   }
 
   /// Absorb the provided instance in the RO
-  pub fn absorb_in_ro<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn absorb_in_ro<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     mut cs: CS,
-    ro: &mut G::ROCircuit,
+    ro: &mut E::ROCircuit,
   ) -> Result<(), SynthesisError> {
     ro.absorb(&self.W.x);
     ro.absorb(&self.W.y);
@@ -198,7 +198,7 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
       .map(|(i, limb)| {
         limb.as_allocated_num(cs.namespace(|| format!("convert limb {i} of X_r[0] to num")))
       })
-      .collect::<Result<Vec<AllocatedNum<G::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     // absorb each of the limbs of X[0]
     for limb in X0_bn {
@@ -214,7 +214,7 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
       .map(|(i, limb)| {
         limb.as_allocated_num(cs.namespace(|| format!("convert limb {i} of X_r[1] to num")))
       })
-      .collect::<Result<Vec<AllocatedNum<G::Base>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Base>>, _>>()?;
 
     // absorb each of the limbs of X[1]
     for limb in X1_bn {
@@ -225,18 +225,18 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
   }
 
   /// Folds self with a relaxed r1cs instance and returns the result
-  pub fn fold_with_r1cs<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn fold_with_r1cs<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     mut cs: CS,
-    params: &AllocatedNum<G::Base>, // hash of R1CSShape of F'
-    u: &AllocatedR1CSInstance<G>,
-    T: &AllocatedPoint<G>,
-    ro_consts: ROConstantsCircuit<G>,
+    params: &AllocatedNum<E::Base>, // hash of R1CSShape of F'
+    u: &AllocatedR1CSInstance<E>,
+    T: &AllocatedPoint<E>,
+    ro_consts: ROConstantsCircuit<E>,
     limb_width: usize,
     n_limbs: usize,
-  ) -> Result<AllocatedRelaxedR1CSInstance<G>, SynthesisError> {
+  ) -> Result<AllocatedRelaxedR1CSInstance<E>, SynthesisError> {
     // Compute r:
-    let mut ro = G::ROCircuit::new(ro_consts, NUM_FE_FOR_RO);
+    let mut ro = E::ROCircuit::new(ro_consts, NUM_FE_FOR_RO);
     ro.absorb(params);
     self.absorb_in_ro(cs.namespace(|| "absorb running instance"), &mut ro)?;
     u.absorb_in_ro(&mut ro);
@@ -277,7 +277,7 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
     // Allocate the order of the non-native field as a constant
     let m_bn = alloc_bignat_constant(
       cs.namespace(|| "alloc m"),
-      &G::get_curve_params().2,
+      &E::GE::group_params().2,
       limb_width,
       n_limbs,
     )?;
@@ -322,26 +322,26 @@ impl<G: Group> AllocatedRelaxedR1CSInstance<G> {
   }
 
   /// If the condition is true then returns this otherwise it returns the other
-  pub fn conditionally_select<CS: ConstraintSystem<<G as Group>::Base>>(
+  pub fn conditionally_select<CS: ConstraintSystem<<E as Engine>::Base>>(
     &self,
     cs: CS,
-    other: &AllocatedRelaxedR1CSInstance<G>,
+    other: &AllocatedRelaxedR1CSInstance<E>,
     condition: &Boolean,
-  ) -> Result<AllocatedRelaxedR1CSInstance<G>, SynthesisError> {
+  ) -> Result<AllocatedRelaxedR1CSInstance<E>, SynthesisError> {
     conditionally_select_alloc_relaxed_r1cs(cs, self, other, condition)
   }
 }
 
 /// c = cond ? a: b, where a, b: `AllocatedRelaxedR1CSInstance`
 pub fn conditionally_select_alloc_relaxed_r1cs<
-  G: Group,
-  CS: ConstraintSystem<<G as Group>::Base>,
+  E: Engine,
+  CS: ConstraintSystem<<E as Engine>::Base>,
 >(
   mut cs: CS,
-  a: &AllocatedRelaxedR1CSInstance<G>,
-  b: &AllocatedRelaxedR1CSInstance<G>,
+  a: &AllocatedRelaxedR1CSInstance<E>,
+  b: &AllocatedRelaxedR1CSInstance<E>,
   condition: &Boolean,
-) -> Result<AllocatedRelaxedR1CSInstance<G>, SynthesisError> {
+) -> Result<AllocatedRelaxedR1CSInstance<E>, SynthesisError> {
   let c = AllocatedRelaxedR1CSInstance {
     W: conditionally_select_point(
       cs.namespace(|| "W = cond ? a.W : b.W"),
@@ -380,14 +380,14 @@ pub fn conditionally_select_alloc_relaxed_r1cs<
 #[allow(dead_code)]
 /// c = cond ? a: b, where a, b: `Vec<AllocatedRelaxedR1CSInstance>`
 pub fn conditionally_select_vec_allocated_relaxed_r1cs_instance<
-  G: Group,
-  CS: ConstraintSystem<<G as Group>::Base>,
+  E: Engine,
+  CS: ConstraintSystem<<E as Engine>::Base>,
 >(
   mut cs: CS,
-  a: &[AllocatedRelaxedR1CSInstance<G>],
-  b: &[AllocatedRelaxedR1CSInstance<G>],
+  a: &[AllocatedRelaxedR1CSInstance<E>],
+  b: &[AllocatedRelaxedR1CSInstance<E>],
   condition: &Boolean,
-) -> Result<Vec<AllocatedRelaxedR1CSInstance<G>>, SynthesisError> {
+) -> Result<Vec<AllocatedRelaxedR1CSInstance<E>>, SynthesisError> {
   a.iter()
     .enumerate()
     .zip(b.iter())
@@ -398,16 +398,16 @@ pub fn conditionally_select_vec_allocated_relaxed_r1cs_instance<
         condition,
       )
     })
-    .collect::<Result<Vec<AllocatedRelaxedR1CSInstance<G>>, _>>()
+    .collect::<Result<Vec<AllocatedRelaxedR1CSInstance<E>>, _>>()
 }
 
 /// c = cond ? a: b, where a, b: `AllocatedPoint`
-pub fn conditionally_select_point<G: Group, CS: ConstraintSystem<<G as Group>::Base>>(
+pub fn conditionally_select_point<E: Engine, CS: ConstraintSystem<<E as Engine>::Base>>(
   mut cs: CS,
-  a: &AllocatedPoint<G>,
-  b: &AllocatedPoint<G>,
+  a: &AllocatedPoint<E>,
+  b: &AllocatedPoint<E>,
   condition: &Boolean,
-) -> Result<AllocatedPoint<G>, SynthesisError> {
+) -> Result<AllocatedPoint<E>, SynthesisError> {
   let c = AllocatedPoint {
     x: conditionally_select(
       cs.namespace(|| "x = cond ? a.x : b.x"),
diff --git a/src/gadgets/utils.rs b/src/gadgets/utils.rs
index f8866118f..b8f242faf 100644
--- a/src/gadgets/utils.rs
+++ b/src/gadgets/utils.rs
@@ -1,6 +1,6 @@
 //! This module implements various low-level gadgets
 use super::nonnative::bignat::{nat_to_limbs, BigNat};
-use crate::traits::Group;
+use crate::traits::Engine;
 use bellpepper::gadgets::Assignment;
 use bellpepper_core::{
   boolean::{AllocatedBit, Boolean},
@@ -68,20 +68,20 @@ pub fn alloc_one<F: PrimeField, CS: ConstraintSystem<F>>(mut cs: CS) -> Allocate
   one
 }
 
-/// Allocate a scalar as a base. Only to be used if the scalar fits in base!
-pub fn alloc_scalar_as_base<G, CS>(
+/// Allocate a scalar as a base. Only to be used is the scalar fits in base!
+pub fn alloc_scalar_as_base<E, CS>(
   mut cs: CS,
-  input: Option<G::Scalar>,
-) -> Result<AllocatedNum<G::Base>, SynthesisError>
+  input: Option<E::Scalar>,
+) -> Result<AllocatedNum<E::Base>, SynthesisError>
 where
-  G: Group,
-  <G as Group>::Scalar: PrimeFieldBits,
-  CS: ConstraintSystem<<G as Group>::Base>,
+  E: Engine,
+  <E as Engine>::Scalar: PrimeFieldBits,
+  CS: ConstraintSystem<<E as Engine>::Base>,
 {
   AllocatedNum::alloc(cs.namespace(|| "allocate scalar as base"), || {
-    let input_bits = input.unwrap_or(G::Scalar::ZERO).clone().to_le_bits();
-    let mut mult = G::Base::ONE;
-    let mut val = G::Base::ZERO;
+    let input_bits = input.unwrap_or(E::Scalar::ZERO).clone().to_le_bits();
+    let mut mult = E::Base::ONE;
+    let mut val = E::Base::ZERO;
     for bit in input_bits {
       if bit {
         val += mult;
@@ -93,10 +93,10 @@ where
 }
 
 /// interepret scalar as base
-pub fn scalar_as_base<G: Group>(input: G::Scalar) -> G::Base {
+pub fn scalar_as_base<E: Engine>(input: E::Scalar) -> E::Base {
   let input_bits = input.to_le_bits();
-  let mut mult = G::Base::ONE;
-  let mut val = G::Base::ZERO;
+  let mut mult = E::Base::ONE;
+  let mut val = E::Base::ZERO;
   for bit in input_bits {
     if bit {
       val += mult;
diff --git a/src/lib.rs b/src/lib.rs
index 62af3ee97..f4b0d1cae 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -53,23 +53,23 @@ use traits::{
   circuit::StepCircuit,
   commitment::{CommitmentEngineTrait, CommitmentTrait},
   snark::RelaxedR1CSSNARKTrait,
-  AbsorbInROTrait, Group, ROConstants, ROConstantsCircuit, ROTrait,
+  AbsorbInROTrait, Engine, ROConstants, ROConstantsCircuit, ROTrait,
 };
 
 /// A type that holds parameters for the primary and secondary circuits of Nova and SuperNova
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as PrimeField>::Repr: Abomonation)]
-pub struct CircuitShape<G: Group> {
+#[abomonation_bounds(where <E::Scalar as PrimeField>::Repr: Abomonation)]
+pub struct CircuitShape<E: Engine> {
   F_arity: usize,
-  r1cs_shape: R1CSShape<G>,
+  r1cs_shape: R1CSShape<E>,
 }
 
-impl<G: Group> SimpleDigestible for CircuitShape<G> {}
+impl<E: Engine> SimpleDigestible for CircuitShape<E> {}
 
-impl<G: Group> CircuitShape<G> {
+impl<E: Engine> CircuitShape<E> {
   /// Create a new `CircuitShape`
-  pub fn new(r1cs_shape: R1CSShape<G>, F_arity: usize) -> Self {
+  pub fn new(r1cs_shape: R1CSShape<E>, F_arity: usize) -> Self {
     Self {
       F_arity,
       r1cs_shape,
@@ -77,8 +77,8 @@ impl<G: Group> CircuitShape<G> {
   }
 
   /// Return the [CircuitShape]' digest.
-  pub fn digest(&self) -> G::Scalar {
-    let dc: DigestComputer<'_, <G as Group>::Scalar, CircuitShape<G>> = DigestComputer::new(self);
+  pub fn digest(&self) -> E::Scalar {
+    let dc: DigestComputer<'_, <E as Engine>::Scalar, CircuitShape<E>> = DigestComputer::new(self);
     dc.digest().expect("Failure in computing digest")
   }
 }
@@ -88,53 +88,53 @@ impl<G: Group> CircuitShape<G> {
 #[serde(bound = "")]
 #[abomonation_bounds(
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  <G1::Scalar as PrimeField>::Repr: Abomonation,
-  <G2::Scalar as PrimeField>::Repr: Abomonation,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
+  <E1::Scalar as PrimeField>::Repr: Abomonation,
+  <E2::Scalar as PrimeField>::Repr: Abomonation,
 )]
-pub struct PublicParams<G1, G2, C1, C2>
+pub struct PublicParams<E1, E2, C1, C2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
 {
   F_arity_primary: usize,
   F_arity_secondary: usize,
-  ro_consts_primary: ROConstants<G1>,
-  ro_consts_circuit_primary: ROConstantsCircuit<G2>,
-  ck_primary: CommitmentKey<G1>,
-  circuit_shape_primary: CircuitShape<G1>,
-  ro_consts_secondary: ROConstants<G2>,
-  ro_consts_circuit_secondary: ROConstantsCircuit<G1>,
-  ck_secondary: CommitmentKey<G2>,
-  circuit_shape_secondary: CircuitShape<G2>,
+  ro_consts_primary: ROConstants<E1>,
+  ro_consts_circuit_primary: ROConstantsCircuit<E2>,
+  ck_primary: CommitmentKey<E1>,
+  circuit_shape_primary: CircuitShape<E1>,
+  ro_consts_secondary: ROConstants<E2>,
+  ro_consts_circuit_secondary: ROConstantsCircuit<E1>,
+  ck_secondary: CommitmentKey<E2>,
+  circuit_shape_secondary: CircuitShape<E2>,
   augmented_circuit_params_primary: NovaAugmentedCircuitParams,
   augmented_circuit_params_secondary: NovaAugmentedCircuitParams,
   #[abomonation_skip]
   #[serde(skip, default = "OnceCell::new")]
-  digest: OnceCell<G1::Scalar>,
+  digest: OnceCell<E1::Scalar>,
   _p: PhantomData<(C1, C2)>,
 }
 
-impl<G1, G2, C1, C2> SimpleDigestible for PublicParams<G1, G2, C1, C2>
+impl<E1, E2, C1, C2> SimpleDigestible for PublicParams<E1, E2, C1, C2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
 {
 }
 
-impl<G1, G2, C1, C2> PublicParams<G1, G2, C1, C2>
+impl<E1, E2, C1, C2> PublicParams<E1, E2, C1, C2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
 {
   /// Set up builder to create `PublicParams` for a pair of circuits `C1` and `C2`.
   ///
@@ -159,67 +159,67 @@ where
   /// # Example
   ///
   /// ```rust
-  /// # use pasta_curves::{vesta, pallas};
   /// # use nova_snark::spartan::ppsnark::RelaxedR1CSSNARK;
   /// # use nova_snark::provider::ipa_pc::EvaluationEngine;
-  /// # use nova_snark::traits::{circuit::TrivialCircuit, Group, snark::RelaxedR1CSSNARKTrait};
+  /// # use nova_snark::provider::pasta::{PallasEngine, VestaEngine};
+  /// # use nova_snark::traits::{circuit::TrivialCircuit, Engine, snark::RelaxedR1CSSNARKTrait};
   /// use nova_snark::PublicParams;
   ///
-  /// type G1 = pallas::Point;
-  /// type G2 = vesta::Point;
-  /// type EE<G> = EvaluationEngine<G>;
-  /// type SPrime<G> = RelaxedR1CSSNARK<G, EE<G>>;
+  /// type E1 = PallasEngine;
+  /// type E2 = VestaEngine;
+  /// type EE<E> = EvaluationEngine<E>;
+  /// type SPrime<E> = RelaxedR1CSSNARK<E, EE<E>>;
   ///
-  /// let circuit1 = TrivialCircuit::<<G1 as Group>::Scalar>::default();
-  /// let circuit2 = TrivialCircuit::<<G2 as Group>::Scalar>::default();
+  /// let circuit1 = TrivialCircuit::<<E1 as Engine>::Scalar>::default();
+  /// let circuit2 = TrivialCircuit::<<E2 as Engine>::Scalar>::default();
   /// // Only relevant for a SNARK using computational commitments, pass &(|_| 0)
   /// // or &*nova_snark::traits::snark::default_ck_hint() otherwise.
-  /// let ck_hint1 = &*SPrime::<G1>::ck_floor();
-  /// let ck_hint2 = &*SPrime::<G2>::ck_floor();
+  /// let ck_hint1 = &*SPrime::<E1>::ck_floor();
+  /// let ck_hint2 = &*SPrime::<E2>::ck_floor();
   ///
   /// let pp = PublicParams::setup(&circuit1, &circuit2, ck_hint1, ck_hint2);
   /// ```
   pub fn setup(
     c_primary: &C1,
     c_secondary: &C2,
-    ck_hint1: &CommitmentKeyHint<G1>,
-    ck_hint2: &CommitmentKeyHint<G2>,
+    ck_hint1: &CommitmentKeyHint<E1>,
+    ck_hint2: &CommitmentKeyHint<E2>,
   ) -> Self {
     let augmented_circuit_params_primary =
       NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
     let augmented_circuit_params_secondary =
       NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
 
-    let ro_consts_primary: ROConstants<G1> = ROConstants::<G1>::default();
-    let ro_consts_secondary: ROConstants<G2> = ROConstants::<G2>::default();
+    let ro_consts_primary: ROConstants<E1> = ROConstants::<E1>::default();
+    let ro_consts_secondary: ROConstants<E2> = ROConstants::<E2>::default();
 
     let F_arity_primary = c_primary.arity();
     let F_arity_secondary = c_secondary.arity();
 
-    // ro_consts_circuit_primary are parameterized by G2 because the type alias uses G2::Base = G1::Scalar
-    let ro_consts_circuit_primary: ROConstantsCircuit<G2> = ROConstantsCircuit::<G2>::default();
-    let ro_consts_circuit_secondary: ROConstantsCircuit<G1> = ROConstantsCircuit::<G1>::default();
+    // ro_consts_circuit_primary are parameterized by E2 because the type alias uses E2::Base = E1::Scalar
+    let ro_consts_circuit_primary: ROConstantsCircuit<E2> = ROConstantsCircuit::<E2>::default();
+    let ro_consts_circuit_secondary: ROConstantsCircuit<E1> = ROConstantsCircuit::<E1>::default();
 
     // Initialize ck for the primary
-    let circuit_primary: NovaAugmentedCircuit<'_, G2, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, E2, C1> = NovaAugmentedCircuit::new(
       &augmented_circuit_params_primary,
       None,
       c_primary,
       ro_consts_circuit_primary.clone(),
     );
-    let mut cs: ShapeCS<G1> = ShapeCS::new();
+    let mut cs: ShapeCS<E1> = 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 = CircuitShape::new(r1cs_shape_primary, F_arity_primary);
 
     // Initialize ck for the secondary
-    let circuit_secondary: NovaAugmentedCircuit<'_, G1, C2> = NovaAugmentedCircuit::new(
+    let circuit_secondary: NovaAugmentedCircuit<'_, E1, C2> = NovaAugmentedCircuit::new(
       &augmented_circuit_params_secondary,
       None,
       c_secondary,
       ro_consts_circuit_secondary.clone(),
     );
-    let mut cs: ShapeCS<G2> = ShapeCS::new();
+    let mut cs: ShapeCS<E2> = ShapeCS::new();
     let _ = circuit_secondary.synthesize(&mut cs);
     let (r1cs_shape_secondary, ck_secondary) = cs.r1cs_shape_and_key(ck_hint2);
     let circuit_shape_secondary = CircuitShape::new(r1cs_shape_secondary, F_arity_secondary);
@@ -243,7 +243,7 @@ where
   }
 
   /// Retrieve the digest of the public parameters.
-  pub fn digest(&self) -> G1::Scalar {
+  pub fn digest(&self) -> E1::Scalar {
     self
       .digest
       .get_or_try_init(|| DigestComputer::new(self).digest())
@@ -271,51 +271,51 @@ where
 /// A SNARK that proves the correct execution of an incremental computation
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct RecursiveSNARK<G1, G2, C1, C2>
+pub struct RecursiveSNARK<E1, E2, C1, C2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
 {
-  z0_primary: Vec<G1::Scalar>,
-  z0_secondary: Vec<G2::Scalar>,
-  r_W_primary: RelaxedR1CSWitness<G1>,
-  r_U_primary: RelaxedR1CSInstance<G1>,
-  r_W_secondary: RelaxedR1CSWitness<G2>,
-  r_U_secondary: RelaxedR1CSInstance<G2>,
-  l_w_secondary: R1CSWitness<G2>,
-  l_u_secondary: R1CSInstance<G2>,
+  z0_primary: Vec<E1::Scalar>,
+  z0_secondary: Vec<E2::Scalar>,
+  r_W_primary: RelaxedR1CSWitness<E1>,
+  r_U_primary: RelaxedR1CSInstance<E1>,
+  r_W_secondary: RelaxedR1CSWitness<E2>,
+  r_U_secondary: RelaxedR1CSInstance<E2>,
+  l_w_secondary: R1CSWitness<E2>,
+  l_u_secondary: R1CSInstance<E2>,
   i: usize,
-  zi_primary: Vec<G1::Scalar>,
-  zi_secondary: Vec<G2::Scalar>,
+  zi_primary: Vec<E1::Scalar>,
+  zi_secondary: Vec<E2::Scalar>,
   _p: PhantomData<(C1, C2)>,
 }
 
-impl<G1, G2, C1, C2> RecursiveSNARK<G1, G2, C1, C2>
+impl<E1, E2, C1, C2> RecursiveSNARK<E1, E2, C1, C2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
 {
   /// Create new instance of recursive SNARK
   pub fn new(
-    pp: &PublicParams<G1, G2, C1, C2>,
+    pp: &PublicParams<E1, E2, C1, C2>,
     c_primary: &C1,
     c_secondary: &C2,
-    z0_primary: &[G1::Scalar],
-    z0_secondary: &[G2::Scalar],
+    z0_primary: &[E1::Scalar],
+    z0_secondary: &[E2::Scalar],
   ) -> Result<Self, NovaError> {
     if z0_primary.len() != pp.F_arity_primary || z0_secondary.len() != pp.F_arity_secondary {
       return Err(NovaError::InvalidInitialInputLength);
     }
 
     // base case for the primary
-    let mut cs_primary = SatisfyingAssignment::<G1>::new();
-    let inputs_primary: NovaAugmentedCircuitInputs<G2> = NovaAugmentedCircuitInputs::new(
-      scalar_as_base::<G1>(pp.digest()),
-      G1::Scalar::ZERO,
+    let mut cs_primary = SatisfyingAssignment::<E1>::new();
+    let inputs_primary: NovaAugmentedCircuitInputs<E2> = NovaAugmentedCircuitInputs::new(
+      scalar_as_base::<E1>(pp.digest()),
+      E1::Scalar::ZERO,
       z0_primary.to_vec(),
       None,
       None,
@@ -323,7 +323,7 @@ where
       None,
     );
 
-    let circuit_primary: NovaAugmentedCircuit<'_, G2, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, E2, C1> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_primary,
       Some(inputs_primary),
       c_primary,
@@ -339,17 +339,17 @@ where
       .expect("Nova error unsat");
 
     // base case for the secondary
-    let mut cs_secondary = SatisfyingAssignment::<G2>::new();
-    let inputs_secondary: NovaAugmentedCircuitInputs<G1> = NovaAugmentedCircuitInputs::new(
+    let mut cs_secondary = SatisfyingAssignment::<E2>::new();
+    let inputs_secondary: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
       pp.digest(),
-      G2::Scalar::ZERO,
+      E2::Scalar::ZERO,
       z0_secondary.to_vec(),
       None,
       None,
       Some(u_primary.clone()),
       None,
     );
-    let circuit_secondary: NovaAugmentedCircuit<'_, G1, C2> = NovaAugmentedCircuit::new(
+    let circuit_secondary: NovaAugmentedCircuit<'_, E1, C2> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_secondary,
       Some(inputs_secondary),
       c_secondary,
@@ -378,9 +378,9 @@ where
     // IVC proof for the secondary circuit
     let l_w_secondary = w_secondary;
     let l_u_secondary = u_secondary;
-    let r_W_secondary = RelaxedR1CSWitness::<G2>::default(&pp.circuit_shape_secondary.r1cs_shape);
+    let r_W_secondary = RelaxedR1CSWitness::<E2>::default(&pp.circuit_shape_secondary.r1cs_shape);
     let r_U_secondary =
-      RelaxedR1CSInstance::<G2>::default(&pp.ck_secondary, &pp.circuit_shape_secondary.r1cs_shape);
+      RelaxedR1CSInstance::<E2>::default(&pp.ck_secondary, &pp.circuit_shape_secondary.r1cs_shape);
 
     assert!(
       !(zi_primary.len() != pp.F_arity_primary || zi_secondary.len() != pp.F_arity_secondary),
@@ -390,13 +390,13 @@ where
     let zi_primary = zi_primary
       .iter()
       .map(|v| v.get_value().ok_or(NovaError::SynthesisError))
-      .collect::<Result<Vec<<G1 as Group>::Scalar>, NovaError>>()
+      .collect::<Result<Vec<<E1 as Engine>::Scalar>, NovaError>>()
       .expect("Nova error synthesis");
 
     let zi_secondary = zi_secondary
       .iter()
       .map(|v| v.get_value().ok_or(NovaError::SynthesisError))
-      .collect::<Result<Vec<<G2 as Group>::Scalar>, NovaError>>()
+      .collect::<Result<Vec<<E2 as Engine>::Scalar>, NovaError>>()
       .expect("Nova error synthesis");
 
     Ok(Self {
@@ -420,7 +420,7 @@ where
   #[tracing::instrument(skip_all, name = "nova::RecursiveSNARK::prove_step")]
   pub fn prove_step(
     &mut self,
-    pp: &PublicParams<G1, G2, C1, C2>,
+    pp: &PublicParams<E1, E2, C1, C2>,
     c_primary: &C1,
     c_secondary: &C2,
   ) -> Result<(), NovaError> {
@@ -434,7 +434,7 @@ where
     let (nifs_secondary, (r_U_secondary, r_W_secondary)) = NIFS::prove(
       &pp.ck_secondary,
       &pp.ro_consts_secondary,
-      &scalar_as_base::<G1>(pp.digest()),
+      &scalar_as_base::<E1>(pp.digest()),
       &pp.circuit_shape_secondary.r1cs_shape,
       &self.r_U_secondary,
       &self.r_W_secondary,
@@ -443,18 +443,18 @@ where
     )
     .expect("Unable to fold secondary");
 
-    let mut cs_primary = SatisfyingAssignment::<G1>::new();
-    let inputs_primary: NovaAugmentedCircuitInputs<G2> = NovaAugmentedCircuitInputs::new(
-      scalar_as_base::<G1>(pp.digest()),
-      G1::Scalar::from(self.i as u64),
+    let mut cs_primary = SatisfyingAssignment::<E1>::new();
+    let inputs_primary: NovaAugmentedCircuitInputs<E2> = NovaAugmentedCircuitInputs::new(
+      scalar_as_base::<E1>(pp.digest()),
+      E1::Scalar::from(self.i as u64),
       self.z0_primary.to_vec(),
       Some(self.zi_primary.clone()),
       Some(self.r_U_secondary.clone()),
       Some(self.l_u_secondary.clone()),
-      Some(Commitment::<G2>::decompress(&nifs_secondary.comm_T)?),
+      Some(Commitment::<E2>::decompress(&nifs_secondary.comm_T)?),
     );
 
-    let circuit_primary: NovaAugmentedCircuit<'_, G2, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, E2, C1> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_primary,
       Some(inputs_primary),
       c_primary,
@@ -483,18 +483,18 @@ where
     )
     .expect("Unable to fold primary");
 
-    let mut cs_secondary = SatisfyingAssignment::<G2>::new();
-    let inputs_secondary: NovaAugmentedCircuitInputs<G1> = NovaAugmentedCircuitInputs::new(
+    let mut cs_secondary = SatisfyingAssignment::<E2>::new();
+    let inputs_secondary: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
       pp.digest(),
-      G2::Scalar::from(self.i as u64),
+      E2::Scalar::from(self.i as u64),
       self.z0_secondary.to_vec(),
       Some(self.zi_secondary.clone()),
       Some(self.r_U_primary.clone()),
       Some(l_u_primary),
-      Some(Commitment::<G1>::decompress(&nifs_primary.comm_T)?),
+      Some(Commitment::<E1>::decompress(&nifs_primary.comm_T)?),
     );
 
-    let circuit_secondary: NovaAugmentedCircuit<'_, G1, C2> = NovaAugmentedCircuit::new(
+    let circuit_secondary: NovaAugmentedCircuit<'_, E1, C2> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_secondary,
       Some(inputs_secondary),
       c_secondary,
@@ -512,11 +512,11 @@ where
     self.zi_primary = zi_primary
       .iter()
       .map(|v| v.get_value().ok_or(NovaError::SynthesisError))
-      .collect::<Result<Vec<<G1 as Group>::Scalar>, NovaError>>()?;
+      .collect::<Result<Vec<<E1 as Engine>::Scalar>, NovaError>>()?;
     self.zi_secondary = zi_secondary
       .iter()
       .map(|v| v.get_value().ok_or(NovaError::SynthesisError))
-      .collect::<Result<Vec<<G2 as Group>::Scalar>, NovaError>>()?;
+      .collect::<Result<Vec<<E2 as Engine>::Scalar>, NovaError>>()?;
 
     self.l_u_secondary = l_u_secondary;
     self.l_w_secondary = l_w_secondary;
@@ -535,11 +535,11 @@ where
   /// Verify the correctness of the `RecursiveSNARK`
   pub fn verify(
     &self,
-    pp: &PublicParams<G1, G2, C1, C2>,
+    pp: &PublicParams<E1, E2, C1, C2>,
     num_steps: usize,
-    z0_primary: &[G1::Scalar],
-    z0_secondary: &[G2::Scalar],
-  ) -> Result<(Vec<G1::Scalar>, Vec<G2::Scalar>), NovaError> {
+    z0_primary: &[E1::Scalar],
+    z0_secondary: &[E2::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<E2::Scalar>), NovaError> {
     // number of steps cannot be zero
     let is_num_steps_zero = num_steps == 0;
 
@@ -564,12 +564,12 @@ where
 
     // check if the output hashes in R1CS instances point to the right running instances
     let (hash_primary, hash_secondary) = {
-      let mut hasher = <<G2 as Group>::RO as ROTrait<G2::Base, G2::Scalar>>::new(
+      let mut hasher = <E2 as Engine>::RO::new(
         pp.ro_consts_secondary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * pp.F_arity_primary,
       );
       hasher.absorb(pp.digest());
-      hasher.absorb(G1::Scalar::from(num_steps as u64));
+      hasher.absorb(E1::Scalar::from(num_steps as u64));
       for e in z0_primary {
         hasher.absorb(*e);
       }
@@ -578,12 +578,12 @@ where
       }
       self.r_U_secondary.absorb_in_ro(&mut hasher);
 
-      let mut hasher2 = <<G1 as Group>::RO as ROTrait<G1::Base, G1::Scalar>>::new(
+      let mut hasher2 = <E1 as Engine>::RO::new(
         pp.ro_consts_primary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * pp.F_arity_secondary,
       );
-      hasher2.absorb(scalar_as_base::<G1>(pp.digest()));
-      hasher2.absorb(G2::Scalar::from(num_steps as u64));
+      hasher2.absorb(scalar_as_base::<E1>(pp.digest()));
+      hasher2.absorb(E2::Scalar::from(num_steps as u64));
       for e in z0_secondary {
         hasher2.absorb(*e);
       }
@@ -599,7 +599,7 @@ where
     };
 
     if hash_primary != self.l_u_secondary.X[0]
-      || hash_secondary != scalar_as_base::<G2>(self.l_u_secondary.X[1])
+      || hash_secondary != scalar_as_base::<E2>(self.l_u_secondary.X[1])
     {
       return Err(NovaError::ProofVerifyError);
     }
@@ -646,14 +646,14 @@ where
 #[derive(Clone, Debug, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
 #[abomonation_omit_bounds]
-pub struct ProverKey<G1, G2, C1, C2, S1, S2>
+pub struct ProverKey<E1, E2, C1, C2, S1, S2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  S1: RelaxedR1CSSNARKTrait<G1>,
-  S2: RelaxedR1CSSNARKTrait<G2>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
+  S1: RelaxedR1CSSNARKTrait<E1>,
+  S2: RelaxedR1CSSNARKTrait<E2>,
 {
   pk_primary: S1::ProverKey,
   pk_secondary: S2::ProverKey,
@@ -664,30 +664,30 @@ where
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
 #[abomonation_bounds(
+  where
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    C1: StepCircuit<E1::Scalar>,
+    C2: StepCircuit<E2::Scalar>,
+    S1: RelaxedR1CSSNARKTrait<E1>,
+    S2: RelaxedR1CSSNARKTrait<E2>,
+    <E1::Scalar as PrimeField>::Repr: Abomonation,
+  )]
+pub struct VerifierKey<E1, E2, C1, C2, S1, S2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  S1: RelaxedR1CSSNARKTrait<G1>,
-  S2: RelaxedR1CSSNARKTrait<G2>,
-  <G1::Scalar as PrimeField>::Repr: Abomonation,
-)]
-pub struct VerifierKey<G1, G2, C1, C2, S1, S2>
-where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  S1: RelaxedR1CSSNARKTrait<G1>,
-  S2: RelaxedR1CSSNARKTrait<G2>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
+  S1: RelaxedR1CSSNARKTrait<E1>,
+  S2: RelaxedR1CSSNARKTrait<E2>,
 {
   F_arity_primary: usize,
   F_arity_secondary: usize,
-  ro_consts_primary: ROConstants<G1>,
-  ro_consts_secondary: ROConstants<G2>,
-  #[abomonate_with(<G1::Scalar as PrimeField>::Repr)]
-  pp_digest: G1::Scalar,
+  ro_consts_primary: ROConstants<E1>,
+  ro_consts_secondary: ROConstants<E2>,
+  #[abomonate_with(<E1::Scalar as PrimeField>::Repr)]
+  pp_digest: E1::Scalar,
   vk_primary: S1::VerifierKey,
   vk_secondary: S2::VerifierKey,
   _p: PhantomData<(C1, C2)>,
@@ -696,45 +696,45 @@ where
 /// A SNARK that proves the knowledge of a valid `RecursiveSNARK`
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct CompressedSNARK<G1, G2, C1, C2, S1, S2>
+pub struct CompressedSNARK<E1, E2, C1, C2, S1, S2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  S1: RelaxedR1CSSNARKTrait<G1>,
-  S2: RelaxedR1CSSNARKTrait<G2>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
+  S1: RelaxedR1CSSNARKTrait<E1>,
+  S2: RelaxedR1CSSNARKTrait<E2>,
 {
-  r_U_primary: RelaxedR1CSInstance<G1>,
+  r_U_primary: RelaxedR1CSInstance<E1>,
   r_W_snark_primary: S1,
 
-  r_U_secondary: RelaxedR1CSInstance<G2>,
-  l_u_secondary: R1CSInstance<G2>,
-  nifs_secondary: NIFS<G2>,
+  r_U_secondary: RelaxedR1CSInstance<E2>,
+  l_u_secondary: R1CSInstance<E2>,
+  nifs_secondary: NIFS<E2>,
   f_W_snark_secondary: S2,
 
-  zn_primary: Vec<G1::Scalar>,
-  zn_secondary: Vec<G2::Scalar>,
+  zn_primary: Vec<E1::Scalar>,
+  zn_secondary: Vec<E2::Scalar>,
 
   _p: PhantomData<(C1, C2)>,
 }
 
-impl<G1, G2, C1, C2, S1, S2> CompressedSNARK<G1, G2, C1, C2, S1, S2>
+impl<E1, E2, C1, C2, S1, S2> CompressedSNARK<E1, E2, C1, C2, S1, S2>
 where
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C1: StepCircuit<G1::Scalar>,
-  C2: StepCircuit<G2::Scalar>,
-  S1: RelaxedR1CSSNARKTrait<G1>,
-  S2: RelaxedR1CSSNARKTrait<G2>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C1: StepCircuit<E1::Scalar>,
+  C2: StepCircuit<E2::Scalar>,
+  S1: RelaxedR1CSSNARKTrait<E1>,
+  S2: RelaxedR1CSSNARKTrait<E2>,
 {
   /// Creates prover and verifier keys for `CompressedSNARK`
   pub fn setup(
-    pp: &PublicParams<G1, G2, C1, C2>,
+    pp: &PublicParams<E1, E2, C1, C2>,
   ) -> Result<
     (
-      ProverKey<G1, G2, C1, C2, S1, S2>,
-      VerifierKey<G1, G2, C1, C2, S1, S2>,
+      ProverKey<E1, E2, C1, C2, S1, S2>,
+      VerifierKey<E1, E2, C1, C2, S1, S2>,
     ),
     NovaError,
   > {
@@ -764,15 +764,15 @@ where
 
   /// Create a new `CompressedSNARK`
   pub fn prove(
-    pp: &PublicParams<G1, G2, C1, C2>,
-    pk: &ProverKey<G1, G2, C1, C2, S1, S2>,
-    recursive_snark: &RecursiveSNARK<G1, G2, C1, C2>,
+    pp: &PublicParams<E1, E2, C1, C2>,
+    pk: &ProverKey<E1, E2, C1, C2, S1, S2>,
+    recursive_snark: &RecursiveSNARK<E1, E2, C1, C2>,
   ) -> Result<Self, NovaError> {
     // fold the secondary circuit's instance with its running instance
     let (nifs_secondary, (f_U_secondary, f_W_secondary)) = NIFS::prove(
       &pp.ck_secondary,
       &pp.ro_consts_secondary,
-      &scalar_as_base::<G1>(pp.digest()),
+      &scalar_as_base::<E1>(pp.digest()),
       &pp.circuit_shape_secondary.r1cs_shape,
       &recursive_snark.r_U_secondary,
       &recursive_snark.r_W_secondary,
@@ -821,11 +821,11 @@ where
   /// Verify the correctness of the `CompressedSNARK`
   pub fn verify(
     &self,
-    vk: &VerifierKey<G1, G2, C1, C2, S1, S2>,
+    vk: &VerifierKey<E1, E2, C1, C2, S1, S2>,
     num_steps: usize,
-    z0_primary: &[G1::Scalar],
-    z0_secondary: &[G2::Scalar],
-  ) -> Result<(Vec<G1::Scalar>, Vec<G2::Scalar>), NovaError> {
+    z0_primary: &[E1::Scalar],
+    z0_secondary: &[E2::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<E2::Scalar>), NovaError> {
     // the number of steps cannot be zero
     if num_steps == 0 {
       return Err(NovaError::ProofVerifyError);
@@ -841,12 +841,12 @@ where
 
     // check if the output hashes in R1CS instances point to the right running instances
     let (hash_primary, hash_secondary) = {
-      let mut hasher = <<G2 as Group>::RO as ROTrait<G2::Base, G2::Scalar>>::new(
+      let mut hasher = <E2 as Engine>::RO::new(
         vk.ro_consts_secondary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * vk.F_arity_primary,
       );
       hasher.absorb(vk.pp_digest);
-      hasher.absorb(G1::Scalar::from(num_steps as u64));
+      hasher.absorb(E1::Scalar::from(num_steps as u64));
       for e in z0_primary {
         hasher.absorb(*e);
       }
@@ -855,12 +855,12 @@ where
       }
       self.r_U_secondary.absorb_in_ro(&mut hasher);
 
-      let mut hasher2 = <<G1 as Group>::RO as ROTrait<G1::Base, G1::Scalar>>::new(
+      let mut hasher2 = <E1 as Engine>::RO::new(
         vk.ro_consts_primary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * vk.F_arity_secondary,
       );
-      hasher2.absorb(scalar_as_base::<G1>(vk.pp_digest));
-      hasher2.absorb(G2::Scalar::from(num_steps as u64));
+      hasher2.absorb(scalar_as_base::<E1>(vk.pp_digest));
+      hasher2.absorb(E2::Scalar::from(num_steps as u64));
       for e in z0_secondary {
         hasher2.absorb(*e);
       }
@@ -876,7 +876,7 @@ where
     };
 
     if hash_primary != self.l_u_secondary.X[0]
-      || hash_secondary != scalar_as_base::<G2>(self.l_u_secondary.X[1])
+      || hash_secondary != scalar_as_base::<E2>(self.l_u_secondary.X[1])
     {
       return Err(NovaError::ProofVerifyError);
     }
@@ -884,7 +884,7 @@ where
     // fold the secondary's running instance with the last instance to get a folded instance
     let f_U_secondary = self.nifs_secondary.verify(
       &vk.ro_consts_secondary,
-      &scalar_as_base::<G1>(vk.pp_digest),
+      &scalar_as_base::<E1>(vk.pp_digest),
       &self.r_U_secondary,
       &self.l_u_secondary,
     )?;
@@ -916,61 +916,57 @@ where
 /// Note for callers: This function should be called with its performance characteristics in mind.
 /// It will synthesize and digest the full `circuit` given.
 pub fn circuit_digest<
-  G1: Group<Base = <G2 as Group>::Scalar>,
-  G2: Group<Base = <G1 as Group>::Scalar>,
-  C: StepCircuit<G1::Scalar>,
+  E1: Engine<Base = <E2 as Engine>::Scalar>,
+  E2: Engine<Base = <E1 as Engine>::Scalar>,
+  C: StepCircuit<E1::Scalar>,
 >(
   circuit: &C,
-) -> G1::Scalar {
+) -> E1::Scalar {
   let augmented_circuit_params = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
 
   // ro_consts_circuit are parameterized by G2 because the type alias uses G2::Base = G1::Scalar
-  let ro_consts_circuit: ROConstantsCircuit<G2> = ROConstantsCircuit::<G2>::default();
+  let ro_consts_circuit: ROConstantsCircuit<E2> = ROConstantsCircuit::<E2>::default();
 
   // Initialize ck for the primary
-  let augmented_circuit: NovaAugmentedCircuit<'_, G2, C> =
+  let augmented_circuit: NovaAugmentedCircuit<'_, E2, C> =
     NovaAugmentedCircuit::new(&augmented_circuit_params, None, circuit, ro_consts_circuit);
-  let mut cs: ShapeCS<G1> = ShapeCS::new();
+  let mut cs: ShapeCS<E1> = ShapeCS::new();
   let _ = augmented_circuit.synthesize(&mut cs);
   cs.r1cs_shape().digest()
 }
 
-type CommitmentKey<G> = <<G as Group>::CE as CommitmentEngineTrait<G>>::CommitmentKey;
-type Commitment<G> = <<G as Group>::CE as CommitmentEngineTrait<G>>::Commitment;
-type CompressedCommitment<G> = <<<G as Group>::CE as CommitmentEngineTrait<G>>::Commitment as CommitmentTrait<G>>::CompressedCommitment;
-type CE<G> = <G as Group>::CE;
+type CommitmentKey<E> = <<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey;
+type Commitment<E> = <<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment;
+type CompressedCommitment<E> = <<<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment as CommitmentTrait<E>>::CompressedCommitment;
+type CE<E> = <E as Engine>::CE;
 
 #[cfg(test)]
 mod tests {
+  use super::*;
   use crate::{
     provider::{
-      bn256_grumpkin::{bn256, grumpkin},
-      secp_secq::{secp256k1, secq256k1},
-      GroupExt,
+      bn256_grumpkin::{Bn256Engine, GrumpkinEngine},
+      pasta::{PallasEngine, VestaEngine},
+      secp_secq::{Secp256k1Engine, Secq256k1Engine},
+      DlogGroup,
     },
     traits::{evaluation::EvaluationEngineTrait, snark::default_ck_hint},
   };
-  use core::fmt::Write;
-
-  use super::*;
-  type EE<G> = provider::ipa_pc::EvaluationEngine<G>;
-  type S<G, EE> = spartan::snark::RelaxedR1CSSNARK<G, EE>;
-  type SPrime<G, EE> = spartan::ppsnark::RelaxedR1CSSNARK<G, EE>;
-
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
-  use core::marker::PhantomData;
+  use core::{fmt::Write, marker::PhantomData};
   use ff::PrimeField;
   use traits::circuit::TrivialCircuit;
 
+  type EE<E> = provider::ipa_pc::EvaluationEngine<E>;
+  type S<E, EE> = spartan::snark::RelaxedR1CSSNARK<E, EE>;
+  type SPrime<E, EE> = spartan::ppsnark::RelaxedR1CSSNARK<E, EE>;
+
   #[derive(Clone, Debug, Default)]
   struct CubicCircuit<F: PrimeField> {
     _p: PhantomData<F>,
   }
 
-  impl<F> StepCircuit<F> for CubicCircuit<F>
-  where
-    F: PrimeField,
-  {
+  impl<F: PrimeField> StepCircuit<F> for CubicCircuit<F> {
     fn arity(&self) -> usize {
       1
     }
@@ -1007,30 +1003,30 @@ mod tests {
     }
   }
 
-  impl<F> CubicCircuit<F>
-  where
-    F: PrimeField,
-  {
+  impl<F: PrimeField> CubicCircuit<F> {
     fn output(&self, z: &[F]) -> Vec<F> {
       vec![z[0] * z[0] * z[0] + z[0] + F::from(5u64)]
     }
   }
 
-  fn test_pp_digest_with<G1, G2, T1, T2, E1, E2>(circuit1: &T1, circuit2: &T2, _expected: &str)
+  fn test_pp_digest_with<E1, E2, T1, T2, EE1, EE2>(circuit1: &T1, circuit2: &T2, expected: &str)
   where
-    G1: Group<Base = <G2 as Group>::Scalar> + GroupExt,
-    G2: Group<Base = <G1 as Group>::Scalar> + GroupExt,
-    T1: StepCircuit<G1::Scalar>,
-    T2: StepCircuit<G2::Scalar>,
-    E1: EvaluationEngineTrait<G1>,
-    E2: EvaluationEngineTrait<G2>,
-    <G1::Scalar as PrimeField>::Repr: Abomonation,
-    <G2::Scalar as PrimeField>::Repr: Abomonation,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    E1::GE: DlogGroup,
+    E2::GE: DlogGroup,
+    T1: StepCircuit<E1::Scalar>,
+    T2: StepCircuit<E2::Scalar>,
+    EE1: EvaluationEngineTrait<E1>,
+    EE2: EvaluationEngineTrait<E2>,
+    // this is due to the reliance on Abomonation
+    <E1::Scalar as PrimeField>::Repr: Abomonation,
+    <E2::Scalar as PrimeField>::Repr: Abomonation,    
   {
     // this tests public parameters with a size specifically intended for a spark-compressed SNARK
-    let ck_hint1 = &*SPrime::<G1, E1>::ck_floor();
-    let ck_hint2 = &*SPrime::<G2, E2>::ck_floor();
-    let pp = PublicParams::<G1, G2, T1, T2>::setup(circuit1, circuit2, ck_hint1, ck_hint2);
+    let ck_hint1 = &*SPrime::<E1, EE1>::ck_floor();
+    let ck_hint2 = &*SPrime::<E2, EE2>::ck_floor();
+    let pp = PublicParams::<E1, E2, T1, T2>::setup(circuit1, circuit2, ck_hint1, ck_hint2);
 
     let digest_str = pp
       .digest()
@@ -1041,92 +1037,89 @@ mod tests {
         let _ = write!(output, "{b:02x}");
         output
       });
-    println!("{:?}", digest_str);
-    // assert_eq!(digest_str, expected);
+    assert_eq!(digest_str, expected);
   }
 
   #[test]
   fn test_pp_digest() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-    let trivial_circuit1 = TrivialCircuit::<<G1 as Group>::Scalar>::default();
-    let trivial_circuit2 = TrivialCircuit::<<G2 as Group>::Scalar>::default();
-    let cubic_circuit1 = CubicCircuit::<<G1 as Group>::Scalar>::default();
+    let trivial_circuit1 = TrivialCircuit::<<PallasEngine as Engine>::Scalar>::default();
+    let trivial_circuit2 = TrivialCircuit::<<VestaEngine as Engine>::Scalar>::default();
+    let cubic_circuit1 = CubicCircuit::<<PallasEngine as Engine>::Scalar>::default();
 
-    test_pp_digest_with::<G1, G2, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<PallasEngine, VestaEngine, _, _, EE<_>, EE<_>>(
       &trivial_circuit1,
       &trivial_circuit2,
-      "cb581e2d5c4b2ef2ddbe2d6849e0da810352f59bcdaca51476dcf9e16072f100",
+      "f4a04841515b4721519e2671b7ee11e58e2d4a30bb183ded963b71ad2ec80d00",
     );
 
-    test_pp_digest_with::<G1, G2, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<PallasEngine, VestaEngine, _, _, EE<_>, EE<_>>(
       &cubic_circuit1,
       &trivial_circuit2,
-      "3cc29bb864910463e0501bac84cdefc1d4327e9c2ef5b0fd6d45ad1741f1a401",
+      "dc1b7c40ab50c5c6877ad027769452870cc28f1d13f140de7ca3a00138c58502",
     );
 
-    let trivial_circuit1_grumpkin = TrivialCircuit::<<bn256::Point as Group>::Scalar>::default();
-    let trivial_circuit2_grumpkin = TrivialCircuit::<<grumpkin::Point as Group>::Scalar>::default();
-    let cubic_circuit1_grumpkin = CubicCircuit::<<bn256::Point as Group>::Scalar>::default();
+    let trivial_circuit1_grumpkin = TrivialCircuit::<<Bn256Engine as Engine>::Scalar>::default();
+    let trivial_circuit2_grumpkin = TrivialCircuit::<<GrumpkinEngine as Engine>::Scalar>::default();
+    let cubic_circuit1_grumpkin = CubicCircuit::<<Bn256Engine as Engine>::Scalar>::default();
 
     // These tests should not need be different on the "asm" feature for bn256.
     // See https://github.com/privacy-scaling-explorations/halo2curves/issues/100 for why they are - closing the issue there
     // should eliminate the discrepancy here.
     #[cfg(feature = "asm")]
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Bn256Engine, GrumpkinEngine, _, _, EE<_>, EE<_>>(
       &trivial_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
       "c4ecd363a6c1473de7e0d24fc1dbb660f563556e2e13fb4614acdff04cab7701",
     );
     #[cfg(feature = "asm")]
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Bn256Engine, GrumpkinEngine, _, _, EE<_>, EE<_>>(
       &cubic_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
       "4853a6463b6309f6ae76442934d0a423f51f1e10abaddd0d39bf5644ed589100",
     );
     #[cfg(not(feature = "asm"))]
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Bn256Engine, GrumpkinEngine, _, _, EE<_>, EE<_>>(
       &trivial_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
-      "c26cc841d42c19bf98bc2482e66cd30903922f2a923927b85d66f375a821f101",
+      "c565748bea3336f07c8ff997c542ed62385ff5662f29402c4f9747153f699e01",
     );
     #[cfg(not(feature = "asm"))]
-    test_pp_digest_with::<bn256::Point, grumpkin::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Bn256Engine, GrumpkinEngine, _, _, EE<_>, EE<_>>(
       &cubic_circuit1_grumpkin,
       &trivial_circuit2_grumpkin,
-      "4c484cab71e93dda69b420beb7276af969c2034a7ffb0ea8e6964e96a7e5a901",
+      "5aec6defcb0f6b2bb14aec70362419388916d7a5bc528c0b3fabb197ae57cb03",
     );
 
-    let trivial_circuit1_secp = TrivialCircuit::<<secp256k1::Point as Group>::Scalar>::default();
-    let trivial_circuit2_secp = TrivialCircuit::<<secq256k1::Point as Group>::Scalar>::default();
-    let cubic_circuit1_secp = CubicCircuit::<<secp256k1::Point as Group>::Scalar>::default();
+    let trivial_circuit1_secp = TrivialCircuit::<<Secp256k1Engine as Engine>::Scalar>::default();
+    let trivial_circuit2_secp = TrivialCircuit::<<Secq256k1Engine as Engine>::Scalar>::default();
+    let cubic_circuit1_secp = CubicCircuit::<<Secp256k1Engine as Engine>::Scalar>::default();
 
-    test_pp_digest_with::<secp256k1::Point, secq256k1::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Secp256k1Engine, Secq256k1Engine, _, _, EE<_>, EE<_>>(
       &trivial_circuit1_secp,
       &trivial_circuit2_secp,
-      "b794d655fb39891eaf530ca3be1ec2a5ac97f72a0d07c45dbb84529d8a611502",
+      "66c6d3618bb824bcb9253b7731247b89432853bf2014ffae45a8f6b00befe303",
     );
-    test_pp_digest_with::<secp256k1::Point, secq256k1::Point, _, _, EE<_>, EE<_>>(
+    test_pp_digest_with::<Secp256k1Engine, Secq256k1Engine, _, _, EE<_>, EE<_>>(
       &cubic_circuit1_secp,
       &trivial_circuit2_secp,
-      "50e6acf363c31c2ac1c9c646b4494cb21aae6cb648c7b0d4c95015c811fba302",
+      "cc22c270460e11d190235fbd691bdeec51e8200219e5e65112e48bb80b610803",
     );
   }
 
-  fn test_ivc_trivial_with<G1, G2>()
+  fn test_ivc_trivial_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
-    let test_circuit1 = TrivialCircuit::<<G1 as Group>::Scalar>::default();
-    let test_circuit2 = TrivialCircuit::<<G2 as Group>::Scalar>::default();
+    let test_circuit1 = TrivialCircuit::<<E1 as Engine>::Scalar>::default();
+    let test_circuit2 = TrivialCircuit::<<E2 as Engine>::Scalar>::default();
 
     // produce public parameters
     let pp = PublicParams::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      TrivialCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      TrivialCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &test_circuit1,
       &test_circuit2,
@@ -1140,8 +1133,8 @@ mod tests {
       &pp,
       &test_circuit1,
       &test_circuit2,
-      &[<G1 as Group>::Scalar::ZERO],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ZERO],
+      &[<E2 as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1153,36 +1146,33 @@ mod tests {
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &[<G1 as Group>::Scalar::ZERO],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ZERO],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
 
   #[test]
   fn test_ivc_trivial() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_trivial_with::<G1, G2>();
-    test_ivc_trivial_with::<bn256::Point, grumpkin::Point>();
-    test_ivc_trivial_with::<secp256k1::Point, secq256k1::Point>();
+    test_ivc_trivial_with::<PallasEngine, VestaEngine>();
+    test_ivc_trivial_with::<Bn256Engine, GrumpkinEngine>();
+    test_ivc_trivial_with::<Secp256k1Engine, Secq256k1Engine>();
   }
 
-  fn test_ivc_nontrivial_with<G1, G2>()
+  fn test_ivc_nontrivial_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
     let circuit_primary = TrivialCircuit::default();
     let circuit_secondary = CubicCircuit::default();
 
     // produce public parameters
     let pp = PublicParams::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &circuit_primary,
       &circuit_secondary,
@@ -1194,16 +1184,16 @@ mod tests {
 
     // produce a recursive SNARK
     let mut recursive_snark = RecursiveSNARK::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::new(
       &pp,
       &circuit_primary,
       &circuit_secondary,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1215,8 +1205,8 @@ mod tests {
       let res = recursive_snark.verify(
         &pp,
         i + 1,
-        &[<G1 as Group>::Scalar::ONE],
-        &[<G2 as Group>::Scalar::ZERO],
+        &[<E1 as Engine>::Scalar::ONE],
+        &[<E2 as Engine>::Scalar::ZERO],
       );
       assert!(res.is_ok());
     }
@@ -1225,52 +1215,49 @@ mod tests {
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
     let (zn_primary, zn_secondary) = res.unwrap();
 
     // sanity: check the claimed output with a direct computation of the same
-    assert_eq!(zn_primary, vec![<G1 as Group>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<G2 as Group>::Scalar::ZERO];
+    assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
+    let mut zn_secondary_direct = vec![<E2 as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = circuit_secondary.clone().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
-    assert_eq!(zn_secondary, vec![<G2 as Group>::Scalar::from(2460515u64)]);
+    assert_eq!(zn_secondary, vec![<E2 as Engine>::Scalar::from(2460515u64)]);
   }
 
   #[test]
   fn test_ivc_nontrivial() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_nontrivial_with::<G1, G2>();
-    test_ivc_nontrivial_with::<bn256::Point, grumpkin::Point>();
-    test_ivc_nontrivial_with::<secp256k1::Point, secq256k1::Point>();
+    test_ivc_nontrivial_with::<PallasEngine, VestaEngine>();
+    test_ivc_nontrivial_with::<Bn256Engine, GrumpkinEngine>();
+    test_ivc_nontrivial_with::<Secp256k1Engine, Secq256k1Engine>();
   }
 
-  fn test_ivc_nontrivial_with_compression_with<G1, G2, E1, E2>()
+  fn test_ivc_nontrivial_with_compression_with<E1, E2, EE1, EE2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
-    E1: EvaluationEngineTrait<G1>,
-    E2: EvaluationEngineTrait<G2>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    EE1: EvaluationEngineTrait<E1>,
+    EE2: EvaluationEngineTrait<E2>,
     // this is due to the reliance on Abomonation
-    <<G1 as Group>::Scalar as PrimeField>::Repr: Abomonation,
-    <<G2 as Group>::Scalar as PrimeField>::Repr: Abomonation,
+    <E1::Scalar as PrimeField>::Repr: Abomonation,
+    <E2::Scalar as PrimeField>::Repr: Abomonation,    
   {
     let circuit_primary = TrivialCircuit::default();
     let circuit_secondary = CubicCircuit::default();
 
     // produce public parameters
     let pp = PublicParams::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &circuit_primary,
       &circuit_secondary,
@@ -1282,16 +1269,16 @@ mod tests {
 
     // produce a recursive SNARK
     let mut recursive_snark = RecursiveSNARK::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::new(
       &pp,
       &circuit_primary,
       &circuit_secondary,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1304,28 +1291,28 @@ mod tests {
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
     let (zn_primary, zn_secondary) = res.unwrap();
 
     // sanity: check the claimed output with a direct computation of the same
-    assert_eq!(zn_primary, vec![<G1 as Group>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<G2 as Group>::Scalar::ZERO];
+    assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
+    let mut zn_secondary_direct = vec![<E2 as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = circuit_secondary.clone().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
-    assert_eq!(zn_secondary, vec![<G2 as Group>::Scalar::from(2460515u64)]);
+    assert_eq!(zn_secondary, vec![<E2 as Engine>::Scalar::from(2460515u64)]);
 
     // produce the prover and verifier keys for compressed snark
-    let (pk, vk) = CompressedSNARK::<_, _, _, _, S<G1, E1>, S<G2, E2>>::setup(&pp).unwrap();
+    let (pk, vk) = CompressedSNARK::<_, _, _, _, S<E1, EE1>, S<E2, EE2>>::setup(&pp).unwrap();
 
     // produce a compressed SNARK
     let res =
-      CompressedSNARK::<_, _, _, _, S<G1, E1>, S<G2, E2>>::prove(&pp, &pk, &recursive_snark);
+      CompressedSNARK::<_, _, _, _, S<E1, EE1>, S<E2, EE2>>::prove(&pp, &pk, &recursive_snark);
     assert!(res.is_ok());
     let compressed_snark = res.unwrap();
 
@@ -1333,62 +1320,59 @@ mod tests {
     let res = compressed_snark.verify(
       &vk,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
 
   #[test]
   fn test_ivc_nontrivial_with_compression() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_nontrivial_with_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nontrivial_with_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>();
-    test_ivc_nontrivial_with_compression_with::<secp256k1::Point, secq256k1::Point, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_compression_with::<PallasEngine, VestaEngine, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_compression_with::<Bn256Engine, GrumpkinEngine, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_compression_with::<Secp256k1Engine, Secq256k1Engine, EE<_>, EE<_>>();
   }
 
-  fn test_ivc_nontrivial_with_spark_compression_with<G1, G2, E1, E2>()
+  fn test_ivc_nontrivial_with_spark_compression_with<E1, E2, EE1, EE2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
-    E1: EvaluationEngineTrait<G1>,
-    E2: EvaluationEngineTrait<G2>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    EE1: EvaluationEngineTrait<E1>,
+    EE2: EvaluationEngineTrait<E2>,
     // this is due to the reliance on Abomonation
-    <<G1 as Group>::Scalar as PrimeField>::Repr: Abomonation,
-    <<G2 as Group>::Scalar as PrimeField>::Repr: Abomonation,
+    <E1::Scalar as PrimeField>::Repr: Abomonation,
+    <E2::Scalar as PrimeField>::Repr: Abomonation,    
   {
     let circuit_primary = TrivialCircuit::default();
     let circuit_secondary = CubicCircuit::default();
 
     // produce public parameters, which we'll use with a spark-compressed SNARK
     let pp = PublicParams::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &circuit_primary,
       &circuit_secondary,
-      &*SPrime::<_, E1>::ck_floor(),
-      &*SPrime::<_, E2>::ck_floor(),
+      &*SPrime::<E1, EE1>::ck_floor(),
+      &*SPrime::<E2, EE2>::ck_floor(),
     );
 
     let num_steps = 3;
 
     // produce a recursive SNARK
     let mut recursive_snark = RecursiveSNARK::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::new(
       &pp,
       &circuit_primary,
       &circuit_secondary,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1401,29 +1385,29 @@ mod tests {
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
     let (zn_primary, zn_secondary) = res.unwrap();
 
     // sanity: check the claimed output with a direct computation of the same
-    assert_eq!(zn_primary, vec![<G1 as Group>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<G2 as Group>::Scalar::ZERO];
+    assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
+    let mut zn_secondary_direct = vec![<E2 as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = CubicCircuit::default().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
-    assert_eq!(zn_secondary, vec![<G2 as Group>::Scalar::from(2460515u64)]);
+    assert_eq!(zn_secondary, vec![<E2 as Engine>::Scalar::from(2460515u64)]);
 
     // run the compressed snark with Spark compiler
     // produce the prover and verifier keys for compressed snark
     let (pk, vk) =
-      CompressedSNARK::<_, _, _, _, SPrime<G1, E1>, SPrime<G2, E2>>::setup(&pp).unwrap();
+      CompressedSNARK::<_, _, _, _, SPrime<E1, EE1>, SPrime<E2, EE2>>::setup(&pp).unwrap();
 
     // produce a compressed SNARK
-    let res = CompressedSNARK::<_, _, _, _, SPrime<G1, E1>, SPrime<G2, E2>>::prove(
+    let res = CompressedSNARK::<_, _, _, _, SPrime<E1, EE1>, SPrime<E2, EE2>>::prove(
       &pp,
       &pk,
       &recursive_snark,
@@ -1435,37 +1419,29 @@ mod tests {
     let res = compressed_snark.verify(
       &vk,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
 
   #[test]
   fn test_ivc_nontrivial_with_spark_compression() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_nontrivial_with_spark_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nontrivial_with_spark_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>(
+    test_ivc_nontrivial_with_spark_compression_with::<PallasEngine, VestaEngine, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_spark_compression_with::<Bn256Engine, GrumpkinEngine, EE<_>, EE<_>>();
+    test_ivc_nontrivial_with_spark_compression_with::<Secp256k1Engine, Secq256k1Engine, EE<_>, EE<_>>(
     );
-    test_ivc_nontrivial_with_spark_compression_with::<
-      secp256k1::Point,
-      secq256k1::Point,
-      EE<_>,
-      EE<_>,
-    >();
   }
 
-  fn test_ivc_nondet_with_compression_with<G1, G2, E1, E2>()
+  fn test_ivc_nondet_with_compression_with<E1, E2, EE1, EE2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
-    E1: EvaluationEngineTrait<G1>,
-    E2: EvaluationEngineTrait<G2>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
+    EE1: EvaluationEngineTrait<E1>,
+    EE2: EvaluationEngineTrait<E2>,
     // this is due to the reliance on Abomonation
-    <<G1 as Group>::Scalar as PrimeField>::Repr: Abomonation,
-    <<G2 as Group>::Scalar as PrimeField>::Repr: Abomonation,
+    <E1::Scalar as PrimeField>::Repr: Abomonation,
+    <E2::Scalar as PrimeField>::Repr: Abomonation,
   {
     // y is a non-deterministic advice representing the fifth root of the input at a step.
     #[derive(Clone, Debug)]
@@ -1473,10 +1449,7 @@ mod tests {
       y: F,
     }
 
-    impl<F> FifthRootCheckingCircuit<F>
-    where
-      F: PrimeField,
-    {
+    impl<F: PrimeField> FifthRootCheckingCircuit<F> {
       fn new(num_steps: usize) -> (Vec<F>, Vec<Self>) {
         let mut powers = Vec::new();
         let rng = &mut rand::rngs::OsRng;
@@ -1528,17 +1501,17 @@ mod tests {
     }
 
     let circuit_primary = FifthRootCheckingCircuit {
-      y: <G1 as Group>::Scalar::ZERO,
+      y: <E1 as Engine>::Scalar::ZERO,
     };
 
     let circuit_secondary = TrivialCircuit::default();
 
     // produce public parameters
     let pp = PublicParams::<
-      G1,
-      G2,
-      FifthRootCheckingCircuit<<G1 as Group>::Scalar>,
-      TrivialCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      FifthRootCheckingCircuit<<E1 as Engine>::Scalar>,
+      TrivialCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &circuit_primary,
       &circuit_secondary,
@@ -1550,19 +1523,19 @@ mod tests {
 
     // produce non-deterministic advice
     let (z0_primary, roots) = FifthRootCheckingCircuit::new(num_steps);
-    let z0_secondary = vec![<G2 as Group>::Scalar::ZERO];
+    let z0_secondary = vec![<E2 as Engine>::Scalar::ZERO];
 
     // produce a recursive SNARK
     let mut recursive_snark: RecursiveSNARK<
-      G1,
-      G2,
-      FifthRootCheckingCircuit<<G1 as Group>::Scalar>,
-      TrivialCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      FifthRootCheckingCircuit<<E1 as Engine>::Scalar>,
+      TrivialCircuit<<E2 as Engine>::Scalar>,
     > = RecursiveSNARK::<
-      G1,
-      G2,
-      FifthRootCheckingCircuit<<G1 as Group>::Scalar>,
-      TrivialCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      FifthRootCheckingCircuit<<E1 as Engine>::Scalar>,
+      TrivialCircuit<<E2 as Engine>::Scalar>,
     >::new(
       &pp,
       &roots[0],
@@ -1582,11 +1555,11 @@ mod tests {
     assert!(res.is_ok());
 
     // produce the prover and verifier keys for compressed snark
-    let (pk, vk) = CompressedSNARK::<_, _, _, _, S<G1, E1>, S<G2, E2>>::setup(&pp).unwrap();
+    let (pk, vk) = CompressedSNARK::<_, _, _, _, S<E1, EE1>, S<E2, EE2>>::setup(&pp).unwrap();
 
     // produce a compressed SNARK
     let res =
-      CompressedSNARK::<_, _, _, _, S<G1, E1>, S<G2, E2>>::prove(&pp, &pk, &recursive_snark);
+      CompressedSNARK::<_, _, _, _, S<E1, EE1>, S<E2, EE2>>::prove(&pp, &pk, &recursive_snark);
     assert!(res.is_ok());
     let compressed_snark = res.unwrap();
 
@@ -1597,28 +1570,25 @@ mod tests {
 
   #[test]
   fn test_ivc_nondet_with_compression() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_nondet_with_compression_with::<G1, G2, EE<_>, EE<_>>();
-    test_ivc_nondet_with_compression_with::<bn256::Point, grumpkin::Point, EE<_>, EE<_>>();
-    test_ivc_nondet_with_compression_with::<secp256k1::Point, secq256k1::Point, EE<_>, EE<_>>();
+    test_ivc_nondet_with_compression_with::<PallasEngine, VestaEngine, EE<_>, EE<_>>();
+    test_ivc_nondet_with_compression_with::<Bn256Engine, GrumpkinEngine, EE<_>, EE<_>>();
+    test_ivc_nondet_with_compression_with::<Secp256k1Engine, Secq256k1Engine, EE<_>, EE<_>>();
   }
 
-  fn test_ivc_base_with<G1, G2>()
+  fn test_ivc_base_with<E1, E2>()
   where
-    G1: Group<Base = <G2 as Group>::Scalar>,
-    G2: Group<Base = <G1 as Group>::Scalar>,
+    E1: Engine<Base = <E2 as Engine>::Scalar>,
+    E2: Engine<Base = <E1 as Engine>::Scalar>,
   {
-    let test_circuit1 = TrivialCircuit::<<G1 as Group>::Scalar>::default();
-    let test_circuit2 = CubicCircuit::<<G2 as Group>::Scalar>::default();
+    let test_circuit1 = TrivialCircuit::<<E1 as Engine>::Scalar>::default();
+    let test_circuit2 = CubicCircuit::<<E2 as Engine>::Scalar>::default();
 
     // produce public parameters
     let pp = PublicParams::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::setup(
       &test_circuit1,
       &test_circuit2,
@@ -1630,16 +1600,16 @@ mod tests {
 
     // produce a recursive SNARK
     let mut recursive_snark = RecursiveSNARK::<
-      G1,
-      G2,
-      TrivialCircuit<<G1 as Group>::Scalar>,
-      CubicCircuit<<G2 as Group>::Scalar>,
+      E1,
+      E2,
+      TrivialCircuit<<E1 as Engine>::Scalar>,
+      CubicCircuit<<E2 as Engine>::Scalar>,
     >::new(
       &pp,
       &test_circuit1,
       &test_circuit2,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1652,24 +1622,21 @@ mod tests {
     let res = recursive_snark.verify(
       &pp,
       num_steps,
-      &[<G1 as Group>::Scalar::ONE],
-      &[<G2 as Group>::Scalar::ZERO],
+      &[<E1 as Engine>::Scalar::ONE],
+      &[<E2 as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
     let (zn_primary, zn_secondary) = res.unwrap();
 
-    assert_eq!(zn_primary, vec![<G1 as Group>::Scalar::ONE]);
-    assert_eq!(zn_secondary, vec![<G2 as Group>::Scalar::from(5u64)]);
+    assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
+    assert_eq!(zn_secondary, vec![<E2 as Engine>::Scalar::from(5u64)]);
   }
 
   #[test]
   fn test_ivc_base() {
-    type G1 = pasta_curves::pallas::Point;
-    type G2 = pasta_curves::vesta::Point;
-
-    test_ivc_base_with::<G1, G2>();
-    test_ivc_base_with::<bn256::Point, grumpkin::Point>();
-    test_ivc_base_with::<secp256k1::Point, secq256k1::Point>();
+    test_ivc_base_with::<PallasEngine, VestaEngine>();
+    test_ivc_base_with::<Bn256Engine, GrumpkinEngine>();
+    test_ivc_base_with::<Secp256k1Engine, Secq256k1Engine>();
   }
 }
diff --git a/src/nifs.rs b/src/nifs.rs
index 0913dc942..d82681c6a 100644
--- a/src/nifs.rs
+++ b/src/nifs.rs
@@ -6,7 +6,7 @@ use crate::{
   errors::NovaError,
   r1cs::{R1CSInstance, R1CSShape, R1CSWitness, RelaxedR1CSInstance, RelaxedR1CSWitness},
   scalar_as_base,
-  traits::{commitment::CommitmentTrait, AbsorbInROTrait, Group, ROTrait},
+  traits::{commitment::CommitmentTrait, AbsorbInROTrait, Engine, ROTrait},
   Commitment, CommitmentKey, CompressedCommitment,
 };
 use serde::{Deserialize, Serialize};
@@ -15,14 +15,14 @@ use serde::{Deserialize, Serialize};
 #[allow(clippy::upper_case_acronyms)]
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct NIFS<G: Group> {
-  pub(crate) comm_T: CompressedCommitment<G>,
+pub struct NIFS<E: Engine> {
+  pub(crate) comm_T: CompressedCommitment<E>,
 }
 
-type ROConstants<G> =
-  <<G as Group>::RO as ROTrait<<G as Group>::Base, <G as Group>::Scalar>>::Constants;
+type ROConstants<E> =
+  <<E as Engine>::RO as ROTrait<<E as Engine>::Base, <E as Engine>::Scalar>>::Constants;
 
-impl<G: Group> NIFS<G> {
+impl<E: Engine> NIFS<E> {
   /// Takes as input a Relaxed R1CS instance-witness tuple `(U1, W1)` and
   /// an R1CS instance-witness tuple `(U2, W2)` with the same structure `shape`
   /// and defined with respect to the same `ck`, and outputs
@@ -32,20 +32,20 @@ impl<G: Group> NIFS<G> {
   #[allow(clippy::too_many_arguments)]
   #[tracing::instrument(skip_all, level = "trace", name = "NIFS::prove")]
   pub fn prove(
-    ck: &CommitmentKey<G>,
-    ro_consts: &ROConstants<G>,
-    pp_digest: &G::Scalar,
-    S: &R1CSShape<G>,
-    U1: &RelaxedR1CSInstance<G>,
-    W1: &RelaxedR1CSWitness<G>,
-    U2: &R1CSInstance<G>,
-    W2: &R1CSWitness<G>,
-  ) -> Result<(NIFS<G>, (RelaxedR1CSInstance<G>, RelaxedR1CSWitness<G>)), NovaError> {
+    ck: &CommitmentKey<E>,
+    ro_consts: &ROConstants<E>,
+    pp_digest: &E::Scalar,
+    S: &R1CSShape<E>,
+    U1: &RelaxedR1CSInstance<E>,
+    W1: &RelaxedR1CSWitness<E>,
+    U2: &R1CSInstance<E>,
+    W2: &R1CSWitness<E>,
+  ) -> Result<(NIFS<E>, (RelaxedR1CSInstance<E>, RelaxedR1CSWitness<E>)), NovaError> {
     // initialize a new RO
-    let mut ro = G::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
+    let mut ro = E::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
 
     // append the digest of pp to the transcript
-    ro.absorb(scalar_as_base::<G>(*pp_digest));
+    ro.absorb(scalar_as_base::<E>(*pp_digest));
 
     // append U1 and U2 to transcript
     U1.absorb_in_ro(&mut ro);
@@ -82,23 +82,23 @@ impl<G: Group> NIFS<G> {
   /// if and only if `U1` and `U2` are satisfiable.
   pub fn verify(
     &self,
-    ro_consts: &ROConstants<G>,
-    pp_digest: &G::Scalar,
-    U1: &RelaxedR1CSInstance<G>,
-    U2: &R1CSInstance<G>,
-  ) -> Result<RelaxedR1CSInstance<G>, NovaError> {
+    ro_consts: &ROConstants<E>,
+    pp_digest: &E::Scalar,
+    U1: &RelaxedR1CSInstance<E>,
+    U2: &R1CSInstance<E>,
+  ) -> Result<RelaxedR1CSInstance<E>, NovaError> {
     // initialize a new RO
-    let mut ro = G::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
+    let mut ro = E::RO::new(ro_consts.clone(), NUM_FE_FOR_RO);
 
     // append the digest of pp to the transcript
-    ro.absorb(scalar_as_base::<G>(*pp_digest));
+    ro.absorb(scalar_as_base::<E>(*pp_digest));
 
     // append U1 and U2 to transcript
     U1.absorb_in_ro(&mut ro);
     U2.absorb_in_ro(&mut ro);
 
     // append `comm_T` to the transcript and obtain a challenge
-    let comm_T = Commitment::<G>::decompress(&self.comm_T)?;
+    let comm_T = Commitment::<E>::decompress(&self.comm_T)?;
     comm_T.absorb_in_ro(&mut ro);
 
     // compute a challenge from the RO
@@ -116,16 +116,19 @@ impl<G: Group> NIFS<G> {
 mod tests {
   use super::*;
   use crate::{
-    r1cs::{commitment_key, SparseMatrix},
-    traits::snark::default_ck_hint,
-    traits::{commitment::CommitmentEngineTrait, Group},
+    bellpepper::{
+      r1cs::{NovaShape, NovaWitness},
+      solver::SatisfyingAssignment,
+      test_shape_cs::TestShapeCS,
+    },
+    provider::{bn256_grumpkin::Bn256Engine, pasta::PallasEngine, secp_secq::Secp256k1Engine},
+    r1cs::{SparseMatrix, commitment_key},
+    traits::{snark::default_ck_hint, Engine},
   };
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
   use ff::{Field, PrimeField};
   use rand::rngs::OsRng;
 
-  type G = pasta_curves::pallas::Point;
-
   fn synthesize_tiny_r1cs_bellpepper<Scalar: PrimeField, CS: ConstraintSystem<Scalar>>(
     cs: &mut CS,
     x_val: Option<Scalar>,
@@ -159,34 +162,25 @@ mod tests {
     Ok(())
   }
 
-  fn test_tiny_r1cs_bellpepper_with<G>()
-  where
-    G: Group,
-  {
-    use crate::bellpepper::{
-      r1cs::{NovaShape, NovaWitness},
-      solver::SatisfyingAssignment,
-      test_shape_cs::TestShapeCS,
-    };
-
+  fn test_tiny_r1cs_bellpepper_with<E: Engine>() {
     // First create the shape
-    let mut cs: TestShapeCS<G> = TestShapeCS::new();
+    let mut cs: TestShapeCS<E> = TestShapeCS::new();
     let _ = synthesize_tiny_r1cs_bellpepper(&mut cs, None);
     let (shape, ck) = cs.r1cs_shape_and_key(&*default_ck_hint());
     let ro_consts =
-      <<G as Group>::RO as ROTrait<<G as Group>::Base, <G as Group>::Scalar>>::Constants::default();
+      <<E as Engine>::RO as ROTrait<<E as Engine>::Base, <E as Engine>::Scalar>>::Constants::default();
 
     // Now get the instance and assignment for one instance
-    let mut cs = SatisfyingAssignment::<G>::new();
-    let _ = synthesize_tiny_r1cs_bellpepper(&mut cs, Some(G::Scalar::from(5)));
+    let mut cs = SatisfyingAssignment::<E>::new();
+    let _ = synthesize_tiny_r1cs_bellpepper(&mut cs, Some(E::Scalar::from(5)));
     let (U1, W1) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
 
     // Make sure that the first instance is satisfiable
     assert!(shape.is_sat(&ck, &U1, &W1).is_ok());
 
     // Now get the instance and assignment for second instance
-    let mut cs = SatisfyingAssignment::<G>::new();
-    let _ = synthesize_tiny_r1cs_bellpepper(&mut cs, Some(G::Scalar::from(135)));
+    let mut cs = SatisfyingAssignment::<E>::new();
+    let _ = synthesize_tiny_r1cs_bellpepper(&mut cs, Some(E::Scalar::from(135)));
     let (U2, W2) = cs.r1cs_instance_and_witness(&shape, &ck).unwrap();
 
     // Make sure that the second instance is satisfiable
@@ -196,7 +190,7 @@ mod tests {
     execute_sequence(
       &ck,
       &ro_consts,
-      &<G as Group>::Scalar::ZERO,
+      &<E as Engine>::Scalar::ZERO,
       &shape,
       &U1,
       &W1,
@@ -207,23 +201,21 @@ mod tests {
 
   #[test]
   fn test_tiny_r1cs_bellpepper() {
-    test_tiny_r1cs_bellpepper_with::<G>();
-
-    test_tiny_r1cs_bellpepper_with::<crate::provider::bn256_grumpkin::bn256::Point>();
+    test_tiny_r1cs_bellpepper_with::<PallasEngine>();
+    test_tiny_r1cs_bellpepper_with::<Bn256Engine>();
+    test_tiny_r1cs_bellpepper_with::<Secp256k1Engine>();
   }
 
-  fn execute_sequence<G>(
-    ck: &CommitmentKey<G>,
-    ro_consts: &<<G as Group>::RO as ROTrait<<G as Group>::Base, <G as Group>::Scalar>>::Constants,
-    pp_digest: &<G as Group>::Scalar,
-    shape: &R1CSShape<G>,
-    U1: &R1CSInstance<G>,
-    W1: &R1CSWitness<G>,
-    U2: &R1CSInstance<G>,
-    W2: &R1CSWitness<G>,
-  ) where
-    G: Group,
-  {
+  fn execute_sequence<E: Engine>(
+    ck: &CommitmentKey<E>,
+    ro_consts: &<<E as Engine>::RO as ROTrait<<E as Engine>::Base, <E as Engine>::Scalar>>::Constants,
+    pp_digest: &<E as Engine>::Scalar,
+    shape: &R1CSShape<E>,
+    U1: &R1CSInstance<E>,
+    W1: &R1CSWitness<E>,
+    U2: &R1CSInstance<E>,
+    W2: &R1CSWitness<E>,
+  ) {
     // produce a default running instance
     let mut r_W = RelaxedR1CSWitness::default(shape);
     let mut r_U = RelaxedR1CSInstance::default(ck, shape);
@@ -264,8 +256,8 @@ mod tests {
     assert!(shape.is_sat_relaxed(ck, &r_U, &r_W).is_ok());
   }
 
-  fn test_tiny_r1cs_with<G: Group>() {
-    let one = <G::Scalar as Field>::ONE;
+  fn test_tiny_r1cs_with<E: Engine>() {
+    let one = <E::Scalar as Field>::ONE;
     let (num_cons, num_vars, num_io, A, B, C) = {
       let num_cons = 4;
       let num_vars = 3;
@@ -282,9 +274,9 @@ mod tests {
       // constraint and a column for every entry in z = (vars, u, inputs)
       // An R1CS instance is satisfiable iff:
       // Az \circ Bz = u \cdot Cz + E, where z = (vars, 1, inputs)
-      let mut A: Vec<(usize, usize, G::Scalar)> = Vec::new();
-      let mut B: Vec<(usize, usize, G::Scalar)> = Vec::new();
-      let mut C: Vec<(usize, usize, G::Scalar)> = Vec::new();
+      let mut A: Vec<(usize, usize, E::Scalar)> = Vec::new();
+      let mut B: Vec<(usize, usize, E::Scalar)> = Vec::new();
+      let mut C: Vec<(usize, usize, E::Scalar)> = Vec::new();
 
       // constraint 0 entries in (A,B,C)
       // `I0 * I0 - Z0 = 0`
@@ -333,13 +325,12 @@ mod tests {
     };
 
     // generate generators and ro constants
-    let ck: <<G as Group>::CE as CommitmentEngineTrait<G>>::CommitmentKey =
-      commitment_key(&S, &*default_ck_hint());
+    let ck = commitment_key(&S, &*default_ck_hint());
     let ro_consts =
-      <<G as Group>::RO as ROTrait<<G as Group>::Base, <G as Group>::Scalar>>::Constants::default();
+      <<E as Engine>::RO as ROTrait<<E as Engine>::Base, <E as Engine>::Scalar>>::Constants::default();
 
     let rand_inst_witness_generator =
-      |ck: &CommitmentKey<G>, I: &G::Scalar| -> (G::Scalar, R1CSInstance<G>, R1CSWitness<G>) {
+      |ck: &CommitmentKey<E>, I: &E::Scalar| -> (E::Scalar, R1CSInstance<E>, R1CSWitness<E>) {
         let i0 = *I;
 
         // compute a satisfying (vars, X) tuple
@@ -374,7 +365,7 @@ mod tests {
       };
 
     let mut csprng: OsRng = OsRng;
-    let I = G::Scalar::random(&mut csprng); // the first input is picked randomly for the first instance
+    let I = E::Scalar::random(&mut csprng); // the first input is picked randomly for the first instance
     let (O, U1, W1) = rand_inst_witness_generator(&ck, &I);
     let (_O, U2, W2) = rand_inst_witness_generator(&ck, &O);
 
@@ -382,7 +373,7 @@ mod tests {
     execute_sequence(
       &ck,
       &ro_consts,
-      &<G as Group>::Scalar::ZERO,
+      &<E as Engine>::Scalar::ZERO,
       &S,
       &U1,
       &W1,
@@ -393,8 +384,8 @@ mod tests {
 
   #[test]
   fn test_tiny_r1cs() {
-    test_tiny_r1cs_with::<pasta_curves::pallas::Point>();
-    test_tiny_r1cs_with::<crate::provider::bn256_grumpkin::bn256::Point>();
-    test_tiny_r1cs_with::<crate::provider::secp_secq::secp256k1::Point>();
+    test_tiny_r1cs_with::<PallasEngine>();
+    test_tiny_r1cs_with::<Bn256Engine>();
+    test_tiny_r1cs_with::<Secp256k1Engine>();
   }
 }
diff --git a/src/provider/bn256_grumpkin.rs b/src/provider/bn256_grumpkin.rs
index fc1eddfe4..d1831bb8d 100644
--- a/src/provider/bn256_grumpkin.rs
+++ b/src/provider/bn256_grumpkin.rs
@@ -6,9 +6,9 @@ use crate::{
     keccak::Keccak256Transcript,
     pedersen::CommitmentEngine,
     poseidon::{PoseidonRO, PoseidonROCircuit},
-    CompressedGroup, GroupExt,
+    CompressedGroup, DlogGroup,
   },
-  traits::{Group, PrimeFieldExt, TranscriptReprTrait},
+  traits::{Engine, Group, PrimeFieldExt, TranscriptReprTrait},
 };
 use digest::{ExtendableOutput, Update};
 use ff::{FromUniformBytes, PrimeField};
@@ -42,7 +42,16 @@ pub mod grumpkin {
   };
 }
 
+/// An implementation of the Nova `Engine` trait with BN254 curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Bn256Engine;
+
+/// An implementation of the Nova `Engine` trait with Grumpkin curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct GrumpkinEngine;
+
 impl_traits!(
+  Bn256Engine,
   bn256,
   Bn256Compressed,
   Bn256Point,
@@ -52,6 +61,7 @@ impl_traits!(
 );
 
 impl_traits!(
+  GrumpkinEngine,
   grumpkin,
   GrumpkinCompressed,
   GrumpkinPoint,
@@ -85,7 +95,7 @@ mod tests {
     for n in [
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1021,
     ] {
-      let ck_par = <G as GroupExt>::from_label(label, n);
+      let ck_par = <G as DlogGroup>::from_label(label, n);
       let ck_ser = from_label_serial(label, n);
       assert_eq!(ck_par.len(), n);
       assert_eq!(ck_ser.len(), n);
diff --git a/src/provider/ipa_pc.rs b/src/provider/ipa_pc.rs
index 3025e162b..07e5eea16 100644
--- a/src/provider/ipa_pc.rs
+++ b/src/provider/ipa_pc.rs
@@ -1,12 +1,12 @@
 //! This module implements `EvaluationEngine` using an IPA-based polynomial commitment scheme
 use crate::{
   errors::NovaError,
-  provider::{pedersen::CommitmentKeyExtTrait, GroupExt},
+  provider::{pedersen::CommitmentKeyExtTrait, DlogGroup},
   spartan::polys::eq::EqPolynomial,
   traits::{
     commitment::{CommitmentEngineTrait, CommitmentTrait},
     evaluation::EvaluationEngineTrait,
-    Group, TranscriptEngineTrait, TranscriptReprTrait,
+    Engine, TranscriptEngineTrait, TranscriptReprTrait,
   },
   Commitment, CommitmentKey, CompressedCommitment, CE,
 };
@@ -21,38 +21,39 @@ use std::marker::PhantomData;
 #[derive(Clone, Debug, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
 #[abomonation_omit_bounds]
-pub struct ProverKey<G: Group> {
-  ck_s: CommitmentKey<G>,
+pub struct ProverKey<E: Engine> {
+  ck_s: CommitmentKey<E>,
 }
 
 /// Provides an implementation of the verifier key
 #[derive(Clone, Debug, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
 #[abomonation_omit_bounds]
-pub struct VerifierKey<G: Group> {
-  ck_v: CommitmentKey<G>,
-  ck_s: CommitmentKey<G>,
+pub struct VerifierKey<E: Engine> {
+  ck_v: CommitmentKey<E>,
+  ck_s: CommitmentKey<E>,
 }
 
 /// Provides an implementation of a polynomial evaluation engine using IPA
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct EvaluationEngine<G: Group> {
-  _p: PhantomData<G>,
+pub struct EvaluationEngine<E: Engine> {
+  _p: PhantomData<E>,
 }
 
-impl<G> EvaluationEngineTrait<G> for EvaluationEngine<G>
+impl<E> EvaluationEngineTrait<E> for EvaluationEngine<E>
 where
-  G: GroupExt,
-  CommitmentKey<G>: CommitmentKeyExtTrait<G>,
+  E: Engine,
+  E::GE: DlogGroup,
+  CommitmentKey<E>: CommitmentKeyExtTrait<E>,
 {
-  type ProverKey = ProverKey<G>;
-  type VerifierKey = VerifierKey<G>;
-  type EvaluationArgument = InnerProductArgument<G>;
+  type ProverKey = ProverKey<E>;
+  type VerifierKey = VerifierKey<E>;
+  type EvaluationArgument = InnerProductArgument<E>;
 
   fn setup(
-    ck: &<<G as Group>::CE as CommitmentEngineTrait<G>>::CommitmentKey,
+    ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey,
   ) -> (Self::ProverKey, Self::VerifierKey) {
-    let ck_c = G::CE::setup(b"ipa", 1);
+    let ck_c = E::CE::setup(b"ipa", 1);
 
     let pk = ProverKey { ck_s: ck_c.clone() };
     let vk = VerifierKey {
@@ -64,13 +65,13 @@ where
   }
 
   fn prove(
-    ck: &CommitmentKey<G>,
+    ck: &CommitmentKey<E>,
     pk: &Self::ProverKey,
-    transcript: &mut G::TE,
-    comm: &Commitment<G>,
-    poly: &[G::Scalar],
-    point: &[G::Scalar],
-    eval: &G::Scalar,
+    transcript: &mut E::TE,
+    comm: &Commitment<E>,
+    poly: &[E::Scalar],
+    point: &[E::Scalar],
+    eval: &E::Scalar,
   ) -> Result<Self::EvaluationArgument, NovaError> {
     let u = InnerProductInstance::new(comm, &EqPolynomial::new(point.to_vec()).evals(), eval);
     let w = InnerProductWitness::new(poly);
@@ -81,10 +82,10 @@ where
   /// A method to verify purported evaluations of a batch of polynomials
   fn verify(
     vk: &Self::VerifierKey,
-    transcript: &mut G::TE,
-    comm: &Commitment<G>,
-    point: &[G::Scalar],
-    eval: &G::Scalar,
+    transcript: &mut E::TE,
+    comm: &Commitment<E>,
+    point: &[E::Scalar],
+    eval: &E::Scalar,
     arg: &Self::EvaluationArgument,
   ) -> Result<(), NovaError> {
     let u = InnerProductInstance::new(comm, &EqPolynomial::new(point.to_vec()).evals(), eval);
@@ -101,10 +102,7 @@ where
   }
 }
 
-fn inner_product<T>(a: &[T], b: &[T]) -> T
-where
-  T: Field + Send + Sync,
-{
+fn inner_product<T: Field + Send + Sync>(a: &[T], b: &[T]) -> T {
   assert_eq!(a.len(), b.len());
   (0..a.len())
     .into_par_iter()
@@ -114,14 +112,18 @@ where
 
 /// An inner product instance consists of a commitment to a vector `a` and another vector `b`
 /// and the claim that c = <a, b>.
-pub struct InnerProductInstance<G: Group> {
-  comm_a_vec: Commitment<G>,
-  b_vec: Vec<G::Scalar>,
-  c: G::Scalar,
+pub struct InnerProductInstance<E: Engine> {
+  comm_a_vec: Commitment<E>,
+  b_vec: Vec<E::Scalar>,
+  c: E::Scalar,
 }
 
-impl<G: Group> InnerProductInstance<G> {
-  fn new(comm_a_vec: &Commitment<G>, b_vec: &[G::Scalar], c: &G::Scalar) -> Self {
+impl<E> InnerProductInstance<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  fn new(comm_a_vec: &Commitment<E>, b_vec: &[E::Scalar], c: &E::Scalar) -> Self {
     InnerProductInstance {
       comm_a_vec: *comm_a_vec,
       b_vec: b_vec.to_vec(),
@@ -130,7 +132,7 @@ impl<G: Group> InnerProductInstance<G> {
   }
 }
 
-impl<G: Group> TranscriptReprTrait<G> for InnerProductInstance<G> {
+impl<E: Engine> TranscriptReprTrait<E::GE> for InnerProductInstance<E> {
   fn to_transcript_bytes(&self) -> Vec<u8> {
     // we do not need to include self.b_vec as in our context it is produced from the transcript
     [
@@ -141,12 +143,12 @@ impl<G: Group> TranscriptReprTrait<G> for InnerProductInstance<G> {
   }
 }
 
-struct InnerProductWitness<G: Group> {
-  a_vec: Vec<G::Scalar>,
+struct InnerProductWitness<E: Engine> {
+  a_vec: Vec<E::Scalar>,
 }
 
-impl<G: Group> InnerProductWitness<G> {
-  fn new(a_vec: &[G::Scalar]) -> Self {
+impl<E: Engine> InnerProductWitness<E> {
+  fn new(a_vec: &[E::Scalar]) -> Self {
     InnerProductWitness {
       a_vec: a_vec.to_vec(),
     }
@@ -156,27 +158,28 @@ impl<G: Group> InnerProductWitness<G> {
 /// An inner product argument
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct InnerProductArgument<G: Group> {
-  L_vec: Vec<CompressedCommitment<G>>,
-  R_vec: Vec<CompressedCommitment<G>>,
-  a_hat: G::Scalar,
+pub struct InnerProductArgument<E: Engine> {
+  L_vec: Vec<CompressedCommitment<E>>,
+  R_vec: Vec<CompressedCommitment<E>>,
+  a_hat: E::Scalar,
 }
 
-impl<G> InnerProductArgument<G>
+impl<E> InnerProductArgument<E>
 where
-  G: GroupExt,
-  CommitmentKey<G>: CommitmentKeyExtTrait<G>,
+  E: Engine,
+  E::GE: DlogGroup,
+  CommitmentKey<E>: CommitmentKeyExtTrait<E>,
 {
   const fn protocol_name() -> &'static [u8] {
     b"IPA"
   }
 
   fn prove(
-    ck: &CommitmentKey<G>,
-    ck_c: &CommitmentKey<G>,
-    U: &InnerProductInstance<G>,
-    W: &InnerProductWitness<G>,
-    transcript: &mut G::TE,
+    ck: &CommitmentKey<E>,
+    ck_c: &CommitmentKey<E>,
+    U: &InnerProductInstance<E>,
+    W: &InnerProductWitness<E>,
+    transcript: &mut E::TE,
   ) -> Result<Self, NovaError> {
     transcript.dom_sep(Self::protocol_name());
 
@@ -194,17 +197,17 @@ where
     let ck_c = ck_c.scale(&r);
 
     // a closure that executes a step of the recursive inner product argument
-    let prove_inner = |a_vec: &[G::Scalar],
-                       b_vec: &[G::Scalar],
-                       ck: &CommitmentKey<G>,
-                       transcript: &mut G::TE|
+    let prove_inner = |a_vec: &[E::Scalar],
+                       b_vec: &[E::Scalar],
+                       ck: &CommitmentKey<E>,
+                       transcript: &mut E::TE|
      -> Result<
       (
-        CompressedCommitment<G>,
-        CompressedCommitment<G>,
-        Vec<G::Scalar>,
-        Vec<G::Scalar>,
-        CommitmentKey<G>,
+        CompressedCommitment<E>,
+        CompressedCommitment<E>,
+        Vec<E::Scalar>,
+        Vec<E::Scalar>,
+        CommitmentKey<E>,
       ),
       NovaError,
     > {
@@ -214,22 +217,22 @@ where
       let c_L = inner_product(&a_vec[0..n / 2], &b_vec[n / 2..n]);
       let c_R = inner_product(&a_vec[n / 2..n], &b_vec[0..n / 2]);
 
-      let L = CE::<G>::commit(
+      let L = CE::<E>::commit(
         &ck_R.combine(&ck_c),
         &a_vec[0..n / 2]
           .iter()
           .chain(iter::once(&c_L))
           .copied()
-          .collect::<Vec<G::Scalar>>(),
+          .collect::<Vec<E::Scalar>>(),
       )
       .compress();
-      let R = CE::<G>::commit(
+      let R = CE::<E>::commit(
         &ck_L.combine(&ck_c),
         &a_vec[n / 2..n]
           .iter()
           .chain(iter::once(&c_R))
           .copied()
-          .collect::<Vec<G::Scalar>>(),
+          .collect::<Vec<E::Scalar>>(),
       )
       .compress();
 
@@ -244,13 +247,13 @@ where
         .par_iter()
         .zip(a_vec[n / 2..n].par_iter())
         .map(|(a_L, a_R)| *a_L * r + r_inverse * *a_R)
-        .collect::<Vec<G::Scalar>>();
+        .collect::<Vec<E::Scalar>>();
 
       let b_vec_folded = b_vec[0..n / 2]
         .par_iter()
         .zip(b_vec[n / 2..n].par_iter())
         .map(|(b_L, b_R)| *b_L * r_inverse + r * *b_R)
-        .collect::<Vec<G::Scalar>>();
+        .collect::<Vec<E::Scalar>>();
 
       let ck_folded = ck.fold(&r_inverse, &r);
 
@@ -258,8 +261,8 @@ where
     };
 
     // two vectors to hold the logarithmic number of group elements
-    let mut L_vec: Vec<CompressedCommitment<G>> = Vec::new();
-    let mut R_vec: Vec<CompressedCommitment<G>> = Vec::new();
+    let mut L_vec: Vec<CompressedCommitment<E>> = Vec::new();
+    let mut R_vec: Vec<CompressedCommitment<E>> = Vec::new();
 
     // we create mutable copies of vectors and generators
     let mut a_vec = W.a_vec.to_vec();
@@ -285,11 +288,11 @@ where
 
   fn verify(
     &self,
-    ck: &CommitmentKey<G>,
-    ck_c: &CommitmentKey<G>,
+    ck: &CommitmentKey<E>,
+    ck_c: &CommitmentKey<E>,
     n: usize,
-    U: &InnerProductInstance<G>,
-    transcript: &mut G::TE,
+    U: &InnerProductInstance<E>,
+    transcript: &mut E::TE,
   ) -> Result<(), NovaError> {
     let (ck, _) = ck.split_at(U.b_vec.len());
 
@@ -309,11 +312,11 @@ where
     let r = transcript.squeeze(b"r")?;
     let ck_c = ck_c.scale(&r);
 
-    let P = U.comm_a_vec + CE::<G>::commit(&ck_c, &[U.c]);
+    let P = U.comm_a_vec + CE::<E>::commit(&ck_c, &[U.c]);
 
-    let batch_invert = |v: &[G::Scalar]| -> Result<Vec<G::Scalar>, NovaError> {
-      let mut products = vec![G::Scalar::ZERO; v.len()];
-      let mut acc = G::Scalar::ONE;
+    let batch_invert = |v: &[E::Scalar]| -> Result<Vec<E::Scalar>, NovaError> {
+      let mut products = vec![E::Scalar::ZERO; v.len()];
+      let mut acc = E::Scalar::ONE;
 
       for i in 0..v.len() {
         products[i] = acc;
@@ -327,7 +330,7 @@ where
       };
 
       // compute the inverse once for all entries
-      let mut inv = vec![G::Scalar::ZERO; v.len()];
+      let mut inv = vec![E::Scalar::ZERO; v.len()];
       for i in (0..v.len()).rev() {
         let tmp = acc * v[i];
         inv[i] = products[i] * acc;
@@ -344,24 +347,24 @@ where
         transcript.absorb(b"R", &self.R_vec[i]);
         transcript.squeeze(b"r")
       })
-      .collect::<Result<Vec<G::Scalar>, NovaError>>()?;
+      .collect::<Result<Vec<E::Scalar>, NovaError>>()?;
 
     // precompute scalars necessary for verification
-    let r_square: Vec<G::Scalar> = (0..self.L_vec.len())
+    let r_square: Vec<E::Scalar> = (0..self.L_vec.len())
       .into_par_iter()
       .map(|i| r[i] * r[i])
       .collect();
     let r_inverse = batch_invert(&r)?;
-    let r_inverse_square: Vec<G::Scalar> = (0..self.L_vec.len())
+    let r_inverse_square: Vec<E::Scalar> = (0..self.L_vec.len())
       .into_par_iter()
       .map(|i| r_inverse[i] * r_inverse[i])
       .collect();
 
     // compute the vector with the tensor structure
     let s = {
-      let mut s = vec![G::Scalar::ZERO; n];
+      let mut s = vec![E::Scalar::ZERO; n];
       s[0] = {
-        let mut v = G::Scalar::ONE;
+        let mut v = E::Scalar::ONE;
         for r_inverse_i in r_inverse {
           v *= r_inverse_i;
         }
@@ -375,32 +378,32 @@ where
     };
 
     let ck_hat = {
-      let c = CE::<G>::commit(&ck, &s).compress();
-      CommitmentKey::<G>::reinterpret_commitments_as_ck(&[c])?
+      let c = CE::<E>::commit(&ck, &s).compress();
+      CommitmentKey::<E>::reinterpret_commitments_as_ck(&[c])?
     };
 
     let b_hat = inner_product(&U.b_vec, &s);
 
     let P_hat = {
       let ck_folded = {
-        let ck_L = CommitmentKey::<G>::reinterpret_commitments_as_ck(&self.L_vec)?;
-        let ck_R = CommitmentKey::<G>::reinterpret_commitments_as_ck(&self.R_vec)?;
-        let ck_P = CommitmentKey::<G>::reinterpret_commitments_as_ck(&[P.compress()])?;
+        let ck_L = CommitmentKey::<E>::reinterpret_commitments_as_ck(&self.L_vec)?;
+        let ck_R = CommitmentKey::<E>::reinterpret_commitments_as_ck(&self.R_vec)?;
+        let ck_P = CommitmentKey::<E>::reinterpret_commitments_as_ck(&[P.compress()])?;
         ck_L.combine(&ck_R).combine(&ck_P)
       };
 
-      CE::<G>::commit(
+      CE::<E>::commit(
         &ck_folded,
         &r_square
           .iter()
           .chain(r_inverse_square.iter())
-          .chain(iter::once(&G::Scalar::ONE))
+          .chain(iter::once(&E::Scalar::ONE))
           .copied()
-          .collect::<Vec<G::Scalar>>(),
+          .collect::<Vec<E::Scalar>>(),
       )
     };
 
-    if P_hat == CE::<G>::commit(&ck_hat.combine(&ck_c), &[self.a_hat, self.a_hat * b_hat]) {
+    if P_hat == CE::<E>::commit(&ck_hat.combine(&ck_c), &[self.a_hat, self.a_hat * b_hat]) {
       Ok(())
     } else {
       Err(NovaError::InvalidIPA)
diff --git a/src/provider/keccak.rs b/src/provider/keccak.rs
index 26139eb91..0cc06217c 100644
--- a/src/provider/keccak.rs
+++ b/src/provider/keccak.rs
@@ -2,7 +2,7 @@
 use crate::traits::PrimeFieldExt;
 use crate::{
   errors::NovaError,
-  traits::{Group, TranscriptEngineTrait, TranscriptReprTrait},
+  traits::{Engine, TranscriptEngineTrait, TranscriptReprTrait},
 };
 use core::marker::PhantomData;
 use sha3::{Digest, Keccak256};
@@ -15,11 +15,11 @@ const KECCAK256_PREFIX_CHALLENGE_HI: u8 = 1;
 
 /// Provides an implementation of `TranscriptEngine`
 #[derive(Debug, Clone)]
-pub struct Keccak256Transcript<G: Group> {
+pub struct Keccak256Transcript<E: Engine> {
   round: u16,
   state: [u8; KECCAK256_STATE_SIZE],
   transcript: Keccak256,
-  _p: PhantomData<G>,
+  _p: PhantomData<E>,
 }
 
 fn compute_updated_state(keccak_instance: Keccak256, input: &[u8]) -> [u8; KECCAK256_STATE_SIZE] {
@@ -45,7 +45,7 @@ fn compute_updated_state(keccak_instance: Keccak256, input: &[u8]) -> [u8; KECCA
     .unwrap()
 }
 
-impl<G: Group> TranscriptEngineTrait<G> for Keccak256Transcript<G> {
+impl<E: Engine> TranscriptEngineTrait<E> for Keccak256Transcript<E> {
   fn new(label: &'static [u8]) -> Self {
     let keccak_instance = Keccak256::new();
     let input = [PERSONA_TAG, label].concat();
@@ -59,7 +59,7 @@ impl<G: Group> TranscriptEngineTrait<G> for Keccak256Transcript<G> {
     }
   }
 
-  fn squeeze(&mut self, label: &'static [u8]) -> Result<G::Scalar, NovaError> {
+  fn squeeze(&mut self, label: &'static [u8]) -> Result<E::Scalar, NovaError> {
     // we gather the full input from the round, preceded by the current state of the transcript
     let input = [
       DOM_SEP_TAG,
@@ -82,10 +82,10 @@ impl<G: Group> TranscriptEngineTrait<G> for Keccak256Transcript<G> {
     self.transcript = Keccak256::new();
 
     // squeeze out a challenge
-    Ok(G::Scalar::from_uniform(&output))
+    Ok(E::Scalar::from_uniform(&output))
   }
 
-  fn absorb<T: TranscriptReprTrait<G>>(&mut self, label: &'static [u8], o: &T) {
+  fn absorb<T: TranscriptReprTrait<E::GE>>(&mut self, label: &'static [u8], o: &T) {
     self.transcript.update(label);
     self.transcript.update(&o.to_transcript_bytes());
   }
@@ -99,53 +99,57 @@ impl<G: Group> TranscriptEngineTrait<G> for Keccak256Transcript<G> {
 #[cfg(test)]
 mod tests {
   use crate::{
-    provider::bn256_grumpkin::bn256,
-    provider::{self, keccak::Keccak256Transcript, secp_secq},
-    traits::{Group, PrimeFieldExt, TranscriptEngineTrait, TranscriptReprTrait},
+    provider::keccak::Keccak256Transcript,
+    provider::{
+      bn256_grumpkin::{Bn256Engine, GrumpkinEngine},
+      pasta::{PallasEngine, VestaEngine},
+      secp_secq::{Secp256k1Engine, Secq256k1Engine},
+    },
+    traits::{Engine, PrimeFieldExt, TranscriptEngineTrait, TranscriptReprTrait},
   };
   use ff::PrimeField;
   use rand::Rng;
   use sha3::{Digest, Keccak256};
 
-  fn test_keccak_transcript_with<G: Group>(expected_h1: &'static str, expected_h2: &'static str) {
-    let mut transcript: Keccak256Transcript<G> = Keccak256Transcript::new(b"test");
+  fn test_keccak_transcript_with<E: Engine>(expected_h1: &'static str, expected_h2: &'static str) {
+    let mut transcript: Keccak256Transcript<E> = Keccak256Transcript::new(b"test");
 
     // two scalars
-    let s1 = <G as Group>::Scalar::from(2u64);
-    let s2 = <G as Group>::Scalar::from(5u64);
+    let s1 = <E as Engine>::Scalar::from(2u64);
+    let s2 = <E as Engine>::Scalar::from(5u64);
 
     // add the scalars to the transcript
     transcript.absorb(b"s1", &s1);
     transcript.absorb(b"s2", &s2);
 
     // make a challenge
-    let c1: <G as Group>::Scalar = transcript.squeeze(b"c1").unwrap();
+    let c1: <E as Engine>::Scalar = transcript.squeeze(b"c1").unwrap();
     assert_eq!(hex::encode(c1.to_repr().as_ref()), expected_h1);
 
     // a scalar
-    let s3 = <G as Group>::Scalar::from(128u64);
+    let s3 = <E as Engine>::Scalar::from(128u64);
 
     // add the scalar to the transcript
     transcript.absorb(b"s3", &s3);
 
     // make a challenge
-    let c2: <G as Group>::Scalar = transcript.squeeze(b"c2").unwrap();
+    let c2: <E as Engine>::Scalar = transcript.squeeze(b"c2").unwrap();
     assert_eq!(hex::encode(c2.to_repr().as_ref()), expected_h2);
   }
 
   #[test]
   fn test_keccak_transcript() {
-    test_keccak_transcript_with::<pasta_curves::pallas::Point>(
+    test_keccak_transcript_with::<PallasEngine>(
       "5ddffa8dc091862132788b8976af88b9a2c70594727e611c7217ba4c30c8c70a",
       "4d4bf42c065870395749fa1c4fb641df1e0d53f05309b03d5b1db7f0be3aa13d",
     );
 
-    test_keccak_transcript_with::<bn256::Point>(
+    test_keccak_transcript_with::<Bn256Engine>(
       "9fb71e3b74bfd0b60d97349849b895595779a240b92a6fae86bd2812692b6b0e",
       "bfd4c50b7d6317e9267d5d65c985eb455a3561129c0b3beef79bfc8461a84f18",
     );
 
-    test_keccak_transcript_with::<provider::secp_secq::secp256k1::Point>(
+    test_keccak_transcript_with::<Secp256k1Engine>(
       "9723aafb69ec8f0e9c7de756df0993247d98cf2b2f72fa353e3de654a177e310",
       "a6a90fcb6e1b1a2a2f84c950ef1510d369aea8e42085f5c629bfa66d00255f25",
     );
@@ -206,13 +210,13 @@ mod tests {
 
   // This test is meant to ensure compatibility between the incremental way of computing the transcript above, and
   // the former, which materialized the entirety of the input vector before calling Keccak256 on it.
-  fn test_keccak_transcript_incremental_vs_explicit_with<G: Group>() {
+  fn test_keccak_transcript_incremental_vs_explicit_with<E: Engine>() {
     let test_label = b"test";
-    let mut transcript: Keccak256Transcript<G> = Keccak256Transcript::new(test_label);
+    let mut transcript: Keccak256Transcript<E> = Keccak256Transcript::new(test_label);
     let mut rng = rand::thread_rng();
 
     // ten scalars
-    let scalars = std::iter::from_fn(|| Some(<G as Group>::Scalar::from(rng.gen::<u64>())))
+    let scalars = std::iter::from_fn(|| Some(<E as Engine>::Scalar::from(rng.gen::<u64>())))
       .take(10)
       .collect::<Vec<_>>();
 
@@ -233,18 +237,20 @@ mod tests {
     let initial_state = compute_updated_state_for_testing(&input);
 
     // make a challenge
-    let c1: <G as Group>::Scalar = transcript.squeeze(b"c1").unwrap();
+    let c1: <E as Engine>::Scalar = transcript.squeeze(b"c1").unwrap();
 
     let c1_bytes = squeeze_for_testing(&manual_transcript[..], 0u16, initial_state, b"c1");
-    let to_hex = |g: G::Scalar| hex::encode(g.to_repr().as_ref());
-    assert_eq!(to_hex(c1), to_hex(G::Scalar::from_uniform(&c1_bytes)));
+    let to_hex = |g: E::Scalar| hex::encode(g.to_repr().as_ref());
+    assert_eq!(to_hex(c1), to_hex(E::Scalar::from_uniform(&c1_bytes)));
   }
 
   #[test]
   fn test_keccak_transcript_incremental_vs_explicit() {
-    test_keccak_transcript_incremental_vs_explicit_with::<pasta_curves::pallas::Point>();
-    test_keccak_transcript_incremental_vs_explicit_with::<bn256::Point>();
-    test_keccak_transcript_incremental_vs_explicit_with::<secp_secq::secp256k1::Point>();
-    test_keccak_transcript_incremental_vs_explicit_with::<secp_secq::secq256k1::Point>();
+    test_keccak_transcript_incremental_vs_explicit_with::<PallasEngine>();
+    test_keccak_transcript_incremental_vs_explicit_with::<VestaEngine>();
+    test_keccak_transcript_incremental_vs_explicit_with::<Bn256Engine>();
+    test_keccak_transcript_incremental_vs_explicit_with::<GrumpkinEngine>();
+    test_keccak_transcript_incremental_vs_explicit_with::<Secp256k1Engine>();
+    test_keccak_transcript_incremental_vs_explicit_with::<Secq256k1Engine>();
   }
 }
diff --git a/src/provider/mod.rs b/src/provider/mod.rs
index b27e35deb..fa4b9e07b 100644
--- a/src/provider/mod.rs
+++ b/src/provider/mod.rs
@@ -1,6 +1,6 @@
 //! This module implements Nova's traits using the following configuration:
 //! `CommitmentEngine` with Pedersen's commitments
-//! `Group` with pasta curves and BN256/Grumpkin
+//! `Engine` with pasta curves and BN256/Grumpkin
 //! `RO` traits with Poseidon
 //! `EvaluationEngine` with an IPA-based polynomial evaluation argument
 use crate::traits::{commitment::ScalarMul, Group, TranscriptReprTrait};
@@ -24,7 +24,7 @@ pub trait CompressedGroup:
   + 'static
 {
   /// A type that holds the decompressed version of the compressed group element
-  type GroupElement: Group;
+  type GroupElement: DlogGroup;
 
   /// Decompresses the compressed group element
   fn decompress(&self) -> Option<Self::GroupElement>;
@@ -50,7 +50,7 @@ pub trait ScalarMulOwned<Rhs, Output = Self>: for<'r> ScalarMul<&'r Rhs, Output>
 impl<T, Rhs, Output> ScalarMulOwned<Rhs, Output> for T where T: for<'r> ScalarMul<&'r Rhs, Output> {}
 
 /// A trait that defines extensions to the Group trait
-pub trait GroupExt:
+pub trait DlogGroup:
   Group
   + Serialize
   + for<'de> Deserialize<'de>
@@ -91,7 +91,7 @@ pub trait GroupExt:
   fn zero() -> Self;
 
   /// Returns the affine coordinates (x, y, infinty) for the point
-  fn to_coordinates(&self) -> (Self::Base, Self::Base, bool);
+  fn to_coordinates(&self) -> (<Self as Group>::Base, <Self as Group>::Base, bool);
 }
 
 pub mod bn256_grumpkin;
@@ -221,6 +221,7 @@ pub(crate) fn cpu_best_multiexp<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C
 #[macro_export]
 macro_rules! impl_traits {
   (
+    $engine:ident,
     $name:ident,
     $name_compressed:ident,
     $name_curve:ident,
@@ -228,15 +229,21 @@ macro_rules! impl_traits {
     $order_str:literal,
     $base_str:literal
   ) => {
-    impl Group for $name::Point {
+    impl Engine for $engine {
       type Base = $name::Base;
       type Scalar = $name::Scalar;
+      type GE = $name::Point;
       type RO = PoseidonRO<Self::Base, Self::Scalar>;
       type ROCircuit = PoseidonROCircuit<Self::Base>;
       type TE = Keccak256Transcript<Self>;
       type CE = CommitmentEngine<Self>;
+    }
+
+    impl Group for $name::Point {
+      type Base = $name::Base;
+      type Scalar = $name::Scalar;
 
-      fn get_curve_params() -> (Self::Base, Self::Base, BigInt, BigInt) {
+      fn group_params() -> (Self::Base, Self::Base, BigInt, BigInt) {
         let A = $name::Point::a();
         let B = $name::Point::b();
         let order = BigInt::from_str_radix($order_str, 16).unwrap();
@@ -246,7 +253,7 @@ macro_rules! impl_traits {
       }
     }
 
-    impl GroupExt for $name::Point {
+    impl DlogGroup for $name::Point {
       type CompressedGroupElement = $name_compressed;
       type PreprocessedGroupElement = $name::Affine;
 
@@ -335,7 +342,7 @@ macro_rules! impl_traits {
       }
     }
 
-    impl<G: Group> TranscriptReprTrait<G> for $name_compressed {
+    impl<G: DlogGroup> TranscriptReprTrait<G> for $name_compressed {
       fn to_transcript_bytes(&self) -> Vec<u8> {
         self.as_ref().to_vec()
       }
diff --git a/src/provider/pasta.rs b/src/provider/pasta.rs
index dc1663f59..0cb0cb5ae 100644
--- a/src/provider/pasta.rs
+++ b/src/provider/pasta.rs
@@ -5,9 +5,9 @@ use crate::{
     keccak::Keccak256Transcript,
     pedersen::CommitmentEngine,
     poseidon::{PoseidonRO, PoseidonROCircuit},
-    CompressedGroup, GroupExt,
+    CompressedGroup, DlogGroup,
   },
-  traits::{Group, PrimeFieldExt, TranscriptReprTrait},
+  traits::{Engine, Group, PrimeFieldExt, TranscriptReprTrait},
 };
 use digest::{ExtendableOutput, Update};
 use ff::{FromUniformBytes, PrimeField};
@@ -50,8 +50,17 @@ impl VestaCompressedElementWrapper {
   }
 }
 
+/// An implementation of the Nova `Engine` trait with Pallas curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PallasEngine;
+
+/// An implementation of the Nova `Engine` trait with Vesta curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct VestaEngine;
+
 macro_rules! impl_traits {
   (
+    $engine:ident,
     $name:ident,
     $name_compressed:ident,
     $name_curve:ident,
@@ -59,15 +68,21 @@ macro_rules! impl_traits {
     $order_str:literal,
     $base_str:literal
   ) => {
-    impl Group for $name::Point {
+    impl Engine for $engine {
       type Base = $name::Base;
       type Scalar = $name::Scalar;
+      type GE = $name::Point;
       type RO = PoseidonRO<Self::Base, Self::Scalar>;
       type ROCircuit = PoseidonROCircuit<Self::Base>;
       type TE = Keccak256Transcript<Self>;
       type CE = CommitmentEngine<Self>;
+    }
+
+    impl Group for $name::Point {
+      type Base = $name::Base;
+      type Scalar = $name::Scalar;
 
-      fn get_curve_params() -> (Self::Base, Self::Base, BigInt, BigInt) {
+      fn group_params() -> (Self::Base, Self::Base, BigInt, BigInt) {
         let A = $name::Point::a();
         let B = $name::Point::b();
         let order = BigInt::from_str_radix($order_str, 16).unwrap();
@@ -77,7 +92,7 @@ macro_rules! impl_traits {
       }
     }
 
-    impl GroupExt for $name::Point {
+    impl DlogGroup for $name::Point {
       type CompressedGroupElement = $name_compressed;
       type PreprocessedGroupElement = $name::Affine;
 
@@ -181,7 +196,7 @@ macro_rules! impl_traits {
       }
     }
 
-    impl<G: Group> TranscriptReprTrait<G> for $name_compressed {
+    impl<G: DlogGroup> TranscriptReprTrait<G> for $name_compressed {
       fn to_transcript_bytes(&self) -> Vec<u8> {
         self.repr.to_vec()
       }
@@ -204,6 +219,7 @@ macro_rules! impl_traits {
 }
 
 impl_traits!(
+  PallasEngine,
   pallas,
   PallasCompressedElementWrapper,
   Ep,
@@ -213,6 +229,7 @@ impl_traits!(
 );
 
 impl_traits!(
+  VestaEngine,
   vesta,
   VestaCompressedElementWrapper,
   Eq,
@@ -224,7 +241,7 @@ impl_traits!(
 #[cfg(test)]
 mod tests {
   use super::*;
-  type G = pasta_curves::pallas::Point;
+  type G = <PallasEngine as Engine>::GE;
 
   fn from_label_serial(label: &'static [u8], n: usize) -> Vec<EpAffine> {
     let mut shake = Shake256::default();
@@ -246,7 +263,7 @@ mod tests {
     for n in [
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1021,
     ] {
-      let ck_par = <G as GroupExt>::from_label(label, n);
+      let ck_par = <G as DlogGroup>::from_label(label, n);
       let ck_ser = from_label_serial(label, n);
       assert_eq!(ck_par.len(), n);
       assert_eq!(ck_ser.len(), n);
diff --git a/src/provider/pedersen.rs b/src/provider/pedersen.rs
index d22f50609..acf3928d5 100644
--- a/src/provider/pedersen.rs
+++ b/src/provider/pedersen.rs
@@ -1,17 +1,17 @@
 //! This module provides an implementation of a commitment engine
 use crate::{
   errors::NovaError,
-  provider::{CompressedGroup, GroupExt},
+  provider::{CompressedGroup, DlogGroup},
   traits::{
     commitment::{CommitmentEngineTrait, CommitmentTrait, Len},
-    AbsorbInROTrait, Group, ROTrait, TranscriptReprTrait,
+    AbsorbInROTrait, Engine, ROTrait, TranscriptReprTrait,
   },
 };
 use abomonation_derive::Abomonation;
 use core::{
   fmt::Debug,
   marker::PhantomData,
-  ops::{Add, AddAssign, Mul, MulAssign},
+  ops::{Add, Mul, MulAssign},
 };
 use ff::Field;
 use rayon::prelude::*;
@@ -20,13 +20,21 @@ use serde::{Deserialize, Serialize};
 /// A type that holds commitment generators
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Abomonation)]
 #[abomonation_omit_bounds]
-pub struct CommitmentKey<G: GroupExt> {
+pub struct CommitmentKey<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   #[abomonate_with(Vec<[u64; 8]>)] // this is a hack; we just assume the size of the element.
-  ck: Vec<G::PreprocessedGroupElement>,
+  ck: Vec<<E::GE as DlogGroup>::PreprocessedGroupElement>,
 }
 
 /// [CommitmentKey]s are often large, and this helps with cloning bottlenecks
-impl<G: GroupExt> Clone for CommitmentKey<G> {
+impl<E> Clone for CommitmentKey<E> 
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   fn clone(&self) -> Self {
     Self {
       ck: self.ck.par_iter().cloned().collect(),
@@ -34,7 +42,11 @@ impl<G: GroupExt> Clone for CommitmentKey<G> {
   }
 }
 
-impl<G: GroupExt> Len for CommitmentKey<G> {
+impl<E> Len for CommitmentKey<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   fn length(&self) -> usize {
     self.ck.len()
   }
@@ -44,20 +56,28 @@ impl<G: GroupExt> Len for CommitmentKey<G> {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
 #[abomonation_omit_bounds]
-pub struct Commitment<G: GroupExt> {
+pub struct Commitment<E: Engine> {
   #[abomonate_with(Vec<[u64; 12]>)] // this is a hack; we just assume the size of the element.
-  pub(crate) comm: G,
+  pub(crate) comm: E::GE,
 }
 
 /// A type that holds a compressed commitment
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct CompressedCommitment<G: GroupExt> {
-  comm: G::CompressedGroupElement,
+pub struct CompressedCommitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  comm: <E::GE as DlogGroup>::CompressedGroupElement,
 }
 
-impl<G: GroupExt> CommitmentTrait<G> for Commitment<G> {
-  type CompressedCommitment = CompressedCommitment<G>;
+impl<E> CommitmentTrait<E> for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  type CompressedCommitment = CompressedCommitment<E>;
 
   fn compress(&self) -> Self::CompressedCommitment {
     CompressedCommitment {
@@ -65,12 +85,12 @@ impl<G: GroupExt> CommitmentTrait<G> for Commitment<G> {
     }
   }
 
-  fn to_coordinates(&self) -> (G::Base, G::Base, bool) {
+  fn to_coordinates(&self) -> (E::Base, E::Base, bool) {
     self.comm.to_coordinates()
   }
 
   fn decompress(c: &Self::CompressedCommitment) -> Result<Self, NovaError> {
-    let comm = <G as GroupExt>::CompressedGroupElement::decompress(&c.comm);
+    let comm = <<E as Engine>::GE as DlogGroup>::CompressedGroupElement::decompress(&c.comm);
     if comm.is_none() {
       return Err(NovaError::DecompressionError);
     }
@@ -80,13 +100,23 @@ impl<G: GroupExt> CommitmentTrait<G> for Commitment<G> {
   }
 }
 
-impl<G: GroupExt> Default for Commitment<G> {
+impl<E: Engine> Default for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   fn default() -> Self {
-    Commitment { comm: G::zero() }
+    Commitment {
+      comm: E::GE::zero(),
+    }
   }
 }
 
-impl<G: GroupExt> TranscriptReprTrait<G> for Commitment<G> {
+impl<E> TranscriptReprTrait<E::GE> for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   fn to_transcript_bytes(&self) -> Vec<u8> {
     let (x, y, is_infinity) = self.comm.to_coordinates();
     let is_infinity_byte = (!is_infinity).into();
@@ -99,131 +129,120 @@ impl<G: GroupExt> TranscriptReprTrait<G> for Commitment<G> {
   }
 }
 
-impl<G: GroupExt> AbsorbInROTrait<G> for Commitment<G> {
-  fn absorb_in_ro(&self, ro: &mut G::RO) {
+impl<E> AbsorbInROTrait<E> for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  fn absorb_in_ro(&self, ro: &mut E::RO) {
     let (x, y, is_infinity) = self.comm.to_coordinates();
     ro.absorb(x);
     ro.absorb(y);
     ro.absorb(if is_infinity {
-      G::Base::ONE
+      E::Base::ONE
     } else {
-      G::Base::ZERO
+      E::Base::ZERO
     });
   }
 }
 
-impl<G: GroupExt> TranscriptReprTrait<G> for CompressedCommitment<G> {
+impl<E> TranscriptReprTrait<E::GE> for CompressedCommitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   fn to_transcript_bytes(&self) -> Vec<u8> {
     self.comm.to_transcript_bytes()
   }
 }
 
-impl<G: GroupExt> MulAssign<G::Scalar> for Commitment<G> {
-  fn mul_assign(&mut self, scalar: G::Scalar) {
-    let result = (self as &Commitment<G>).comm * scalar;
-    *self = Commitment { comm: result };
+impl<E> MulAssign<E::Scalar> for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  fn mul_assign(&mut self, scalar: E::Scalar) {
+    *self = Commitment {
+      comm: self.comm * scalar,
+    };
   }
 }
 
-impl<'a, 'b, G: GroupExt> Mul<&'b G::Scalar> for &'a Commitment<G> {
-  type Output = Commitment<G>;
-  fn mul(self, scalar: &'b G::Scalar) -> Commitment<G> {
+impl<'a, 'b, E> Mul<&'b E::Scalar> for &'a Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  type Output = Commitment<E>;
+  fn mul(self, scalar: &'b E::Scalar) -> Commitment<E> {
     Commitment {
       comm: self.comm * scalar,
     }
   }
 }
 
-impl<G: GroupExt> Mul<G::Scalar> for Commitment<G> {
-  type Output = Commitment<G>;
+impl<E> Mul<E::Scalar> for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  type Output = Commitment<E>;
 
-  fn mul(self, scalar: G::Scalar) -> Commitment<G> {
+  fn mul(self, scalar: E::Scalar) -> Commitment<E> {
     Commitment {
       comm: self.comm * scalar,
     }
   }
 }
 
-impl<'b, G: GroupExt> AddAssign<&'b Commitment<G>> for Commitment<G> {
-  fn add_assign(&mut self, other: &'b Commitment<G>) {
-    let result = (self as &Commitment<G>).comm + other.comm;
-    *self = Commitment { comm: result };
-  }
-}
+impl<E> Add for Commitment<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  type Output = Commitment<E>;
 
-impl<'a, 'b, G: GroupExt> Add<&'b Commitment<G>> for &'a Commitment<G> {
-  type Output = Commitment<G>;
-  fn add(self, other: &'b Commitment<G>) -> Commitment<G> {
+  fn add(self, other: Commitment<E>) -> Commitment<E> {
     Commitment {
       comm: self.comm + other.comm,
     }
   }
 }
 
-macro_rules! define_add_variants {
-  (G = $g:path, LHS = $lhs:ty, RHS = $rhs:ty, Output = $out:ty) => {
-    impl<'b, G: $g> Add<&'b $rhs> for $lhs {
-      type Output = $out;
-      fn add(self, rhs: &'b $rhs) -> $out {
-        &self + rhs
-      }
-    }
-
-    impl<'a, G: $g> Add<$rhs> for &'a $lhs {
-      type Output = $out;
-      fn add(self, rhs: $rhs) -> $out {
-        self + &rhs
-      }
-    }
-
-    impl<G: $g> Add<$rhs> for $lhs {
-      type Output = $out;
-      fn add(self, rhs: $rhs) -> $out {
-        &self + &rhs
-      }
-    }
-  };
-}
-
-macro_rules! define_add_assign_variants {
-  (G = $g:path, LHS = $lhs:ty, RHS = $rhs:ty) => {
-    impl<G: $g> AddAssign<$rhs> for $lhs {
-      fn add_assign(&mut self, rhs: $rhs) {
-        *self += &rhs;
-      }
-    }
-  };
-}
-
-define_add_assign_variants!(G = GroupExt, LHS = Commitment<G>, RHS = Commitment<G>);
-define_add_variants!(G = GroupExt, LHS = Commitment<G>, RHS = Commitment<G>, Output = Commitment<G>);
-
 /// Provides a commitment engine
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CommitmentEngine<G: GroupExt> {
-  _p: PhantomData<G>,
+pub struct CommitmentEngine<E: Engine> {
+  _p: PhantomData<E>,
 }
 
-impl<G: GroupExt> CommitmentEngineTrait<G> for CommitmentEngine<G> {
-  type CommitmentKey = CommitmentKey<G>;
-  type Commitment = Commitment<G>;
+impl<E> CommitmentEngineTrait<E> for CommitmentEngine<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
+  type CommitmentKey = CommitmentKey<E>;
+  type Commitment = Commitment<E>;
 
   fn setup(label: &'static [u8], n: usize) -> Self::CommitmentKey {
     Self::CommitmentKey {
-      ck: G::from_label(label, n.next_power_of_two()),
+      ck: E::GE::from_label(label, n.next_power_of_two()),
     }
   }
 
-  fn commit(ck: &Self::CommitmentKey, v: &[G::Scalar]) -> Self::Commitment {
+  fn commit(ck: &Self::CommitmentKey, v: &[E::Scalar]) -> Self::Commitment {
     assert!(ck.ck.len() >= v.len());
     Commitment {
-      comm: G::vartime_multiscalar_mul(v, &ck.ck[..v.len()]),
+      comm: E::GE::vartime_multiscalar_mul(v, &ck.ck[..v.len()]),
     }
   }
 }
 
 /// A trait listing properties of a commitment key that can be managed in a divide-and-conquer fashion
-pub trait CommitmentKeyExtTrait<G: GroupExt> {
+pub trait CommitmentKeyExtTrait<E>
+where
+  E: Engine,
+  E::GE: DlogGroup,
+{
   /// Splits the commitment key into two pieces at a specified point
   fn split_at(&self, n: usize) -> (Self, Self)
   where
@@ -233,21 +252,25 @@ pub trait CommitmentKeyExtTrait<G: GroupExt> {
   fn combine(&self, other: &Self) -> Self;
 
   /// Folds the two commitment keys into one using the provided weights
-  fn fold(&self, w1: &G::Scalar, w2: &G::Scalar) -> Self;
+  fn fold(&self, w1: &E::Scalar, w2: &E::Scalar) -> Self;
 
   /// Scales the commitment key using the provided scalar
-  fn scale(&self, r: &G::Scalar) -> Self;
+  fn scale(&self, r: &E::Scalar) -> Self;
 
   /// Reinterprets commitments as commitment keys
   fn reinterpret_commitments_as_ck(
-    c: &[<<<G as Group>::CE as CommitmentEngineTrait<G>>::Commitment as CommitmentTrait<G>>::CompressedCommitment],
+    c: &[<<<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment as CommitmentTrait<E>>::CompressedCommitment],
   ) -> Result<Self, NovaError>
   where
     Self: Sized;
 }
 
-impl<G: Group<CE = CommitmentEngine<G>> + GroupExt> CommitmentKeyExtTrait<G> for CommitmentKey<G> {
-  fn split_at(&self, n: usize) -> (CommitmentKey<G>, CommitmentKey<G>) {
+impl<E> CommitmentKeyExtTrait<E> for CommitmentKey<E>
+where
+  E: Engine<CE = CommitmentEngine<E>>,
+  E::GE: DlogGroup,
+{
+  fn split_at(&self, n: usize) -> (CommitmentKey<E>, CommitmentKey<E>) {
     (
       CommitmentKey {
         ck: self.ck[0..n].to_vec(),
@@ -258,7 +281,7 @@ impl<G: Group<CE = CommitmentEngine<G>> + GroupExt> CommitmentKeyExtTrait<G> for
     )
   }
 
-  fn combine(&self, other: &CommitmentKey<G>) -> CommitmentKey<G> {
+  fn combine(&self, other: &CommitmentKey<E>) -> CommitmentKey<E> {
     let ck = {
       let mut c = self.ck.clone();
       c.extend(other.ck.clone());
@@ -268,7 +291,7 @@ impl<G: Group<CE = CommitmentEngine<G>> + GroupExt> CommitmentKeyExtTrait<G> for
   }
 
   // combines the left and right halves of `self` using `w1` and `w2` as the weights
-  fn fold(&self, w1: &G::Scalar, w2: &G::Scalar) -> CommitmentKey<G> {
+  fn fold(&self, w1: &E::Scalar, w2: &E::Scalar) -> CommitmentKey<E> {
     let w = vec![*w1, *w2];
     let (L, R) = self.split_at(self.ck.len() / 2);
 
@@ -276,7 +299,7 @@ impl<G: Group<CE = CommitmentEngine<G>> + GroupExt> CommitmentKeyExtTrait<G> for
       .into_par_iter()
       .map(|i| {
         let bases = [L.ck[i].clone(), R.ck[i].clone()].to_vec();
-        G::vartime_multiscalar_mul(&w, &bases).preprocessed()
+        E::GE::vartime_multiscalar_mul(&w, &bases).preprocessed()
       })
       .collect();
 
@@ -284,23 +307,23 @@ impl<G: Group<CE = CommitmentEngine<G>> + GroupExt> CommitmentKeyExtTrait<G> for
   }
 
   /// Scales each element in `self` by `r`
-  fn scale(&self, r: &G::Scalar) -> Self {
+  fn scale(&self, r: &E::Scalar) -> Self {
     let ck_scaled = self
       .ck
       .clone()
       .into_par_iter()
-      .map(|g| G::vartime_multiscalar_mul(&[*r], &[g]).preprocessed())
+      .map(|g| E::GE::vartime_multiscalar_mul(&[*r], &[g]).preprocessed())
       .collect();
 
     CommitmentKey { ck: ck_scaled }
   }
 
   /// reinterprets a vector of commitments as a set of generators
-  fn reinterpret_commitments_as_ck(c: &[CompressedCommitment<G>]) -> Result<Self, NovaError> {
+  fn reinterpret_commitments_as_ck(c: &[CompressedCommitment<E>]) -> Result<Self, NovaError> {
     let d = (0..c.len())
       .into_par_iter()
-      .map(|i| Commitment::<G>::decompress(&c[i]))
-      .collect::<Result<Vec<Commitment<G>>, NovaError>>()?;
+      .map(|i| Commitment::<E>::decompress(&c[i]))
+      .collect::<Result<Vec<Commitment<E>>, NovaError>>()?;
     let ck = (0..d.len())
       .into_par_iter()
       .map(|i| d[i].comm.preprocessed())
diff --git a/src/provider/poseidon.rs b/src/provider/poseidon.rs
index 070fa2b3b..cae48d350 100644
--- a/src/provider/poseidon.rs
+++ b/src/provider/poseidon.rs
@@ -116,10 +116,7 @@ where
 
 /// A Poseidon-based RO gadget to use inside the verifier circuit.
 #[derive(Serialize, Deserialize)]
-pub struct PoseidonROCircuit<Scalar>
-where
-  Scalar: PrimeField,
-{
+pub struct PoseidonROCircuit<Scalar: PrimeField> {
   // Internal state
   state: Vec<AllocatedNum<Scalar>>,
   constants: PoseidonConstantsCircuit<Scalar>,
@@ -152,14 +149,11 @@ where
   }
 
   /// Compute a challenge by hashing the current state
-  fn squeeze<CS>(
+  fn squeeze<CS: ConstraintSystem<Scalar>>(
     &mut self,
     mut cs: CS,
     num_bits: usize,
-  ) -> Result<Vec<AllocatedBit>, SynthesisError>
-  where
-    CS: ConstraintSystem<Scalar>,
-  {
+  ) -> Result<Vec<AllocatedBit>, SynthesisError> {
     // check if we have squeezed already
     assert!(!self.squeezed, "Cannot squeeze again after squeezing");
     self.squeezed = true;
@@ -209,32 +203,37 @@ where
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::provider::{bn256_grumpkin::bn256, secp_secq};
+  use crate::provider::{
+    bn256_grumpkin::{Bn256Engine, GrumpkinEngine},
+    pasta::{PallasEngine, VestaEngine},
+    secp_secq::{Secp256k1Engine, Secq256k1Engine},
+  };
   use crate::{
     bellpepper::solver::SatisfyingAssignment, constants::NUM_CHALLENGE_BITS,
-    gadgets::utils::le_bits_to_num, traits::Group,
+    gadgets::utils::le_bits_to_num, traits::Engine,
   };
   use ff::Field;
   use rand::rngs::OsRng;
 
-  fn test_poseidon_ro_with<G: Group>()
+  fn test_poseidon_ro_with<E: Engine>()
   where
-    // we can print the field elements we get from G's Base & Scalar fields,
+    // we can print the field elements we get from E's Base & Scalar fields,
     // and compare their byte representations
-    <<G as Group>::Base as PrimeField>::Repr: std::fmt::Debug + Abomonation,
-    <<G as Group>::Scalar as PrimeField>::Repr: std::fmt::Debug + Abomonation,
-    <<G as Group>::Base as PrimeField>::Repr: PartialEq<<<G as Group>::Scalar as PrimeField>::Repr>,
+    <<E as Engine>::Base as PrimeField>::Repr: std::fmt::Debug + Abomonation,
+    <<E as Engine>::Scalar as PrimeField>::Repr: std::fmt::Debug + Abomonation,
+    <<E as Engine>::Base as PrimeField>::Repr:
+      PartialEq<<<E as Engine>::Scalar as PrimeField>::Repr>,
   {
     // Check that the number computed inside the circuit is equal to the number computed outside the circuit
     let mut csprng: OsRng = OsRng;
-    let constants = PoseidonConstantsCircuit::<G::Scalar>::default();
+    let constants = PoseidonConstantsCircuit::<E::Scalar>::default();
     let num_absorbs = 32;
-    let mut ro: PoseidonRO<G::Scalar, G::Base> = PoseidonRO::new(constants.clone(), num_absorbs);
-    let mut ro_gadget: PoseidonROCircuit<G::Scalar> =
+    let mut ro: PoseidonRO<E::Scalar, E::Base> = PoseidonRO::new(constants.clone(), num_absorbs);
+    let mut ro_gadget: PoseidonROCircuit<E::Scalar> =
       PoseidonROCircuit::new(constants, num_absorbs);
-    let mut cs = SatisfyingAssignment::<G>::new();
+    let mut cs = SatisfyingAssignment::<E>::new();
     for i in 0..num_absorbs {
-      let num = G::Scalar::random(&mut csprng);
+      let num = E::Scalar::random(&mut csprng);
       ro.absorb(num);
       let num_gadget = AllocatedNum::alloc_infallible(cs.namespace(|| format!("data {i}")), || num);
       num_gadget
@@ -250,9 +249,11 @@ mod tests {
 
   #[test]
   fn test_poseidon_ro() {
-    test_poseidon_ro_with::<pasta_curves::pallas::Point>();
-    test_poseidon_ro_with::<bn256::Point>();
-    test_poseidon_ro_with::<secp_secq::secp256k1::Point>();
-    test_poseidon_ro_with::<secp_secq::secq256k1::Point>();
+    test_poseidon_ro_with::<PallasEngine>();
+    test_poseidon_ro_with::<VestaEngine>();
+    test_poseidon_ro_with::<Bn256Engine>();
+    test_poseidon_ro_with::<GrumpkinEngine>();
+    test_poseidon_ro_with::<Secp256k1Engine>();
+    test_poseidon_ro_with::<Secq256k1Engine>();
   }
 }
diff --git a/src/provider/secp_secq.rs b/src/provider/secp_secq.rs
index 13f2c1cf8..ef6251859 100644
--- a/src/provider/secp_secq.rs
+++ b/src/provider/secp_secq.rs
@@ -6,9 +6,9 @@ use crate::{
     keccak::Keccak256Transcript,
     pedersen::CommitmentEngine,
     poseidon::{PoseidonRO, PoseidonROCircuit},
-    CompressedGroup, GroupExt,
+    CompressedGroup, DlogGroup,
   },
-  traits::{Group, PrimeFieldExt, TranscriptReprTrait},
+  traits::{Engine, Group, PrimeFieldExt, TranscriptReprTrait},
 };
 use digest::{ExtendableOutput, Update};
 use ff::{FromUniformBytes, PrimeField};
@@ -39,7 +39,16 @@ pub mod secq256k1 {
   };
 }
 
+/// An implementation of the Nova `Engine` trait with Secp256k1 curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Secp256k1Engine;
+
+/// An implementation of the Nova `Engine` trait with Secp256k1 curve and Pedersen commitment scheme
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Secq256k1Engine;
+
 impl_traits!(
+  Secp256k1Engine,
   secp256k1,
   Secp256k1Compressed,
   Secp256k1,
@@ -49,6 +58,7 @@ impl_traits!(
 );
 
 impl_traits!(
+  Secq256k1Engine,
   secq256k1,
   Secq256k1Compressed,
   Secq256k1,
@@ -82,7 +92,7 @@ mod tests {
     for n in [
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1021,
     ] {
-      let ck_par = <G as GroupExt>::from_label(label, n);
+      let ck_par = <G as DlogGroup>::from_label(label, n);
       let ck_ser = from_label_serial(label, n);
       assert_eq!(ck_par.len(), n);
       assert_eq!(ck_ser.len(), n);
diff --git a/src/r1cs/mod.rs b/src/r1cs/mod.rs
index 6a261a400..afb074de6 100644
--- a/src/r1cs/mod.rs
+++ b/src/r1cs/mod.rs
@@ -12,14 +12,14 @@ use crate::{
     utils::scalar_as_base,
   },
   traits::{
-    commitment::CommitmentEngineTrait, AbsorbInROTrait, Group, ROTrait, TranscriptReprTrait,
+    commitment::CommitmentEngineTrait, AbsorbInROTrait, Engine, ROTrait, TranscriptReprTrait,
   },
   Commitment, CommitmentKey, CE,
 };
 use abomonation::Abomonation;
 use abomonation_derive::Abomonation;
 use core::cmp::max;
-use ff::Field;
+use ff::{Field, PrimeField};
 use once_cell::sync::OnceCell;
 
 use rayon::prelude::*;
@@ -29,54 +29,54 @@ pub(crate) use self::sparse::SparseMatrix;
 
 /// A type that holds the shape of the R1CS matrices
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Abomonation)]
-#[abomonation_bounds(where <G::Scalar as ff::PrimeField>::Repr: Abomonation)]
-pub struct R1CSShape<G: Group> {
+#[abomonation_bounds(where <E::Scalar as ff::PrimeField>::Repr: Abomonation)]
+pub struct R1CSShape<E: Engine> {
   pub(crate) num_cons: usize,
   pub(crate) num_vars: usize,
   pub(crate) num_io: usize,
-  pub(crate) A: SparseMatrix<G::Scalar>,
-  pub(crate) B: SparseMatrix<G::Scalar>,
-  pub(crate) C: SparseMatrix<G::Scalar>,
-  #[abomonation_skip]
+  pub(crate) A: SparseMatrix<E::Scalar>,
+  pub(crate) B: SparseMatrix<E::Scalar>,
+  pub(crate) C: SparseMatrix<E::Scalar>,
   #[serde(skip, default = "OnceCell::new")]
-  pub(crate) digest: OnceCell<G::Scalar>,
+  #[abomonate_with(<E::Scalar as PrimeField>::Repr)]
+  pub(crate) digest: OnceCell<E::Scalar>,
 }
 
-impl<G: Group> SimpleDigestible for R1CSShape<G> {}
+impl<E: Engine> SimpleDigestible for R1CSShape<E> {}
 
 /// A type that holds a witness for a given R1CS instance
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct R1CSWitness<G: Group> {
-  W: Vec<G::Scalar>,
+pub struct R1CSWitness<E: Engine> {
+  W: Vec<E::Scalar>,
 }
 
 /// A type that holds an R1CS instance
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct R1CSInstance<G: Group> {
-  pub(crate) comm_W: Commitment<G>,
-  pub(crate) X: Vec<G::Scalar>,
+pub struct R1CSInstance<E: Engine> {
+  pub(crate) comm_W: Commitment<E>,
+  pub(crate) X: Vec<E::Scalar>,
 }
 
 /// A type that holds a witness for a given Relaxed R1CS instance
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RelaxedR1CSWitness<G: Group> {
-  pub(crate) W: Vec<G::Scalar>,
-  pub(crate) E: Vec<G::Scalar>,
+pub struct RelaxedR1CSWitness<E: Engine> {
+  pub(crate) W: Vec<E::Scalar>,
+  pub(crate) E: Vec<E::Scalar>,
 }
 
 /// A type that holds a Relaxed R1CS instance
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct RelaxedR1CSInstance<G: Group> {
-  pub(crate) comm_W: Commitment<G>,
-  pub(crate) comm_E: Commitment<G>,
-  pub(crate) X: Vec<G::Scalar>,
-  pub(crate) u: G::Scalar,
+pub struct RelaxedR1CSInstance<E: Engine> {
+  pub(crate) comm_W: Commitment<E>,
+  pub(crate) comm_E: Commitment<E>,
+  pub(crate) X: Vec<E::Scalar>,
+  pub(crate) u: E::Scalar,
 }
 
 /// A type for functions that hints commitment key sizing by returning the floor of the number of required generators.
-pub type CommitmentKeyHint<G> = dyn Fn(&R1CSShape<G>) -> usize;
+pub type CommitmentKeyHint<E> = dyn Fn(&R1CSShape<E>) -> usize;
 
 /// Generates public parameters for a Rank-1 Constraint System (R1CS).
 ///
@@ -89,36 +89,36 @@ pub type CommitmentKeyHint<G> = dyn Fn(&R1CSShape<G>) -> usize;
 /// * `ck_floor`: A function that provides a floor for the number of generators. A good function to
 ///   provide is the `commitment_key_floor` field in the trait `RelaxedR1CSSNARKTrait`.
 ///
-pub fn commitment_key<G: Group>(
-  S: &R1CSShape<G>,
-  ck_floor: &CommitmentKeyHint<G>,
-) -> CommitmentKey<G> {
+pub fn commitment_key<E: Engine>(
+  S: &R1CSShape<E>,
+  ck_floor: &CommitmentKeyHint<E>,
+) -> CommitmentKey<E> {
   let size = commitment_key_size(S, ck_floor);
-  G::CE::setup(b"ck", size)
+  E::CE::setup(b"ck", size)
 }
 
 /// Computes the number of generators required for the commitment key corresponding to shape `S`.
-pub fn commitment_key_size<G: Group>(S: &R1CSShape<G>, ck_floor: &CommitmentKeyHint<G>) -> usize {
+pub fn commitment_key_size<E: Engine>(S: &R1CSShape<E>, ck_floor: &CommitmentKeyHint<E>) -> usize {
   let num_cons = S.num_cons;
   let num_vars = S.num_vars;
   let ck_hint = ck_floor(S);
   max(max(num_cons, num_vars), ck_hint)
 }
 
-impl<G: Group> R1CSShape<G> {
+impl<E: Engine> R1CSShape<E> {
   /// Create an object of type `R1CSShape` from the explicitly specified R1CS matrices
   pub fn new(
     num_cons: usize,
     num_vars: usize,
     num_io: usize,
-    A: SparseMatrix<G::Scalar>,
-    B: SparseMatrix<G::Scalar>,
-    C: SparseMatrix<G::Scalar>,
-  ) -> Result<R1CSShape<G>, NovaError> {
+    A: SparseMatrix<E::Scalar>,
+    B: SparseMatrix<E::Scalar>,
+    C: SparseMatrix<E::Scalar>,
+  ) -> Result<R1CSShape<E>, NovaError> {
     let is_valid = |num_cons: usize,
                     num_vars: usize,
                     num_io: usize,
-                    M: &SparseMatrix<G::Scalar>|
+                    M: &SparseMatrix<E::Scalar>|
      -> Result<Vec<()>, NovaError> {
       M.iter()
         .map(|(row, col, _val)| {
@@ -151,8 +151,8 @@ impl<G: Group> R1CSShape<G> {
     })
   }
 
-  /// returnd the digest of the `R1CSShape`
-  pub fn digest(&self) -> G::Scalar {
+  /// returned the digest of the `R1CSShape`
+  pub fn digest(&self) -> E::Scalar {
     self
       .digest
       .get_or_try_init(|| DigestComputer::new(self).digest())
@@ -173,8 +173,8 @@ impl<G: Group> R1CSShape<G> {
 
   pub(crate) fn multiply_vec(
     &self,
-    z: &[G::Scalar],
-  ) -> Result<(Vec<G::Scalar>, Vec<G::Scalar>, Vec<G::Scalar>), NovaError> {
+    z: &[E::Scalar],
+  ) -> Result<(Vec<E::Scalar>, Vec<E::Scalar>, Vec<E::Scalar>), NovaError> {
     if z.len() != self.num_io + self.num_vars + 1 {
       return Err(NovaError::InvalidWitnessLength);
     }
@@ -190,9 +190,9 @@ impl<G: Group> R1CSShape<G> {
   /// Checks if the Relaxed R1CS instance is satisfiable given a witness and its shape
   pub fn is_sat_relaxed(
     &self,
-    ck: &CommitmentKey<G>,
-    U: &RelaxedR1CSInstance<G>,
-    W: &RelaxedR1CSWitness<G>,
+    ck: &CommitmentKey<E>,
+    U: &RelaxedR1CSInstance<E>,
+    W: &RelaxedR1CSWitness<E>,
   ) -> Result<(), NovaError> {
     assert_eq!(W.W.len(), self.num_vars);
     assert_eq!(W.E.len(), self.num_cons);
@@ -220,7 +220,7 @@ impl<G: Group> R1CSShape<G> {
     // verify if comm_E and comm_W are commitments to E and W
     let res_comm = {
       let (comm_W, comm_E) =
-        rayon::join(|| CE::<G>::commit(ck, &W.W), || CE::<G>::commit(ck, &W.E));
+        rayon::join(|| CE::<E>::commit(ck, &W.W), || CE::<E>::commit(ck, &W.E));
       U.comm_W == comm_W && U.comm_E == comm_E
     };
 
@@ -233,16 +233,16 @@ impl<G: Group> R1CSShape<G> {
   /// Checks if the R1CS instance is satisfiable given a witness and its shape
   pub fn is_sat(
     &self,
-    ck: &CommitmentKey<G>,
-    U: &R1CSInstance<G>,
-    W: &R1CSWitness<G>,
+    ck: &CommitmentKey<E>,
+    U: &R1CSInstance<E>,
+    W: &R1CSWitness<E>,
   ) -> Result<(), NovaError> {
     assert_eq!(W.W.len(), self.num_vars);
     assert_eq!(U.X.len(), self.num_io);
 
     // verify if Az * Bz = u*Cz
     let res_eq = {
-      let z = [W.W.clone(), vec![G::Scalar::ONE], U.X.clone()].concat();
+      let z = [W.W.clone(), vec![E::Scalar::ONE], U.X.clone()].concat();
       let (Az, Bz, Cz) = self.multiply_vec(&z)?;
       assert_eq!(Az.len(), self.num_cons);
       assert_eq!(Bz.len(), self.num_cons);
@@ -260,7 +260,7 @@ impl<G: Group> R1CSShape<G> {
     res_eq?;
 
     // verify if comm_W is a commitment to W
-    if U.comm_W != CE::<G>::commit(ck, &W.W) {
+    if U.comm_W != CE::<E>::commit(ck, &W.W) {
       return Err(NovaError::UnSat);
     }
     Ok(())
@@ -270,19 +270,19 @@ impl<G: Group> R1CSShape<G> {
   /// Relaxed R1CS instance-witness pair and an R1CS instance-witness pair
   pub fn commit_T(
     &self,
-    ck: &CommitmentKey<G>,
-    U1: &RelaxedR1CSInstance<G>,
-    W1: &RelaxedR1CSWitness<G>,
-    U2: &R1CSInstance<G>,
-    W2: &R1CSWitness<G>,
-  ) -> Result<(Vec<G::Scalar>, Commitment<G>), NovaError> {
+    ck: &CommitmentKey<E>,
+    U1: &RelaxedR1CSInstance<E>,
+    W1: &RelaxedR1CSWitness<E>,
+    U2: &R1CSInstance<E>,
+    W2: &R1CSWitness<E>,
+  ) -> Result<(Vec<E::Scalar>, Commitment<E>), NovaError> {
     let (AZ_1, BZ_1, CZ_1) = tracing::trace_span!("AZ_1, BZ_1, CZ_1").in_scope(|| {
       let Z1 = [W1.W.clone(), vec![U1.u], U1.X.clone()].concat();
       self.multiply_vec(&Z1)
     })?;
 
     let (AZ_2, BZ_2, CZ_2) = tracing::trace_span!("AZ_2, BZ_2, CZ_2").in_scope(|| {
-      let Z2 = [W2.W.clone(), vec![G::Scalar::ONE], U2.X.clone()].concat();
+      let Z2 = [W2.W.clone(), vec![E::Scalar::ONE], U2.X.clone()].concat();
       self.multiply_vec(&Z2)
     })?;
 
@@ -291,19 +291,19 @@ impl<G: Group> R1CSShape<G> {
         let AZ_1_circ_BZ_2 = (0..AZ_1.len())
           .into_par_iter()
           .map(|i| AZ_1[i] * BZ_2[i])
-          .collect::<Vec<G::Scalar>>();
+          .collect::<Vec<E::Scalar>>();
         let AZ_2_circ_BZ_1 = (0..AZ_2.len())
           .into_par_iter()
           .map(|i| AZ_2[i] * BZ_1[i])
-          .collect::<Vec<G::Scalar>>();
+          .collect::<Vec<E::Scalar>>();
         let u_1_cdot_CZ_2 = (0..CZ_2.len())
           .into_par_iter()
           .map(|i| U1.u * CZ_2[i])
-          .collect::<Vec<G::Scalar>>();
+          .collect::<Vec<E::Scalar>>();
         let u_2_cdot_CZ_1 = (0..CZ_1.len())
           .into_par_iter()
           .map(|i| CZ_1[i])
-          .collect::<Vec<G::Scalar>>();
+          .collect::<Vec<E::Scalar>>();
         (AZ_1_circ_BZ_2, AZ_2_circ_BZ_1, u_1_cdot_CZ_2, u_2_cdot_CZ_1)
       });
 
@@ -314,10 +314,10 @@ impl<G: Group> R1CSShape<G> {
         .zip(&u_1_cdot_CZ_2)
         .zip(&u_2_cdot_CZ_1)
         .map(|(((a, b), c), d)| *a + *b - *c - *d)
-        .collect::<Vec<G::Scalar>>()
+        .collect::<Vec<E::Scalar>>()
     });
 
-    let comm_T = CE::<G>::commit(ck, &T);
+    let comm_T = CE::<E>::commit(ck, &T);
 
     Ok((T, comm_T))
   }
@@ -351,7 +351,7 @@ impl<G: Group> R1CSShape<G> {
     let num_vars_padded = m;
     let num_cons_padded = m;
 
-    let apply_pad = |mut M: SparseMatrix<G::Scalar>| -> SparseMatrix<G::Scalar> {
+    let apply_pad = |mut M: SparseMatrix<E::Scalar>| -> SparseMatrix<E::Scalar> {
       M.indices.par_iter_mut().for_each(|c| {
         if *c >= self.num_vars {
           *c += num_vars_padded - self.num_vars
@@ -384,9 +384,9 @@ impl<G: Group> R1CSShape<G> {
   }
 }
 
-impl<G: Group> R1CSWitness<G> {
+impl<E: Engine> R1CSWitness<E> {
   /// A method to create a witness object using a vector of scalars
-  pub fn new(S: &R1CSShape<G>, W: &[G::Scalar]) -> Result<R1CSWitness<G>, NovaError> {
+  pub fn new(S: &R1CSShape<E>, W: &[E::Scalar]) -> Result<R1CSWitness<E>, NovaError> {
     if S.num_vars != W.len() {
       Err(NovaError::InvalidWitnessLength)
     } else {
@@ -395,18 +395,18 @@ impl<G: Group> R1CSWitness<G> {
   }
 
   /// Commits to the witness using the supplied generators
-  pub fn commit(&self, ck: &CommitmentKey<G>) -> Commitment<G> {
-    CE::<G>::commit(ck, &self.W)
+  pub fn commit(&self, ck: &CommitmentKey<E>) -> Commitment<E> {
+    CE::<E>::commit(ck, &self.W)
   }
 }
 
-impl<G: Group> R1CSInstance<G> {
+impl<E: Engine> R1CSInstance<E> {
   /// A method to create an instance object using consitituent elements
   pub fn new(
-    S: &R1CSShape<G>,
-    comm_W: &Commitment<G>,
-    X: &[G::Scalar],
-  ) -> Result<R1CSInstance<G>, NovaError> {
+    S: &R1CSShape<E>,
+    comm_W: &Commitment<E>,
+    X: &[E::Scalar],
+  ) -> Result<R1CSInstance<E>, NovaError> {
     if S.num_io != X.len() {
       Err(NovaError::InvalidInputLength)
     } else {
@@ -418,44 +418,44 @@ impl<G: Group> R1CSInstance<G> {
   }
 }
 
-impl<G: Group> AbsorbInROTrait<G> for R1CSInstance<G> {
-  fn absorb_in_ro(&self, ro: &mut G::RO) {
+impl<E: Engine> AbsorbInROTrait<E> for R1CSInstance<E> {
+  fn absorb_in_ro(&self, ro: &mut E::RO) {
     self.comm_W.absorb_in_ro(ro);
     for x in &self.X {
-      ro.absorb(scalar_as_base::<G>(*x));
+      ro.absorb(scalar_as_base::<E>(*x));
     }
   }
 }
 
-impl<G: Group> RelaxedR1CSWitness<G> {
+impl<E: Engine> RelaxedR1CSWitness<E> {
   /// Produces a default `RelaxedR1CSWitness` given an `R1CSShape`
-  pub fn default(S: &R1CSShape<G>) -> RelaxedR1CSWitness<G> {
+  pub fn default(S: &R1CSShape<E>) -> RelaxedR1CSWitness<E> {
     RelaxedR1CSWitness {
-      W: vec![G::Scalar::ZERO; S.num_vars],
-      E: vec![G::Scalar::ZERO; S.num_cons],
+      W: vec![E::Scalar::ZERO; S.num_vars],
+      E: vec![E::Scalar::ZERO; S.num_cons],
     }
   }
 
   /// Initializes a new `RelaxedR1CSWitness` from an `R1CSWitness`
-  pub fn from_r1cs_witness(S: &R1CSShape<G>, witness: &R1CSWitness<G>) -> RelaxedR1CSWitness<G> {
+  pub fn from_r1cs_witness(S: &R1CSShape<E>, witness: &R1CSWitness<E>) -> RelaxedR1CSWitness<E> {
     RelaxedR1CSWitness {
       W: witness.W.clone(),
-      E: vec![G::Scalar::ZERO; S.num_cons],
+      E: vec![E::Scalar::ZERO; S.num_cons],
     }
   }
 
   /// Commits to the witness using the supplied generators
-  pub fn commit(&self, ck: &CommitmentKey<G>) -> (Commitment<G>, Commitment<G>) {
-    (CE::<G>::commit(ck, &self.W), CE::<G>::commit(ck, &self.E))
+  pub fn commit(&self, ck: &CommitmentKey<E>) -> (Commitment<E>, Commitment<E>) {
+    (CE::<E>::commit(ck, &self.W), CE::<E>::commit(ck, &self.E))
   }
 
   /// Folds an incoming `R1CSWitness` into the current one
   pub fn fold(
     &self,
-    W2: &R1CSWitness<G>,
-    T: &[G::Scalar],
-    r: &G::Scalar,
-  ) -> Result<RelaxedR1CSWitness<G>, NovaError> {
+    W2: &R1CSWitness<E>,
+    T: &[E::Scalar],
+    r: &E::Scalar,
+  ) -> Result<RelaxedR1CSWitness<E>, NovaError> {
     let (W1, E1) = (&self.W, &self.E);
     let W2 = &W2.W;
 
@@ -467,61 +467,61 @@ impl<G: Group> RelaxedR1CSWitness<G> {
       .par_iter()
       .zip(W2)
       .map(|(a, b)| *a + *r * *b)
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
     let E = E1
       .par_iter()
       .zip(T)
       .map(|(a, b)| *a + *r * *b)
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
     Ok(RelaxedR1CSWitness { W, E })
   }
 
   /// Pads the provided witness to the correct length
-  pub fn pad(&self, S: &R1CSShape<G>) -> RelaxedR1CSWitness<G> {
+  pub fn pad(&self, S: &R1CSShape<E>) -> RelaxedR1CSWitness<E> {
     let mut W = self.W.clone();
-    W.extend(vec![G::Scalar::ZERO; S.num_vars - W.len()]);
+    W.extend(vec![E::Scalar::ZERO; S.num_vars - W.len()]);
 
     let mut E = self.E.clone();
-    E.extend(vec![G::Scalar::ZERO; S.num_cons - E.len()]);
+    E.extend(vec![E::Scalar::ZERO; S.num_cons - E.len()]);
 
     Self { W, E }
   }
 }
 
-impl<G: Group> RelaxedR1CSInstance<G> {
+impl<E: Engine> RelaxedR1CSInstance<E> {
   /// Produces a default `RelaxedR1CSInstance` given `R1CSGens` and `R1CSShape`
-  pub fn default(_ck: &CommitmentKey<G>, S: &R1CSShape<G>) -> RelaxedR1CSInstance<G> {
-    let (comm_W, comm_E) = (Commitment::<G>::default(), Commitment::<G>::default());
+  pub fn default(_ck: &CommitmentKey<E>, S: &R1CSShape<E>) -> RelaxedR1CSInstance<E> {
+    let (comm_W, comm_E) = (Commitment::<E>::default(), Commitment::<E>::default());
     RelaxedR1CSInstance {
       comm_W,
       comm_E,
-      u: G::Scalar::ZERO,
-      X: vec![G::Scalar::ZERO; S.num_io],
+      u: E::Scalar::ZERO,
+      X: vec![E::Scalar::ZERO; S.num_io],
     }
   }
 
   /// Initializes a new `RelaxedR1CSInstance` from an `R1CSInstance`
   pub fn from_r1cs_instance(
-    ck: &CommitmentKey<G>,
-    S: &R1CSShape<G>,
-    instance: &R1CSInstance<G>,
-  ) -> RelaxedR1CSInstance<G> {
+    ck: &CommitmentKey<E>,
+    S: &R1CSShape<E>,
+    instance: &R1CSInstance<E>,
+  ) -> RelaxedR1CSInstance<E> {
     let mut r_instance = RelaxedR1CSInstance::default(ck, S);
     r_instance.comm_W = instance.comm_W;
-    r_instance.u = G::Scalar::ONE;
+    r_instance.u = E::Scalar::ONE;
     r_instance.X = instance.X.clone();
     r_instance
   }
 
   /// Initializes a new `RelaxedR1CSInstance` from an `R1CSInstance`
   pub fn from_r1cs_instance_unchecked(
-    comm_W: &Commitment<G>,
-    X: &[G::Scalar],
-  ) -> RelaxedR1CSInstance<G> {
+    comm_W: &Commitment<E>,
+    X: &[E::Scalar],
+  ) -> RelaxedR1CSInstance<E> {
     RelaxedR1CSInstance {
       comm_W: *comm_W,
-      comm_E: Commitment::<G>::default(),
-      u: G::Scalar::ONE,
+      comm_E: Commitment::<E>::default(),
+      u: E::Scalar::ONE,
       X: X.to_vec(),
     }
   }
@@ -529,10 +529,10 @@ impl<G: Group> RelaxedR1CSInstance<G> {
   /// Folds an incoming `RelaxedR1CSInstance` into the current one
   pub fn fold(
     &self,
-    U2: &R1CSInstance<G>,
-    comm_T: &Commitment<G>,
-    r: &G::Scalar,
-  ) -> RelaxedR1CSInstance<G> {
+    U2: &R1CSInstance<E>,
+    comm_T: &Commitment<E>,
+    r: &E::Scalar,
+  ) -> RelaxedR1CSInstance<E> {
     let (X1, u1, comm_W_1, comm_E_1) =
       (&self.X, &self.u, &self.comm_W.clone(), &self.comm_E.clone());
     let (X2, comm_W_2) = (&U2.X, &U2.comm_W);
@@ -542,7 +542,7 @@ impl<G: Group> RelaxedR1CSInstance<G> {
       .par_iter()
       .zip(X2)
       .map(|(a, b)| *a + *r * *b)
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
     let comm_W = *comm_W_1 + *comm_W_2 * *r;
     let comm_E = *comm_E_1 + *comm_T * *r;
     let u = *u1 + *r;
@@ -556,7 +556,7 @@ impl<G: Group> RelaxedR1CSInstance<G> {
   }
 }
 
-impl<G: Group> TranscriptReprTrait<G> for RelaxedR1CSInstance<G> {
+impl<E: Engine> TranscriptReprTrait<E::GE> for RelaxedR1CSInstance<E> {
   fn to_transcript_bytes(&self) -> Vec<u8> {
     [
       self.comm_W.to_transcript_bytes(),
@@ -568,17 +568,17 @@ impl<G: Group> TranscriptReprTrait<G> for RelaxedR1CSInstance<G> {
   }
 }
 
-impl<G: Group> AbsorbInROTrait<G> for RelaxedR1CSInstance<G> {
-  fn absorb_in_ro(&self, ro: &mut G::RO) {
+impl<E: Engine> AbsorbInROTrait<E> for RelaxedR1CSInstance<E> {
+  fn absorb_in_ro(&self, ro: &mut E::RO) {
     self.comm_W.absorb_in_ro(ro);
     self.comm_E.absorb_in_ro(ro);
-    ro.absorb(scalar_as_base::<G>(self.u));
+    ro.absorb(scalar_as_base::<E>(self.u));
 
     // absorb each element of self.X in bignum format
     for x in &self.X {
-      let limbs: Vec<G::Scalar> = nat_to_limbs(&f_to_nat(x), BN_LIMB_WIDTH, BN_N_LIMBS).unwrap();
+      let limbs: Vec<E::Scalar> = nat_to_limbs(&f_to_nat(x), BN_LIMB_WIDTH, BN_N_LIMBS).unwrap();
       for limb in limbs {
-        ro.absorb(scalar_as_base::<G>(limb));
+        ro.absorb(scalar_as_base::<E>(limb));
       }
     }
   }
@@ -589,10 +589,14 @@ mod tests {
   use ff::Field;
 
   use super::*;
-  use crate::{r1cs::sparse::SparseMatrix, traits::Group};
-
-  fn tiny_r1cs<G: Group>(num_vars: usize) -> R1CSShape<G> {
-    let one = <G::Scalar as Field>::ONE;
+  use crate::{
+    provider::{bn256_grumpkin::Bn256Engine, pasta::PallasEngine, secp_secq::Secp256k1Engine},
+    r1cs::sparse::SparseMatrix,
+    traits::Engine,
+  };
+
+  fn tiny_r1cs<E: Engine>(num_vars: usize) -> R1CSShape<E> {
+    let one = <E::Scalar as Field>::ONE;
     let (num_cons, num_vars, num_io, A, B, C) = {
       let num_cons = 4;
       let num_io = 2;
@@ -608,9 +612,9 @@ mod tests {
       // constraint and a column for every entry in z = (vars, u, inputs)
       // An R1CS instance is satisfiable iff:
       // Az \circ Bz = u \cdot Cz + E, where z = (vars, 1, inputs)
-      let mut A: Vec<(usize, usize, G::Scalar)> = Vec::new();
-      let mut B: Vec<(usize, usize, G::Scalar)> = Vec::new();
-      let mut C: Vec<(usize, usize, G::Scalar)> = Vec::new();
+      let mut A: Vec<(usize, usize, E::Scalar)> = Vec::new();
+      let mut B: Vec<(usize, usize, E::Scalar)> = Vec::new();
+      let mut C: Vec<(usize, usize, E::Scalar)> = Vec::new();
 
       // constraint 0 entries in (A,B,C)
       // `I0 * I0 - Z0 = 0`
@@ -657,19 +661,19 @@ mod tests {
     res.unwrap()
   }
 
-  fn test_pad_tiny_r1cs_with<G: Group>() {
-    let padded_r1cs = tiny_r1cs::<G>(3).pad();
+  fn test_pad_tiny_r1cs_with<E: Engine>() {
+    let padded_r1cs = tiny_r1cs::<E>(3).pad();
     assert!(padded_r1cs.is_regular_shape());
 
-    let expected_r1cs = tiny_r1cs::<G>(4);
+    let expected_r1cs = tiny_r1cs::<E>(4);
 
     assert_eq!(padded_r1cs, expected_r1cs);
   }
 
   #[test]
   fn test_pad_tiny_r1cs() {
-    test_pad_tiny_r1cs_with::<pasta_curves::pallas::Point>();
-    test_pad_tiny_r1cs_with::<crate::provider::bn256_grumpkin::bn256::Point>();
-    test_pad_tiny_r1cs_with::<crate::provider::secp_secq::secp256k1::Point>();
+    test_pad_tiny_r1cs_with::<PallasEngine>();
+    test_pad_tiny_r1cs_with::<Bn256Engine>();
+    test_pad_tiny_r1cs_with::<Secp256k1Engine>();
   }
 }
diff --git a/src/r1cs/sparse.rs b/src/r1cs/sparse.rs
index 6c22b67ca..530378df5 100644
--- a/src/r1cs/sparse.rs
+++ b/src/r1cs/sparse.rs
@@ -184,15 +184,18 @@ impl<'a, F: PrimeField> Iterator for Iter<'a, F> {
 
 #[cfg(test)]
 mod tests {
-  use crate::{r1cs::util::FWrap, traits::Group};
-
   use super::SparseMatrix;
-  use pasta_curves::pallas::Point as G;
+  use crate::{
+    provider::pasta::PallasEngine,
+    r1cs::util::FWrap,
+    traits::{Engine, Group},
+  };
   use proptest::{
     prelude::*,
     strategy::{BoxedStrategy, Just, Strategy},
   };
 
+  type G = <PallasEngine as Engine>::GE;
   type Fr = <G as Group>::Scalar;
 
   #[test]
diff --git a/src/spartan/direct.rs b/src/spartan/direct.rs
index 0b19a78fa..b57d68121 100644
--- a/src/spartan/direct.rs
+++ b/src/spartan/direct.rs
@@ -12,7 +12,7 @@ use crate::{
   traits::{
     circuit::StepCircuit,
     snark::{DigestHelperTrait, RelaxedR1CSSNARKTrait},
-    Group,
+    Engine,
   },
   Commitment, CommitmentKey,
 };
@@ -21,25 +21,25 @@ use core::marker::PhantomData;
 use ff::Field;
 use serde::{Deserialize, Serialize};
 
-struct DirectCircuit<G: Group, SC: StepCircuit<G::Scalar>> {
-  z_i: Option<Vec<G::Scalar>>, // inputs to the circuit
+struct DirectCircuit<E: Engine, SC: StepCircuit<E::Scalar>> {
+  z_i: Option<Vec<E::Scalar>>, // inputs to the circuit
   sc: SC,                      // step circuit to be executed
 }
 
-impl<G: Group, SC: StepCircuit<G::Scalar>> Circuit<G::Scalar> for DirectCircuit<G, SC> {
-  fn synthesize<CS: ConstraintSystem<G::Scalar>>(self, cs: &mut CS) -> Result<(), SynthesisError> {
+impl<E: Engine, SC: StepCircuit<E::Scalar>> Circuit<E::Scalar> for DirectCircuit<E, SC> {
+  fn synthesize<CS: ConstraintSystem<E::Scalar>>(self, cs: &mut CS) -> Result<(), SynthesisError> {
     // obtain the arity information
     let arity = self.sc.arity();
 
     // Allocate zi. If inputs.zi is not provided, allocate default value 0
-    let zero = vec![G::Scalar::ZERO; arity];
+    let zero = vec![E::Scalar::ZERO; arity];
     let z_i = (0..arity)
       .map(|i| {
         AllocatedNum::alloc(cs.namespace(|| format!("zi_{i}")), || {
           Ok(self.z_i.as_ref().unwrap_or(&zero)[i])
         })
       })
-      .collect::<Result<Vec<AllocatedNum<G::Scalar>>, _>>()?;
+      .collect::<Result<Vec<AllocatedNum<E::Scalar>>, _>>()?;
 
     let z_i_plus_one = self.sc.synthesize(&mut cs.namespace(|| "F"), &z_i)?;
 
@@ -58,30 +58,30 @@ impl<G: Group, SC: StepCircuit<G::Scalar>> Circuit<G::Scalar> for DirectCircuit<
 /// A type that holds the prover key
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct ProverKey<G, S>
+pub struct ProverKey<E, S>
 where
-  G: Group,
-  S: RelaxedR1CSSNARKTrait<G>,
+  E: Engine,
+  S: RelaxedR1CSSNARKTrait<E>,
 {
-  S: R1CSShape<G>,
-  ck: CommitmentKey<G>,
+  S: R1CSShape<E>,
+  ck: CommitmentKey<E>,
   pk: S::ProverKey,
 }
 
 /// A type that holds the verifier key
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct VerifierKey<G, S>
+pub struct VerifierKey<E, S>
 where
-  G: Group,
-  S: RelaxedR1CSSNARKTrait<G>,
+  E: Engine,
+  S: RelaxedR1CSSNARKTrait<E>,
 {
   vk: S::VerifierKey,
 }
 
-impl<G: Group, S: RelaxedR1CSSNARKTrait<G>> VerifierKey<G, S> {
+impl<E: Engine, S: RelaxedR1CSSNARKTrait<E>> VerifierKey<E, S> {
   /// Returns the digest of the verifier's key
-  pub fn digest(&self) -> G::Scalar {
+  pub fn digest(&self) -> E::Scalar {
     self.vk.digest()
   }
 }
@@ -89,24 +89,24 @@ impl<G: Group, S: RelaxedR1CSSNARKTrait<G>> VerifierKey<G, S> {
 /// A direct SNARK proving a step circuit
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct DirectSNARK<G, S, C>
+pub struct DirectSNARK<E, S, C>
 where
-  G: Group,
-  S: RelaxedR1CSSNARKTrait<G>,
-  C: StepCircuit<G::Scalar>,
+  E: Engine,
+  S: RelaxedR1CSSNARKTrait<E>,
+  C: StepCircuit<E::Scalar>,
 {
-  comm_W: Commitment<G>, // commitment to the witness
+  comm_W: Commitment<E>, // commitment to the witness
   snark: S,              // snark proving the witness is satisfying
   _p: PhantomData<C>,
 }
 
-impl<G: Group, S: RelaxedR1CSSNARKTrait<G>, C: StepCircuit<G::Scalar>> DirectSNARK<G, S, C> {
+impl<E: Engine, S: RelaxedR1CSSNARKTrait<E>, C: StepCircuit<E::Scalar>> DirectSNARK<E, S, C> {
   /// Produces prover and verifier keys for the direct SNARK
-  pub fn setup(sc: C) -> Result<(ProverKey<G, S>, VerifierKey<G, S>), NovaError> {
+  pub fn setup(sc: C) -> Result<(ProverKey<E, S>, VerifierKey<E, S>), NovaError> {
     // construct a circuit that can be synthesized
-    let circuit: DirectCircuit<G, C> = DirectCircuit { z_i: None, sc };
+    let circuit: DirectCircuit<E, C> = DirectCircuit { z_i: None, sc };
 
-    let mut cs: ShapeCS<G> = ShapeCS::new();
+    let mut cs: ShapeCS<E> = ShapeCS::new();
     let _ = circuit.synthesize(&mut cs);
     let (shape, ck) = cs.r1cs_shape_and_key(&*S::ck_floor());
 
@@ -120,10 +120,10 @@ impl<G: Group, S: RelaxedR1CSSNARKTrait<G>, C: StepCircuit<G::Scalar>> DirectSNA
   }
 
   /// Produces a proof of satisfiability of the provided circuit
-  pub fn prove(pk: &ProverKey<G, S>, sc: C, z_i: &[G::Scalar]) -> Result<Self, NovaError> {
-    let mut cs = SatisfyingAssignment::<G>::new();
+  pub fn prove(pk: &ProverKey<E, S>, sc: C, z_i: &[E::Scalar]) -> Result<Self, NovaError> {
+    let mut cs = SatisfyingAssignment::<E>::new();
 
-    let circuit: DirectCircuit<G, C> = DirectCircuit {
+    let circuit: DirectCircuit<E, C> = DirectCircuit {
       z_i: Some(z_i.to_vec()),
       sc,
     };
@@ -150,7 +150,7 @@ impl<G: Group, S: RelaxedR1CSSNARKTrait<G>, C: StepCircuit<G::Scalar>> DirectSNA
   }
 
   /// Verifies a proof of satisfiability
-  pub fn verify(&self, vk: &VerifierKey<G, S>, io: &[G::Scalar]) -> Result<(), NovaError> {
+  pub fn verify(&self, vk: &VerifierKey<E, S>, io: &[E::Scalar]) -> Result<(), NovaError> {
     // construct an instance using the provided commitment to the witness and z_i and z_{i+1}
     let u_relaxed = RelaxedR1CSInstance::from_r1cs_instance_unchecked(&self.comm_W, io);
 
@@ -164,7 +164,9 @@ impl<G: Group, S: RelaxedR1CSSNARKTrait<G>, C: StepCircuit<G::Scalar>> DirectSNA
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::provider::{bn256_grumpkin::bn256, secp_secq::secp256k1};
+  use crate::provider::{
+    bn256_grumpkin::Bn256Engine, pasta::PallasEngine, secp_secq::Secp256k1Engine,
+  };
   use ::bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
   use core::marker::PhantomData;
   use ff::PrimeField;
@@ -174,10 +176,7 @@ mod tests {
     _p: PhantomData<F>,
   }
 
-  impl<F> StepCircuit<F> for CubicCircuit<F>
-  where
-    F: PrimeField,
-  {
+  impl<F: PrimeField> StepCircuit<F> for CubicCircuit<F> {
     fn arity(&self) -> usize {
       1
     }
@@ -222,42 +221,42 @@ mod tests {
 
   #[test]
   fn test_direct_snark() {
-    type G = pasta_curves::pallas::Point;
-    type EE = crate::provider::ipa_pc::EvaluationEngine<G>;
-    type S = crate::spartan::snark::RelaxedR1CSSNARK<G, EE>;
-    test_direct_snark_with::<G, S>();
+    type E = PallasEngine;
+    type EE = crate::provider::ipa_pc::EvaluationEngine<E>;
+    type S = crate::spartan::snark::RelaxedR1CSSNARK<E, EE>;
+    test_direct_snark_with::<E, S>();
 
-    type Spp = crate::spartan::ppsnark::RelaxedR1CSSNARK<G, EE>;
-    test_direct_snark_with::<G, Spp>();
+    type Spp = crate::spartan::ppsnark::RelaxedR1CSSNARK<E, EE>;
+    test_direct_snark_with::<E, Spp>();
 
-    type G2 = bn256::Point;
-    type EE2 = crate::provider::ipa_pc::EvaluationEngine<G2>;
-    type S2 = crate::spartan::snark::RelaxedR1CSSNARK<G2, EE2>;
-    test_direct_snark_with::<G2, S2>();
+    type E2 = Bn256Engine;
+    type EE2 = crate::provider::ipa_pc::EvaluationEngine<E2>;
+    type S2 = crate::spartan::snark::RelaxedR1CSSNARK<E2, EE2>;
+    test_direct_snark_with::<E2, S2>();
 
-    type S2pp = crate::spartan::ppsnark::RelaxedR1CSSNARK<G2, EE2>;
-    test_direct_snark_with::<G2, S2pp>();
+    type S2pp = crate::spartan::ppsnark::RelaxedR1CSSNARK<E2, EE2>;
+    test_direct_snark_with::<E2, S2pp>();
 
-    type G3 = secp256k1::Point;
-    type EE3 = crate::provider::ipa_pc::EvaluationEngine<G3>;
-    type S3 = crate::spartan::snark::RelaxedR1CSSNARK<G3, EE3>;
-    test_direct_snark_with::<G3, S3>();
+    type E3 = Secp256k1Engine;
+    type EE3 = crate::provider::ipa_pc::EvaluationEngine<E3>;
+    type S3 = crate::spartan::snark::RelaxedR1CSSNARK<E3, EE3>;
+    test_direct_snark_with::<E3, S3>();
 
-    type S3pp = crate::spartan::ppsnark::RelaxedR1CSSNARK<G3, EE3>;
-    test_direct_snark_with::<G3, S3pp>();
+    type S3pp = crate::spartan::ppsnark::RelaxedR1CSSNARK<E3, EE3>;
+    test_direct_snark_with::<E3, S3pp>();
   }
 
-  fn test_direct_snark_with<G: Group, S: RelaxedR1CSSNARKTrait<G>>() {
+  fn test_direct_snark_with<E: Engine, S: RelaxedR1CSSNARKTrait<E>>() {
     let circuit = CubicCircuit::default();
 
     // produce keys
     let (pk, vk) =
-      DirectSNARK::<G, S, CubicCircuit<<G as Group>::Scalar>>::setup(circuit.clone()).unwrap();
+      DirectSNARK::<E, S, CubicCircuit<<E as Engine>::Scalar>>::setup(circuit.clone()).unwrap();
 
     let num_steps = 3;
 
     // setup inputs
-    let z0 = vec![<G as Group>::Scalar::ZERO];
+    let z0 = vec![<E as Engine>::Scalar::ZERO];
     let mut z_i = z0;
 
     for _i in 0..num_steps {
@@ -283,6 +282,6 @@ mod tests {
     }
 
     // sanity: check the claimed output with a direct computation of the same
-    assert_eq!(z_i, vec![<G as Group>::Scalar::from(2460515u64)]);
+    assert_eq!(z_i, vec![<E as Engine>::Scalar::from(2460515u64)]);
   }
 }
diff --git a/src/spartan/mod.rs b/src/spartan/mod.rs
index 4578e0770..3e7c514e8 100644
--- a/src/spartan/mod.rs
+++ b/src/spartan/mod.rs
@@ -12,15 +12,15 @@ pub mod ppsnark;
 pub mod snark;
 mod sumcheck;
 
-use crate::{traits::Group, Commitment};
+use crate::{traits::Engine, Commitment};
 use ff::Field;
 use polys::multilinear::SparsePolynomial;
 use rayon::{iter::IntoParallelRefIterator, prelude::*};
 
-fn powers<G: Group>(s: &G::Scalar, n: usize) -> Vec<G::Scalar> {
+fn powers<E: Engine>(s: &E::Scalar, n: usize) -> Vec<E::Scalar> {
   assert!(n >= 1);
   let mut powers = Vec::new();
-  powers.push(G::Scalar::ONE);
+  powers.push(E::Scalar::ONE);
   for i in 1..n {
     powers.push(powers[i - 1] * s);
   }
@@ -28,16 +28,16 @@ fn powers<G: Group>(s: &G::Scalar, n: usize) -> Vec<G::Scalar> {
 }
 
 /// A type that holds a witness to a polynomial evaluation instance
-pub struct PolyEvalWitness<G: Group> {
-  p: Vec<G::Scalar>, // polynomial
+pub struct PolyEvalWitness<E: Engine> {
+  p: Vec<E::Scalar>, // polynomial
 }
 
-impl<G: Group> PolyEvalWitness<G> {
-  fn pad(mut W: Vec<PolyEvalWitness<G>>) -> Vec<PolyEvalWitness<G>> {
+impl<E: Engine> PolyEvalWitness<E> {
+  fn pad(mut W: Vec<PolyEvalWitness<E>>) -> Vec<PolyEvalWitness<E>> {
     // determine the maximum size
     if let Some(n) = W.iter().map(|w| w.p.len()).max() {
       W.iter_mut().for_each(|w| {
-        w.p.resize(n, G::Scalar::ZERO);
+        w.p.resize(n, E::Scalar::ZERO);
       });
       W
     } else {
@@ -45,9 +45,9 @@ impl<G: Group> PolyEvalWitness<G> {
     }
   }
 
-  fn weighted_sum(W: &[PolyEvalWitness<G>], s: &[G::Scalar]) -> PolyEvalWitness<G> {
+  fn weighted_sum(W: &[PolyEvalWitness<E>], s: &[E::Scalar]) -> PolyEvalWitness<E> {
     assert_eq!(W.len(), s.len());
-    let mut p = vec![G::Scalar::ZERO; W[0].p.len()];
+    let mut p = vec![E::Scalar::ZERO; W[0].p.len()];
     for i in 0..W.len() {
       for j in 0..W[i].p.len() {
         p[j] += W[i].p[j] * s[i]
@@ -57,22 +57,22 @@ impl<G: Group> PolyEvalWitness<G> {
   }
 
   // This method panics unless all vectors in p_vec are of the same length
-  fn batch(p_vec: &[&Vec<G::Scalar>], s: &G::Scalar) -> PolyEvalWitness<G> {
+  fn batch(p_vec: &[&Vec<E::Scalar>], s: &E::Scalar) -> PolyEvalWitness<E> {
     p_vec
       .iter()
       .for_each(|p| assert_eq!(p.len(), p_vec[0].len()));
 
-    let powers_of_s = powers::<G>(s, p_vec.len());
+    let powers_of_s = powers::<E>(s, p_vec.len());
 
     let p = p_vec
       .par_iter()
       .zip(powers_of_s.par_iter())
       .map(|(v, &weight)| {
         // compute the weighted sum for each vector
-        v.iter().map(|&x| x * weight).collect::<Vec<G::Scalar>>()
+        v.iter().map(|&x| x * weight).collect::<Vec<E::Scalar>>()
       })
       .reduce(
-        || vec![G::Scalar::ZERO; p_vec[0].len()],
+        || vec![E::Scalar::ZERO; p_vec[0].len()],
         |acc, v| {
           // perform vector addition to combine the weighted vectors
           acc.into_iter().zip(v).map(|(x, y)| x + y).collect()
@@ -84,19 +84,19 @@ impl<G: Group> PolyEvalWitness<G> {
 }
 
 /// A type that holds a polynomial evaluation instance
-pub struct PolyEvalInstance<G: Group> {
-  c: Commitment<G>,  // commitment to the polynomial
-  x: Vec<G::Scalar>, // evaluation point
-  e: G::Scalar,      // claimed evaluation
+pub struct PolyEvalInstance<E: Engine> {
+  c: Commitment<E>,  // commitment to the polynomial
+  x: Vec<E::Scalar>, // evaluation point
+  e: E::Scalar,      // claimed evaluation
 }
 
-impl<G: Group> PolyEvalInstance<G> {
-  fn pad(U: Vec<PolyEvalInstance<G>>) -> Vec<PolyEvalInstance<G>> {
+impl<E: Engine> PolyEvalInstance<E> {
+  fn pad(U: Vec<PolyEvalInstance<E>>) -> Vec<PolyEvalInstance<E>> {
     // determine the maximum size
     if let Some(ell) = U.iter().map(|u| u.x.len()).max() {
       U.into_iter()
         .map(|mut u| {
-          let mut x = vec![G::Scalar::ZERO; ell - u.x.len()];
+          let mut x = vec![E::Scalar::ZERO; ell - u.x.len()];
           x.append(&mut u.x);
           PolyEvalInstance { x, ..u }
         })
@@ -107,12 +107,12 @@ impl<G: Group> PolyEvalInstance<G> {
   }
 
   fn batch(
-    c_vec: &[Commitment<G>],
-    x: &[G::Scalar],
-    e_vec: &[G::Scalar],
-    s: &G::Scalar,
-  ) -> PolyEvalInstance<G> {
-    let powers_of_s = powers::<G>(s, c_vec.len());
+    c_vec: &[Commitment<E>],
+    x: &[E::Scalar],
+    e_vec: &[E::Scalar],
+    s: &E::Scalar,
+  ) -> PolyEvalInstance<E> {
+    let powers_of_s = powers::<E>(s, c_vec.len());
     let e = e_vec
       .par_iter()
       .zip(powers_of_s.par_iter())
@@ -122,7 +122,7 @@ impl<G: Group> PolyEvalInstance<G> {
       .par_iter()
       .zip(powers_of_s.par_iter())
       .map(|(c, p)| *c * *p)
-      .reduce(Commitment::<G>::default, |acc, item| acc + item);
+      .reduce(Commitment::<E>::default, |acc, item| acc + item);
 
     PolyEvalInstance {
       c,
diff --git a/src/spartan/polys/univariate.rs b/src/spartan/polys/univariate.rs
index afc500877..bfe983e5b 100644
--- a/src/spartan/polys/univariate.rs
+++ b/src/spartan/polys/univariate.rs
@@ -109,7 +109,10 @@ impl<Scalar: PrimeField> CompressedUniPoly<Scalar> {
 impl<G: Group> TranscriptReprTrait<G> for UniPoly<G::Scalar> {
   fn to_transcript_bytes(&self) -> Vec<u8> {
     let coeffs = self.compress().coeffs_except_linear_term;
-    coeffs.as_slice().to_transcript_bytes()
+    coeffs
+      .iter()
+      .flat_map(|&t| t.to_repr().as_ref().to_vec())
+      .collect::<Vec<u8>>()
   }
 }
 #[cfg(test)]
diff --git a/src/spartan/ppsnark.rs b/src/spartan/ppsnark.rs
index b3a83e092..1fc017d84 100644
--- a/src/spartan/ppsnark.rs
+++ b/src/spartan/ppsnark.rs
@@ -24,7 +24,7 @@ use crate::{
     commitment::{CommitmentEngineTrait, CommitmentTrait, Len},
     evaluation::EvaluationEngineTrait,
     snark::{DigestHelperTrait, RelaxedR1CSSNARKTrait},
-    Group, TranscriptEngineTrait, TranscriptReprTrait,
+    Engine, TranscriptEngineTrait, TranscriptReprTrait,
   },
   Commitment, CommitmentKey, CompressedCommitment,
 };
@@ -36,7 +36,7 @@ use once_cell::sync::OnceCell;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
-fn padded<G: Group>(v: &[G::Scalar], n: usize, e: &G::Scalar) -> Vec<G::Scalar> {
+fn padded<E: Engine>(v: &[E::Scalar], n: usize, e: &E::Scalar) -> Vec<E::Scalar> {
   let mut v_padded = vec![*e; n];
   for (i, v_i) in v.iter().enumerate() {
     v_padded[i] = *v_i;
@@ -47,49 +47,49 @@ fn padded<G: Group>(v: &[G::Scalar], n: usize, e: &G::Scalar) -> Vec<G::Scalar>
 /// A type that holds `R1CSShape` in a form amenable to memory checking
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as PrimeField>::Repr: Abomonation)]
-pub struct R1CSShapeSparkRepr<G: Group> {
+#[abomonation_bounds(where <E::Scalar as PrimeField>::Repr: Abomonation)]
+pub struct R1CSShapeSparkRepr<E: Engine> {
   N: usize, // size of the vectors
 
   // dense representation
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  row: Vec<G::Scalar>,
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  col: Vec<G::Scalar>,
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  val_A: Vec<G::Scalar>,
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  val_B: Vec<G::Scalar>,
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  val_C: Vec<G::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  row: Vec<E::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  col: Vec<E::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  val_A: Vec<E::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  val_B: Vec<E::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  val_C: Vec<E::Scalar>,
 
   // timestamp polynomials
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  ts_row: Vec<G::Scalar>,
-  #[abomonate_with(Vec<<G::Scalar as PrimeField>::Repr>)]
-  ts_col: Vec<G::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  ts_row: Vec<E::Scalar>,
+  #[abomonate_with(Vec<<E::Scalar as PrimeField>::Repr>)]
+  ts_col: Vec<E::Scalar>,
 }
 
 /// A type that holds a commitment to a sparse polynomial
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as PrimeField>::Repr: Abomonation)]
-pub struct R1CSShapeSparkCommitment<G: Group> {
+#[abomonation_bounds(where <E::Scalar as PrimeField>::Repr: Abomonation)]
+pub struct R1CSShapeSparkCommitment<E: Engine> {
   N: usize, // size of each vector
 
   // commitments to the dense representation
-  comm_row: Commitment<G>,
-  comm_col: Commitment<G>,
-  comm_val_A: Commitment<G>,
-  comm_val_B: Commitment<G>,
-  comm_val_C: Commitment<G>,
+  comm_row: Commitment<E>,
+  comm_col: Commitment<E>,
+  comm_val_A: Commitment<E>,
+  comm_val_B: Commitment<E>,
+  comm_val_C: Commitment<E>,
 
   // commitments to the timestamp polynomials
-  comm_ts_row: Commitment<G>,
-  comm_ts_col: Commitment<G>,
+  comm_ts_row: Commitment<E>,
+  comm_ts_col: Commitment<E>,
 }
 
-impl<G: Group> TranscriptReprTrait<G> for R1CSShapeSparkCommitment<G> {
+impl<E: Engine> TranscriptReprTrait<E::GE> for R1CSShapeSparkCommitment<E> {
   fn to_transcript_bytes(&self) -> Vec<u8> {
     [
       self.comm_row,
@@ -105,9 +105,9 @@ impl<G: Group> TranscriptReprTrait<G> for R1CSShapeSparkCommitment<G> {
   }
 }
 
-impl<G: Group> R1CSShapeSparkRepr<G> {
+impl<E: Engine> R1CSShapeSparkRepr<E> {
   /// represents `R1CSShape` in a Spark-friendly format amenable to memory checking
-  pub fn new(S: &R1CSShape<G>) -> R1CSShapeSparkRepr<G> {
+  pub fn new(S: &R1CSShape<E>) -> R1CSShapeSparkRepr<E> {
     let N = {
       let total_nz = S.A.len() + S.B.len() + S.C.len();
       max(total_nz, max(2 * S.num_vars, S.num_cons)).next_power_of_two()
@@ -120,7 +120,7 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
       col[i] = c;
     }
     let val_A = {
-      let mut val = vec![G::Scalar::ZERO; N];
+      let mut val = vec![E::Scalar::ZERO; N];
       for (i, (_, _, v)) in S.A.iter().enumerate() {
         val[i] = v;
       }
@@ -128,7 +128,7 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
     };
 
     let val_B = {
-      let mut val = vec![G::Scalar::ZERO; N];
+      let mut val = vec![E::Scalar::ZERO; N];
       for (i, (_, _, v)) in S.B.iter().enumerate() {
         val[S.A.len() + i] = v;
       }
@@ -136,7 +136,7 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
     };
 
     let val_C = {
-      let mut val = vec![G::Scalar::ZERO; N];
+      let mut val = vec![E::Scalar::ZERO; N];
       for (i, (_, _, v)) in S.C.iter().enumerate() {
         val[S.A.len() + S.B.len() + i] = v;
       }
@@ -160,10 +160,10 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
       rayon::join(|| timestamp_calc(N, N, &row), || timestamp_calc(N, N, &col));
 
     // a routine to turn a vector of usize into a vector scalars
-    let to_vec_scalar = |v: &[usize]| -> Vec<G::Scalar> {
+    let to_vec_scalar = |v: &[usize]| -> Vec<E::Scalar> {
       (0..v.len())
-        .map(|i| G::Scalar::from(v[i] as u64))
-        .collect::<Vec<G::Scalar>>()
+        .map(|i| E::Scalar::from(v[i] as u64))
+        .collect::<Vec<E::Scalar>>()
     };
 
     R1CSShapeSparkRepr {
@@ -182,8 +182,8 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
     }
   }
 
-  fn commit(&self, ck: &CommitmentKey<G>) -> R1CSShapeSparkCommitment<G> {
-    let comm_vec: Vec<Commitment<G>> = [
+  fn commit(&self, ck: &CommitmentKey<E>) -> R1CSShapeSparkCommitment<E> {
+    let comm_vec: Vec<Commitment<E>> = [
       &self.row,
       &self.col,
       &self.val_A,
@@ -193,7 +193,7 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
       &self.ts_col,
     ]
     .par_iter()
-    .map(|v| G::CE::commit(ck, v))
+    .map(|v| E::CE::commit(ck, v))
     .collect();
 
     R1CSShapeSparkCommitment {
@@ -211,17 +211,17 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
   // computes evaluation oracles
   fn evaluation_oracles(
     &self,
-    S: &R1CSShape<G>,
-    r_x: &G::Scalar,
-    z: &[G::Scalar],
+    S: &R1CSShape<E>,
+    r_x: &E::Scalar,
+    z: &[E::Scalar],
   ) -> (
-    Vec<G::Scalar>,
-    Vec<G::Scalar>,
-    Vec<G::Scalar>,
-    Vec<G::Scalar>,
+    Vec<E::Scalar>,
+    Vec<E::Scalar>,
+    Vec<E::Scalar>,
+    Vec<E::Scalar>,
   ) {
     let mem_row = PowPolynomial::new(r_x, self.N.log_2()).evals();
-    let mem_col = padded::<G>(z, self.N, &G::Scalar::ZERO);
+    let mem_col = padded::<E>(z, self.N, &E::Scalar::ZERO);
 
     let (L_row, L_col) = {
       let mut L_row = vec![mem_row[0]; self.N]; // we place mem_row[0] since resized row is appended with 0s
@@ -246,9 +246,9 @@ impl<G: Group> R1CSShapeSparkRepr<G> {
 }
 
 /// Defines a trait for implementing sum-check in a generic manner
-pub trait SumcheckEngine<G: Group>: Send + Sync {
+pub trait SumcheckEngine<E: Engine>: Send + Sync {
   /// returns the initial claims
-  fn initial_claims(&self) -> Vec<G::Scalar>;
+  fn initial_claims(&self) -> Vec<E::Scalar>;
 
   /// degree of the sum-check polynomial
   fn degree(&self) -> usize;
@@ -257,52 +257,52 @@ pub trait SumcheckEngine<G: Group>: Send + Sync {
   fn size(&self) -> usize;
 
   /// returns evaluation points at 0, 2, d-1 (where d is the degree of the sum-check polynomial)
-  fn evaluation_points(&self) -> Vec<Vec<G::Scalar>>;
+  fn evaluation_points(&self) -> Vec<Vec<E::Scalar>>;
 
   /// bounds a variable in the constituent polynomials
-  fn bound(&mut self, r: &G::Scalar);
+  fn bound(&mut self, r: &E::Scalar);
 
   /// returns the final claims
-  fn final_claims(&self) -> Vec<Vec<G::Scalar>>;
+  fn final_claims(&self) -> Vec<Vec<E::Scalar>>;
 }
 
-struct MemorySumcheckInstance<G: Group> {
+struct MemorySumcheckInstance<E: Engine> {
   // row
-  w_plus_r_row: MultilinearPolynomial<G::Scalar>,
-  t_plus_r_row: MultilinearPolynomial<G::Scalar>,
-  t_plus_r_inv_row: MultilinearPolynomial<G::Scalar>,
-  w_plus_r_inv_row: MultilinearPolynomial<G::Scalar>,
-  ts_row: MultilinearPolynomial<G::Scalar>,
+  w_plus_r_row: MultilinearPolynomial<E::Scalar>,
+  t_plus_r_row: MultilinearPolynomial<E::Scalar>,
+  t_plus_r_inv_row: MultilinearPolynomial<E::Scalar>,
+  w_plus_r_inv_row: MultilinearPolynomial<E::Scalar>,
+  ts_row: MultilinearPolynomial<E::Scalar>,
 
   // col
-  w_plus_r_col: MultilinearPolynomial<G::Scalar>,
-  t_plus_r_col: MultilinearPolynomial<G::Scalar>,
-  t_plus_r_inv_col: MultilinearPolynomial<G::Scalar>,
-  w_plus_r_inv_col: MultilinearPolynomial<G::Scalar>,
-  ts_col: MultilinearPolynomial<G::Scalar>,
+  w_plus_r_col: MultilinearPolynomial<E::Scalar>,
+  t_plus_r_col: MultilinearPolynomial<E::Scalar>,
+  t_plus_r_inv_col: MultilinearPolynomial<E::Scalar>,
+  w_plus_r_inv_col: MultilinearPolynomial<E::Scalar>,
+  ts_col: MultilinearPolynomial<E::Scalar>,
 
   // eq
-  poly_eq: MultilinearPolynomial<G::Scalar>,
+  poly_eq: MultilinearPolynomial<E::Scalar>,
 
   // zero polynomial
-  poly_zero: MultilinearPolynomial<G::Scalar>,
+  poly_zero: MultilinearPolynomial<E::Scalar>,
 }
 
-impl<G: Group> MemorySumcheckInstance<G> {
+impl<E: Engine> MemorySumcheckInstance<E> {
   pub fn new(
-    ck: &CommitmentKey<G>,
-    r: &G::Scalar,
-    T_row: &[G::Scalar],
-    W_row: &[G::Scalar],
-    ts_row: Vec<G::Scalar>,
-    T_col: &[G::Scalar],
-    W_col: &[G::Scalar],
-    ts_col: Vec<G::Scalar>,
-    transcript: &mut G::TE,
-  ) -> Result<(Self, [Commitment<G>; 4], [Vec<G::Scalar>; 4]), NovaError> {
-    let batch_invert = |v: &[G::Scalar]| -> Result<Vec<G::Scalar>, NovaError> {
-      let mut products = vec![G::Scalar::ZERO; v.len()];
-      let mut acc = G::Scalar::ONE;
+    ck: &CommitmentKey<E>,
+    r: & E::Scalar,
+    T_row: &[E::Scalar],
+    W_row: &[E::Scalar],
+    ts_row: Vec<E::Scalar>,
+    T_col: &[E::Scalar],
+    W_col: &[E::Scalar],
+    ts_col: Vec<E::Scalar>,
+    transcript: &mut E::TE,
+  ) -> Result<(Self, [Commitment<E>; 4], [Vec<E::Scalar>; 4]), NovaError> {
+    let batch_invert = |v: &[E::Scalar]| -> Result<Vec<E::Scalar>, NovaError> {
+      let mut products = vec![E::Scalar::ZERO; v.len()];
+      let mut acc = E::Scalar::ONE;
 
       for i in 0..v.len() {
         products[i] = acc;
@@ -310,14 +310,14 @@ impl<G: Group> MemorySumcheckInstance<G> {
       }
 
       // we can compute an inversion only if acc is non-zero
-      if acc == G::Scalar::ZERO {
+      if acc == E::Scalar::ZERO {
         return Err(NovaError::InternalError);
       }
 
       // compute the inverse once for all entries
       acc = acc.invert().unwrap();
 
-      let mut inv = vec![G::Scalar::ZERO; v.len()];
+      let mut inv = vec![E::Scalar::ZERO; v.len()];
       for i in 0..v.len() {
         let tmp = acc * v[v.len() - 1 - i];
         inv[v.len() - 1 - i] = products[v.len() - 1 - i] * acc;
@@ -328,25 +328,25 @@ impl<G: Group> MemorySumcheckInstance<G> {
     };
 
     // compute vectors TS[i]/(T[i] + r) and 1/(W[i] + r)
-    let helper = |T: &[G::Scalar],
-                  W: &[G::Scalar],
-                  TS: &[G::Scalar],
-                  r: &G::Scalar|
+    let helper = |T: &[E::Scalar],
+                  W: &[E::Scalar],
+                  TS: &[E::Scalar],
+                  r: &E::Scalar|
      -> (
       (
-        Result<Vec<G::Scalar>, NovaError>,
-        Result<Vec<G::Scalar>, NovaError>,
+        Result<Vec<E::Scalar>, NovaError>,
+        Result<Vec<E::Scalar>, NovaError>,
       ),
       (
-        Result<Vec<G::Scalar>, NovaError>,
-        Result<Vec<G::Scalar>, NovaError>,
+        Result<Vec<E::Scalar>, NovaError>,
+        Result<Vec<E::Scalar>, NovaError>,
       ),
     ) {
       rayon::join(
         || {
           rayon::join(
             || {
-              let inv = batch_invert(&T.par_iter().map(|e| *e + *r).collect::<Vec<G::Scalar>>())?;
+              let inv = batch_invert(&T.par_iter().map(|e| *e + *r).collect::<Vec<E::Scalar>>())?;
 
               // compute inv[i] * TS[i] in parallel
               Ok(
@@ -357,13 +357,13 @@ impl<G: Group> MemorySumcheckInstance<G> {
                   .collect::<Vec<_>>(),
               )
             },
-            || batch_invert(&W.par_iter().map(|e| *e + *r).collect::<Vec<G::Scalar>>()),
+            || batch_invert(&W.par_iter().map(|e| *e + *r).collect::<Vec<E::Scalar>>()),
           )
         },
         || {
           rayon::join(
-            || Ok(T.par_iter().map(|e| *e + *r).collect::<Vec<G::Scalar>>()),
-            || Ok(W.par_iter().map(|e| *e + *r).collect::<Vec<G::Scalar>>()),
+            || Ok(T.par_iter().map(|e| *e + *r).collect::<Vec<E::Scalar>>()),
+            || Ok(W.par_iter().map(|e| *e + *r).collect::<Vec<E::Scalar>>()),
           )
         },
       )
@@ -388,14 +388,14 @@ impl<G: Group> MemorySumcheckInstance<G> {
     ) = rayon::join(
       || {
         rayon::join(
-          || G::CE::commit(ck, &t_plus_r_inv_row),
-          || G::CE::commit(ck, &w_plus_r_inv_row),
+          || E::CE::commit(ck, &t_plus_r_inv_row),
+          || E::CE::commit(ck, &w_plus_r_inv_row),
         )
       },
       || {
         rayon::join(
-          || G::CE::commit(ck, &t_plus_r_inv_col),
-          || G::CE::commit(ck, &w_plus_r_inv_col),
+          || E::CE::commit(ck, &t_plus_r_inv_col),
+          || E::CE::commit(ck, &w_plus_r_inv_col),
         )
       },
     );
@@ -429,7 +429,7 @@ impl<G: Group> MemorySumcheckInstance<G> {
       w_plus_r_inv_col.clone(),
     ];
 
-    let zero = vec![G::Scalar::ZERO; t_plus_r_inv_row.len()];
+    let zero = vec![E::Scalar::ZERO; t_plus_r_inv_row.len()];
 
     Ok((
       Self {
@@ -452,9 +452,9 @@ impl<G: Group> MemorySumcheckInstance<G> {
   }
 }
 
-impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
-  fn initial_claims(&self) -> Vec<G::Scalar> {
-    vec![G::Scalar::ZERO; 6]
+impl<E: Engine> SumcheckEngine<E> for MemorySumcheckInstance<E> {
+  fn initial_claims(&self) -> Vec<E::Scalar> {
+    vec![E::Scalar::ZERO; 6]
   }
 
   fn degree(&self) -> usize {
@@ -472,29 +472,29 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
     self.w_plus_r_row.len()
   }
 
-  fn evaluation_points(&self) -> Vec<Vec<G::Scalar>> {
-    let comb_func = |poly_A_comp: &G::Scalar,
-                     poly_B_comp: &G::Scalar,
-                     _poly_C_comp: &G::Scalar|
-     -> G::Scalar { *poly_A_comp - *poly_B_comp };
+  fn evaluation_points(&self) -> Vec<Vec<E::Scalar>> {
+    let comb_func = |poly_A_comp: &E::Scalar,
+                     poly_B_comp: &E::Scalar,
+                     _poly_C_comp: &E::Scalar|
+     -> E::Scalar { *poly_A_comp - *poly_B_comp };
 
     let comb_func2 =
-      |poly_A_comp: &G::Scalar,
-       poly_B_comp: &G::Scalar,
-       poly_C_comp: &G::Scalar,
-       _poly_D_comp: &G::Scalar|
-       -> G::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - G::Scalar::ONE) };
+      |poly_A_comp: &E::Scalar,
+       poly_B_comp: &E::Scalar,
+       poly_C_comp: &E::Scalar,
+       _poly_D_comp: &E::Scalar|
+       -> E::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - E::Scalar::ONE) };
 
     let comb_func3 =
-      |poly_A_comp: &G::Scalar,
-       poly_B_comp: &G::Scalar,
-       poly_C_comp: &G::Scalar,
-       poly_D_comp: &G::Scalar|
-       -> G::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
+      |poly_A_comp: &E::Scalar,
+       poly_B_comp: &E::Scalar,
+       poly_C_comp: &E::Scalar,
+       poly_D_comp: &E::Scalar|
+       -> E::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
 
     // inv related evaluation points
     let (eval_inv_0_row, eval_inv_2_row, eval_inv_3_row) =
-      SumcheckProof::<G>::compute_eval_points_cubic(
+      SumcheckProof::<E>::compute_eval_points_cubic(
         &self.t_plus_r_inv_row,
         &self.w_plus_r_inv_row,
         &self.poly_zero,
@@ -502,7 +502,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
       );
 
     let (eval_inv_0_col, eval_inv_2_col, eval_inv_3_col) =
-      SumcheckProof::<G>::compute_eval_points_cubic(
+      SumcheckProof::<E>::compute_eval_points_cubic(
         &self.t_plus_r_inv_col,
         &self.w_plus_r_inv_col,
         &self.poly_zero,
@@ -511,7 +511,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
 
     // row related evaluation points
     let (eval_T_0_row, eval_T_2_row, eval_T_3_row) =
-      SumcheckProof::<G>::compute_eval_points_cubic_with_additive_term(
+      SumcheckProof::<E>::compute_eval_points_cubic_with_additive_term(
         &self.poly_eq,
         &self.t_plus_r_inv_row,
         &self.t_plus_r_row,
@@ -519,7 +519,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
         &comb_func3,
       );
     let (eval_W_0_row, eval_W_2_row, eval_W_3_row) =
-      SumcheckProof::<G>::compute_eval_points_cubic_with_additive_term(
+      SumcheckProof::<E>::compute_eval_points_cubic_with_additive_term(
         &self.poly_eq,
         &self.w_plus_r_inv_row,
         &self.w_plus_r_row,
@@ -529,7 +529,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
 
     // column related evaluation points
     let (eval_T_0_col, eval_T_2_col, eval_T_3_col) =
-      SumcheckProof::<G>::compute_eval_points_cubic_with_additive_term(
+      SumcheckProof::<E>::compute_eval_points_cubic_with_additive_term(
         &self.poly_eq,
         &self.t_plus_r_inv_col,
         &self.t_plus_r_col,
@@ -537,7 +537,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
         &comb_func3,
       );
     let (eval_W_0_col, eval_W_2_col, eval_W_3_col) =
-      SumcheckProof::<G>::compute_eval_points_cubic_with_additive_term(
+      SumcheckProof::<E>::compute_eval_points_cubic_with_additive_term(
         &self.poly_eq,
         &self.w_plus_r_inv_col,
         &self.w_plus_r_col,
@@ -555,7 +555,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
     ]
   }
 
-  fn bound(&mut self, r: &G::Scalar) {
+  fn bound(&mut self, r: &E::Scalar) {
     [
       &mut self.t_plus_r_row,
       &mut self.t_plus_r_inv_row,
@@ -573,7 +573,7 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
     .for_each(|poly| poly.bind_poly_var_top(r));
   }
 
-  fn final_claims(&self) -> Vec<Vec<G::Scalar>> {
+  fn final_claims(&self) -> Vec<Vec<E::Scalar>> {
     let poly_row_final = vec![
       self.t_plus_r_inv_row[0],
       self.w_plus_r_inv_row[0],
@@ -590,28 +590,28 @@ impl<G: Group> SumcheckEngine<G> for MemorySumcheckInstance<G> {
   }
 }
 
-struct OuterSumcheckInstance<G: Group> {
-  poly_tau: MultilinearPolynomial<G::Scalar>,
-  poly_Az: MultilinearPolynomial<G::Scalar>,
-  poly_Bz: MultilinearPolynomial<G::Scalar>,
-  poly_uCz_E: MultilinearPolynomial<G::Scalar>,
+struct OuterSumcheckInstance<E: Engine> {
+  poly_tau: MultilinearPolynomial<E::Scalar>,
+  poly_Az: MultilinearPolynomial<E::Scalar>,
+  poly_Bz: MultilinearPolynomial<E::Scalar>,
+  poly_uCz_E: MultilinearPolynomial<E::Scalar>,
 
-  poly_Mz: MultilinearPolynomial<G::Scalar>,
-  eval_Mz_at_tau: G::Scalar,
+  poly_Mz: MultilinearPolynomial<E::Scalar>,
+  eval_Mz_at_tau: E::Scalar,
 
-  poly_zero: MultilinearPolynomial<G::Scalar>,
+  poly_zero: MultilinearPolynomial<E::Scalar>,
 }
 
-impl<G: Group> OuterSumcheckInstance<G> {
+impl<E: Engine> OuterSumcheckInstance<E> {
   pub fn new(
-    tau: Vec<G::Scalar>,
-    Az: Vec<G::Scalar>,
-    Bz: Vec<G::Scalar>,
-    uCz_E: Vec<G::Scalar>,
-    Mz: Vec<G::Scalar>,
-    eval_Mz_at_tau: &G::Scalar,
+    tau: Vec<E::Scalar>,
+    Az: Vec<E::Scalar>,
+    Bz: Vec<E::Scalar>,
+    uCz_E: Vec<E::Scalar>,
+    Mz: Vec<E::Scalar>,
+    eval_Mz_at_tau: &E::Scalar,
   ) -> Self {
-    let zero = vec![G::Scalar::ZERO; tau.len()];
+    let zero = vec![E::Scalar::ZERO; tau.len()];
     Self {
       poly_tau: MultilinearPolynomial::new(tau),
       poly_Az: MultilinearPolynomial::new(Az),
@@ -624,9 +624,9 @@ impl<G: Group> OuterSumcheckInstance<G> {
   }
 }
 
-impl<G: Group> SumcheckEngine<G> for OuterSumcheckInstance<G> {
-  fn initial_claims(&self) -> Vec<G::Scalar> {
-    vec![G::Scalar::ZERO, self.eval_Mz_at_tau]
+impl<E: Engine> SumcheckEngine<E> for OuterSumcheckInstance<E> {
+  fn initial_claims(&self) -> Vec<E::Scalar> {
+    vec![E::Scalar::ZERO, self.eval_Mz_at_tau]
   }
 
   fn degree(&self) -> usize {
@@ -641,16 +641,16 @@ impl<G: Group> SumcheckEngine<G> for OuterSumcheckInstance<G> {
     self.poly_tau.len()
   }
 
-  fn evaluation_points(&self) -> Vec<Vec<G::Scalar>> {
+  fn evaluation_points(&self) -> Vec<Vec<E::Scalar>> {
     let comb_func =
-      |poly_A_comp: &G::Scalar,
-       poly_B_comp: &G::Scalar,
-       poly_C_comp: &G::Scalar,
-       poly_D_comp: &G::Scalar|
-       -> G::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
+      |poly_A_comp: &E::Scalar,
+       poly_B_comp: &E::Scalar,
+       poly_C_comp: &E::Scalar,
+       poly_D_comp: &E::Scalar|
+       -> E::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
 
     let (eval_point_h_0, eval_point_h_2, eval_point_h_3) =
-      SumcheckProof::<G>::compute_eval_points_cubic_with_additive_term(
+      SumcheckProof::<E>::compute_eval_points_cubic_with_additive_term(
         &self.poly_tau,
         &self.poly_Az,
         &self.poly_Bz,
@@ -658,13 +658,13 @@ impl<G: Group> SumcheckEngine<G> for OuterSumcheckInstance<G> {
         &comb_func,
       );
 
-    let comb_func2 = |poly_A_comp: &G::Scalar,
-                      poly_B_comp: &G::Scalar,
-                      _poly_C_comp: &G::Scalar|
-     -> G::Scalar { *poly_A_comp * *poly_B_comp };
+    let comb_func2 = |poly_A_comp: &E::Scalar,
+                      poly_B_comp: &E::Scalar,
+                      _poly_C_comp: &E::Scalar|
+     -> E::Scalar { *poly_A_comp * *poly_B_comp };
 
     let (eval_point_e_0, eval_point_e_2, eval_point_e_3) =
-      SumcheckProof::<G>::compute_eval_points_cubic(
+      SumcheckProof::<E>::compute_eval_points_cubic(
         &self.poly_tau,
         &self.poly_Mz,
         &self.poly_zero,
@@ -677,7 +677,7 @@ impl<G: Group> SumcheckEngine<G> for OuterSumcheckInstance<G> {
     ]
   }
 
-  fn bound(&mut self, r: &G::Scalar) {
+  fn bound(&mut self, r: &E::Scalar) {
     [
       &mut self.poly_tau,
       &mut self.poly_Az,
@@ -689,20 +689,20 @@ impl<G: Group> SumcheckEngine<G> for OuterSumcheckInstance<G> {
     .for_each(|poly| poly.bind_poly_var_top(r));
   }
 
-  fn final_claims(&self) -> Vec<Vec<G::Scalar>> {
+  fn final_claims(&self) -> Vec<Vec<E::Scalar>> {
     vec![vec![self.poly_Az[0], self.poly_Bz[0]]]
   }
 }
 
-struct InnerSumcheckInstance<G: Group> {
-  claim: G::Scalar,
-  poly_L_row: MultilinearPolynomial<G::Scalar>,
-  poly_L_col: MultilinearPolynomial<G::Scalar>,
-  poly_val: MultilinearPolynomial<G::Scalar>,
+struct InnerSumcheckInstance<E: Engine> {
+  claim: E::Scalar,
+  poly_L_row: MultilinearPolynomial<E::Scalar>,
+  poly_L_col: MultilinearPolynomial<E::Scalar>,
+  poly_val: MultilinearPolynomial<E::Scalar>,
 }
 
-impl<G: Group> SumcheckEngine<G> for InnerSumcheckInstance<G> {
-  fn initial_claims(&self) -> Vec<G::Scalar> {
+impl<E: Engine> SumcheckEngine<E> for InnerSumcheckInstance<E> {
+  fn initial_claims(&self) -> Vec<E::Scalar> {
     vec![self.claim]
   }
 
@@ -716,20 +716,20 @@ impl<G: Group> SumcheckEngine<G> for InnerSumcheckInstance<G> {
     self.poly_L_row.len()
   }
 
-  fn evaluation_points(&self) -> Vec<Vec<G::Scalar>> {
+  fn evaluation_points(&self) -> Vec<Vec<E::Scalar>> {
     let (poly_A, poly_B, poly_C) = (&self.poly_L_row, &self.poly_L_col, &self.poly_val);
-    let comb_func = |poly_A_comp: &G::Scalar,
-                     poly_B_comp: &G::Scalar,
-                     poly_C_comp: &G::Scalar|
-     -> G::Scalar { *poly_A_comp * *poly_B_comp * *poly_C_comp };
+    let comb_func = |poly_A_comp: &E::Scalar,
+                     poly_B_comp: &E::Scalar,
+                     poly_C_comp: &E::Scalar|
+     -> E::Scalar { *poly_A_comp * *poly_B_comp * *poly_C_comp };
 
     let (eval_point_0, eval_point_2, eval_point_3) =
-      SumcheckProof::<G>::compute_eval_points_cubic(poly_A, poly_B, poly_C, &comb_func);
+      SumcheckProof::<E>::compute_eval_points_cubic(poly_A, poly_B, poly_C, &comb_func);
 
     vec![vec![eval_point_0, eval_point_2, eval_point_3]]
   }
 
-  fn bound(&mut self, r: &G::Scalar) {
+  fn bound(&mut self, r: &E::Scalar) {
     [
       &mut self.poly_L_row,
       &mut self.poly_L_col,
@@ -739,7 +739,7 @@ impl<G: Group> SumcheckEngine<G> for InnerSumcheckInstance<G> {
     .for_each(|poly| poly.bind_poly_var_top(r));
   }
 
-  fn final_claims(&self) -> Vec<Vec<G::Scalar>> {
+  fn final_claims(&self) -> Vec<Vec<E::Scalar>> {
     vec![vec![self.poly_L_row[0], self.poly_L_col[0]]]
   }
 }
@@ -747,109 +747,109 @@ impl<G: Group> SumcheckEngine<G> for InnerSumcheckInstance<G> {
 /// A type that represents the prover's key
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as PrimeField>::Repr: Abomonation)]
-pub struct ProverKey<G: Group, EE: EvaluationEngineTrait<G>> {
+#[abomonation_bounds(where <E::Scalar as PrimeField>::Repr: Abomonation)]
+pub struct ProverKey<E: Engine, EE: EvaluationEngineTrait<E>> {
   pk_ee: EE::ProverKey,
-  S_repr: R1CSShapeSparkRepr<G>,
-  S_comm: R1CSShapeSparkCommitment<G>,
-  #[abomonate_with(<G::Scalar as PrimeField>::Repr)]
-  vk_digest: G::Scalar, // digest of verifier's key
+  S_repr: R1CSShapeSparkRepr<E>,
+  S_comm: R1CSShapeSparkCommitment<E>,
+  #[abomonate_with(<E::Scalar as PrimeField>::Repr)]
+  vk_digest: E::Scalar, // digest of verifier's key
 }
 
 /// A type that represents the verifier's key
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as PrimeField>::Repr: Abomonation)]
-pub struct VerifierKey<G: Group, EE: EvaluationEngineTrait<G>> {
+#[abomonation_bounds(where <E::Scalar as PrimeField>::Repr: Abomonation)]
+pub struct VerifierKey<E: Engine, EE: EvaluationEngineTrait<E>> {
   num_cons: usize,
   num_vars: usize,
   vk_ee: EE::VerifierKey,
-  S_comm: R1CSShapeSparkCommitment<G>,
+  S_comm: R1CSShapeSparkCommitment<E>,
   #[abomonation_skip]
   #[serde(skip, default = "OnceCell::new")]
-  digest: OnceCell<G::Scalar>,
+  digest: OnceCell<E::Scalar>,
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> SimpleDigestible for VerifierKey<G, EE> {}
+impl<E: Engine, EE: EvaluationEngineTrait<E>> SimpleDigestible for VerifierKey<E, EE> {}
 
 /// A succinct proof of knowledge of a witness to a relaxed R1CS instance
 /// The proof is produced using Spartan's combination of the sum-check and
 /// the commitment to a vector viewed as a polynomial commitment
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct RelaxedR1CSSNARK<G: Group, EE: EvaluationEngineTrait<G>> {
+pub struct RelaxedR1CSSNARK<E: Engine, EE: EvaluationEngineTrait<E>> {
   // commitment to oracles: the first three are for Az, Bz, Cz,
   // and the last two are for memory reads
-  comm_Az: CompressedCommitment<G>,
-  comm_Bz: CompressedCommitment<G>,
-  comm_Cz: CompressedCommitment<G>,
-  comm_L_row: CompressedCommitment<G>,
-  comm_L_col: CompressedCommitment<G>,
+  comm_Az: CompressedCommitment<E>,
+  comm_Bz: CompressedCommitment<E>,
+  comm_Cz: CompressedCommitment<E>,
+  comm_L_row: CompressedCommitment<E>,
+  comm_L_col: CompressedCommitment<E>,
 
   // commitments to aid the memory checks
-  comm_t_plus_r_inv_row: CompressedCommitment<G>,
-  comm_w_plus_r_inv_row: CompressedCommitment<G>,
-  comm_t_plus_r_inv_col: CompressedCommitment<G>,
-  comm_w_plus_r_inv_col: CompressedCommitment<G>,
+  comm_t_plus_r_inv_row: CompressedCommitment<E>,
+  comm_w_plus_r_inv_row: CompressedCommitment<E>,
+  comm_t_plus_r_inv_col: CompressedCommitment<E>,
+  comm_w_plus_r_inv_col: CompressedCommitment<E>,
 
   // claims about Az, Bz, and Cz polynomials
-  eval_Az_at_tau: G::Scalar,
-  eval_Bz_at_tau: G::Scalar,
-  eval_Cz_at_tau: G::Scalar,
+  eval_Az_at_tau: E::Scalar,
+  eval_Bz_at_tau: E::Scalar,
+  eval_Cz_at_tau: E::Scalar,
 
   // sum-check
-  sc: SumcheckProof<G>,
+  sc: SumcheckProof<E>,
 
   // claims from the end of sum-check
-  eval_Az: G::Scalar,
-  eval_Bz: G::Scalar,
-  eval_Cz: G::Scalar,
-  eval_E: G::Scalar,
-  eval_L_row: G::Scalar,
-  eval_L_col: G::Scalar,
-  eval_val_A: G::Scalar,
-  eval_val_B: G::Scalar,
-  eval_val_C: G::Scalar,
-
-  eval_W: G::Scalar,
-
-  eval_t_plus_r_inv_row: G::Scalar,
-  eval_row: G::Scalar, // address
-  eval_w_plus_r_inv_row: G::Scalar,
-  eval_ts_row: G::Scalar,
-
-  eval_t_plus_r_inv_col: G::Scalar,
-  eval_col: G::Scalar, // address
-  eval_w_plus_r_inv_col: G::Scalar,
-  eval_ts_col: G::Scalar,
+  eval_Az: E::Scalar,
+  eval_Bz: E::Scalar,
+  eval_Cz: E::Scalar,
+  eval_E: E::Scalar,
+  eval_L_row: E::Scalar,
+  eval_L_col: E::Scalar,
+  eval_val_A: E::Scalar,
+  eval_val_B: E::Scalar,
+  eval_val_C: E::Scalar,
+
+  eval_W: E::Scalar,
+
+  eval_t_plus_r_inv_row: E::Scalar,
+  eval_row: E::Scalar, // address
+  eval_w_plus_r_inv_row: E::Scalar,
+  eval_ts_row: E::Scalar,
+
+  eval_t_plus_r_inv_col: E::Scalar,
+  eval_col: E::Scalar, // address
+  eval_w_plus_r_inv_col: E::Scalar,
+  eval_ts_col: E::Scalar,
 
   // a PCS evaluation argument
   eval_arg: EE::EvaluationArgument,
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> RelaxedR1CSSNARK<G, EE>
+impl<E: Engine, EE: EvaluationEngineTrait<E>> RelaxedR1CSSNARK<E, EE> 
 where
-  <G::Scalar as PrimeField>::Repr: Abomonation,
+  <E::Scalar as PrimeField>::Repr: Abomonation,
 {
   fn prove_helper<T1, T2, T3>(
     mem: &mut T1,
     outer: &mut T2,
     inner: &mut T3,
-    transcript: &mut G::TE,
+    transcript: &mut E::TE,
   ) -> Result<
     (
-      SumcheckProof<G>,
-      Vec<G::Scalar>,
-      Vec<Vec<G::Scalar>>,
-      Vec<Vec<G::Scalar>>,
-      Vec<Vec<G::Scalar>>,
+      SumcheckProof<E>,
+      Vec<E::Scalar>,
+      Vec<Vec<E::Scalar>>,
+      Vec<Vec<E::Scalar>>,
+      Vec<Vec<E::Scalar>>,
     ),
     NovaError,
   >
   where
-    T1: SumcheckEngine<G>,
-    T2: SumcheckEngine<G>,
-    T3: SumcheckEngine<G>,
+    T1: SumcheckEngine<E>,
+    T2: SumcheckEngine<E>,
+    T3: SumcheckEngine<E>,
   {
     // sanity checks
     assert_eq!(mem.size(), outer.size());
@@ -863,10 +863,10 @@ where
       .into_iter()
       .chain(outer.initial_claims())
       .chain(inner.initial_claims())
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
 
     let s = transcript.squeeze(b"r")?;
-    let coeffs = powers::<G>(&s, claims.len());
+    let coeffs = powers::<E>(&s, claims.len());
 
     // compute the joint claim
     let claim = claims
@@ -876,8 +876,8 @@ where
       .sum();
 
     let mut e = claim;
-    let mut r: Vec<G::Scalar> = Vec::new();
-    let mut cubic_polys: Vec<CompressedUniPoly<G::Scalar>> = Vec::new();
+    let mut r: Vec<E::Scalar> = Vec::new();
+    let mut cubic_polys: Vec<CompressedUniPoly<E::Scalar>> = Vec::new();
     let num_rounds = mem.size().log_2();
     for _ in 0..num_rounds {
       let (evals_mem, (evals_outer, evals_inner)) = rayon::join(
@@ -885,11 +885,11 @@ where
         || rayon::join(|| outer.evaluation_points(), || inner.evaluation_points()),
       );
 
-      let evals: Vec<Vec<G::Scalar>> = evals_mem
+      let evals: Vec<Vec<E::Scalar>> = evals_mem
         .into_iter()
         .chain(evals_outer.into_iter())
         .chain(evals_inner.into_iter())
-        .collect::<Vec<Vec<G::Scalar>>>();
+        .collect::<Vec<Vec<E::Scalar>>>();
       assert_eq!(evals.len(), claims.len());
 
       let evals_combined_0 = (0..evals.len()).map(|i| evals[i][0] * coeffs[i]).sum();
@@ -934,11 +934,11 @@ where
   }
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> VerifierKey<G, EE> {
+impl<E: Engine, EE: EvaluationEngineTrait<E>> VerifierKey<E, EE> {
   fn new(
     num_cons: usize,
     num_vars: usize,
-    S_comm: R1CSShapeSparkCommitment<G>,
+    S_comm: R1CSShapeSparkCommitment<E>,
     vk_ee: EE::VerifierKey,
   ) -> Self {
     VerifierKey {
@@ -950,9 +950,9 @@ impl<G: Group, EE: EvaluationEngineTrait<G>> VerifierKey<G, EE> {
     }
   }
 }
-impl<G: Group, EE: EvaluationEngineTrait<G>> DigestHelperTrait<G> for VerifierKey<G, EE> {
+impl<E: Engine, EE: EvaluationEngineTrait<E>> DigestHelperTrait<E> for VerifierKey<E, EE> {
   /// Returns the digest of the verifier's key
-  fn digest(&self) -> G::Scalar {
+  fn digest(&self) -> E::Scalar {
     self
       .digest
       .get_or_try_init(|| {
@@ -964,23 +964,23 @@ impl<G: Group, EE: EvaluationEngineTrait<G>> DigestHelperTrait<G> for VerifierKe
   }
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> RelaxedR1CSSNARKTrait<G> for RelaxedR1CSSNARK<G, EE>
+impl<E: Engine, EE: EvaluationEngineTrait<E>> RelaxedR1CSSNARKTrait<E> for RelaxedR1CSSNARK<E, EE> 
 where
-  <G::Scalar as PrimeField>::Repr: Abomonation,
+  <E::Scalar as PrimeField>::Repr: Abomonation,
 {
-  type ProverKey = ProverKey<G, EE>;
-  type VerifierKey = VerifierKey<G, EE>;
+  type ProverKey = ProverKey<E, EE>;
+  type VerifierKey = VerifierKey<E, EE>;
 
-  fn ck_floor() -> Box<dyn for<'a> Fn(&'a R1CSShape<G>) -> usize> {
-    Box::new(|shape: &R1CSShape<G>| -> usize {
+  fn ck_floor() -> Box<dyn for<'a> Fn(&'a R1CSShape<E>) -> usize> {
+    Box::new(|shape: &R1CSShape<E>| -> usize {
       // the commitment key should be large enough to commit to the R1CS matrices
       shape.A.len() + shape.B.len() + shape.C.len()
     })
   }
 
   fn setup(
-    ck: &CommitmentKey<G>,
-    S: &R1CSShape<G>,
+    ck: &CommitmentKey<E>,
+    S: &R1CSShape<E>,
   ) -> Result<(Self::ProverKey, Self::VerifierKey), NovaError> {
     // check the provided commitment key meets minimal requirements
     if ck.length() < Self::ck_floor()(S) {
@@ -1009,11 +1009,11 @@ where
   /// produces a succinct proof of satisfiability of a `RelaxedR1CS` instance
   #[tracing::instrument(skip_all, name = "PPSNARK::prove")]
   fn prove(
-    ck: &CommitmentKey<G>,
+    ck: &CommitmentKey<E>,
     pk: &Self::ProverKey,
-    S: &R1CSShape<G>,
-    U: &RelaxedR1CSInstance<G>,
-    W: &RelaxedR1CSWitness<G>,
+    S: &R1CSShape<E>,
+    U: &RelaxedR1CSInstance<E>,
+    W: &RelaxedR1CSWitness<E>,
   ) -> Result<Self, NovaError> {
     // pad the R1CSShape
     let S = S.pad();
@@ -1021,7 +1021,7 @@ where
     assert!(S.is_regular_shape());
 
     let W = W.pad(&S); // pad the witness
-    let mut transcript = G::TE::new(b"RelaxedR1CSSNARK");
+    let mut transcript = E::TE::new(b"RelaxedR1CSSNARK");
 
     // append the verifier key (which includes commitment to R1CS matrices) and the RelaxedR1CSInstance to the transcript
     transcript.absorb(b"vk", &pk.vk_digest);
@@ -1035,8 +1035,8 @@ where
 
     // commit to Az, Bz, Cz
     let (comm_Az, (comm_Bz, comm_Cz)) = rayon::join(
-      || G::CE::commit(ck, &Az),
-      || rayon::join(|| G::CE::commit(ck, &Bz), || G::CE::commit(ck, &Cz)),
+      || E::CE::commit(ck, &Az),
+      || rayon::join(|| E::CE::commit(ck, &Bz), || E::CE::commit(ck, &Cz)),
     );
 
     transcript.absorb(b"c", &[comm_Az, comm_Bz, comm_Cz].as_slice());
@@ -1048,11 +1048,11 @@ where
 
     // (1) send commitments to Az, Bz, and Cz along with their evaluations at tau
     let (Az, Bz, Cz, W, E) = {
-      Az.resize(pk.S_repr.N, G::Scalar::ZERO);
-      Bz.resize(pk.S_repr.N, G::Scalar::ZERO);
-      Cz.resize(pk.S_repr.N, G::Scalar::ZERO);
-      let E = padded::<G>(&W.E, pk.S_repr.N, &G::Scalar::ZERO);
-      let W = padded::<G>(&W.W, pk.S_repr.N, &G::Scalar::ZERO);
+      Az.resize(pk.S_repr.N, E::Scalar::ZERO);
+      Bz.resize(pk.S_repr.N, E::Scalar::ZERO);
+      Cz.resize(pk.S_repr.N, E::Scalar::ZERO);
+      let E = padded::<E>(&W.E, pk.S_repr.N, &E::Scalar::ZERO);
+      let W = padded::<E>(&W.W, pk.S_repr.N, &E::Scalar::ZERO);
 
       (Az, Bz, Cz, W, E)
     };
@@ -1060,7 +1060,7 @@ where
       let evals_at_tau = [&Az, &Bz, &Cz]
         .into_par_iter()
         .map(|p| MultilinearPolynomial::evaluate_with(p, &tau_coords))
-        .collect::<Vec<G::Scalar>>();
+        .collect::<Vec<E::Scalar>>();
       (evals_at_tau[0], evals_at_tau[1], evals_at_tau[2])
     };
 
@@ -1069,7 +1069,7 @@ where
     // L_col(i) = z(col(i)) for all i
     let (mem_row, mem_col, L_row, L_col) = pk.S_repr.evaluation_oracles(&S, &tau, &z);
     let (comm_L_row, comm_L_col) =
-      rayon::join(|| G::CE::commit(ck, &L_row), || G::CE::commit(ck, &L_col));
+      rayon::join(|| E::CE::commit(ck, &L_row), || E::CE::commit(ck, &L_col));
 
     // absorb the claimed evaluations into the transcript
     transcript.absorb(
@@ -1086,8 +1086,8 @@ where
     let poly_vec = vec![&Az, &Bz, &Cz];
     transcript.absorb(b"e", &eval_vec.as_slice()); // c_vec is already in the transcript
     let c = transcript.squeeze(b"c")?;
-    let w: PolyEvalWitness<G> = PolyEvalWitness::batch(&poly_vec, &c);
-    let u: PolyEvalInstance<G> = PolyEvalInstance::batch(&comm_vec, &tau_coords, &eval_vec, &c);
+    let w: PolyEvalWitness<E> = PolyEvalWitness::batch(&poly_vec, &c);
+    let u: PolyEvalInstance<E> = PolyEvalInstance::batch(&comm_vec, &tau_coords, &eval_vec, &c);
 
     // we now need to prove three claims
     // (1) 0 = \sum_x poly_tau(x) * (poly_Az(x) * poly_Bz(x) - poly_uCz_E(x)), and eval_Az_at_tau + r * eval_Bz_at_tau + r^2 * eval_Cz_at_tau = (Az+r*Bz+r^2*Cz)(tau)
@@ -1105,7 +1105,7 @@ where
           Bz.clone(),
           (0..Cz.len())
             .map(|i| U.u * Cz[i] + E[i])
-            .collect::<Vec<G::Scalar>>(),
+            .collect::<Vec<E::Scalar>>(),
           w.p.clone(), // Mz = Az + r * Bz + r^2 * Cz
           &u.e,        // eval_Az_at_tau + r * eval_Az_at_tau + r^2 * eval_Cz_at_tau
         );
@@ -1118,7 +1118,7 @@ where
           .zip(pk.S_repr.val_B.par_iter())
           .zip(pk.S_repr.val_C.par_iter())
           .map(|((v_a, v_b), v_c)| *v_a + c * *v_b + c * c * *v_c)
-          .collect::<Vec<G::Scalar>>();
+          .collect::<Vec<E::Scalar>>();
         let inner_sc_inst = InnerSumcheckInstance {
           claim: eval_Az_at_tau + c * eval_Bz_at_tau + c * c * eval_Cz_at_tau,
           poly_L_row: MultilinearPolynomial::new(L_row.clone()),
@@ -1133,22 +1133,22 @@ where
         // we now need to prove that L_row and L_col are well-formed
 
         // hash the tuples of (addr,val) memory contents and read responses into a single field element using `hash_func`
-        let hash_func_vec = |mem: &[G::Scalar],
-                             addr: &[G::Scalar],
-                             lookups: &[G::Scalar]|
-         -> (Vec<G::Scalar>, Vec<G::Scalar>) {
-          let hash_func = |addr: &G::Scalar, val: &G::Scalar| -> G::Scalar { *val * gamma + *addr };
+        let hash_func_vec = |mem: &[E::Scalar],
+                             addr: &[E::Scalar],
+                             lookups: &[E::Scalar]|
+         -> (Vec<E::Scalar>, Vec<E::Scalar>) {
+          let hash_func = |addr: &E::Scalar, val: &E::Scalar| -> E::Scalar { *val * gamma + *addr };
           assert_eq!(addr.len(), lookups.len());
           rayon::join(
             || {
               (0..mem.len())
-                .map(|i| hash_func(&G::Scalar::from(i as u64), &mem[i]))
-                .collect::<Vec<G::Scalar>>()
+                .map(|i| hash_func(&E::Scalar::from(i as u64), &mem[i]))
+                .collect::<Vec<E::Scalar>>()
             },
             || {
               (0..addr.len())
                 .map(|i| hash_func(&addr[i], &lookups[i]))
-                .collect::<Vec<G::Scalar>>()
+                .collect::<Vec<E::Scalar>>()
             },
           )
         };
@@ -1210,7 +1210,7 @@ where
       ]
       .into_par_iter()
       .map(|p| MultilinearPolynomial::evaluate_with(p, &rand_sc))
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
       (e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7])
     };
 
@@ -1236,7 +1236,7 @@ where
       eval_ts_col,
     ]
     .into_iter()
-    .collect::<Vec<G::Scalar>>();
+    .collect::<Vec<E::Scalar>>();
 
     let comm_vec = [
       U.comm_W,
@@ -1280,8 +1280,8 @@ where
     ];
     transcript.absorb(b"e", &eval_vec.as_slice()); // comm_vec is already in the transcript
     let c = transcript.squeeze(b"c")?;
-    let w: PolyEvalWitness<G> = PolyEvalWitness::batch(&poly_vec, &c);
-    let u: PolyEvalInstance<G> = PolyEvalInstance::batch(&comm_vec, &rand_sc, &eval_vec, &c);
+    let w: PolyEvalWitness<E> = PolyEvalWitness::batch(&poly_vec, &c);
+    let u: PolyEvalInstance<E> = PolyEvalInstance::batch(&comm_vec, &rand_sc, &eval_vec, &c);
 
     let eval_arg = EE::prove(ck, &pk.pk_ee, &mut transcript, &u.c, &w.p, &rand_sc, &u.e)?;
 
@@ -1330,22 +1330,22 @@ where
   }
 
   /// verifies a proof of satisfiability of a `RelaxedR1CS` instance
-  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<G>) -> Result<(), NovaError> {
-    let mut transcript = G::TE::new(b"RelaxedR1CSSNARK");
+  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<E>) -> Result<(), NovaError> {
+    let mut transcript = E::TE::new(b"RelaxedR1CSSNARK");
 
     // append the verifier key (including commitment to R1CS matrices) and the RelaxedR1CSInstance to the transcript
     transcript.absorb(b"vk", &vk.digest());
     transcript.absorb(b"U", U);
 
-    let comm_Az = Commitment::<G>::decompress(&self.comm_Az)?;
-    let comm_Bz = Commitment::<G>::decompress(&self.comm_Bz)?;
-    let comm_Cz = Commitment::<G>::decompress(&self.comm_Cz)?;
-    let comm_L_row = Commitment::<G>::decompress(&self.comm_L_row)?;
-    let comm_L_col = Commitment::<G>::decompress(&self.comm_L_col)?;
-    let comm_t_plus_r_inv_row = Commitment::<G>::decompress(&self.comm_t_plus_r_inv_row)?;
-    let comm_w_plus_r_inv_row = Commitment::<G>::decompress(&self.comm_w_plus_r_inv_row)?;
-    let comm_t_plus_r_inv_col = Commitment::<G>::decompress(&self.comm_t_plus_r_inv_col)?;
-    let comm_w_plus_r_inv_col = Commitment::<G>::decompress(&self.comm_w_plus_r_inv_col)?;
+    let comm_Az = Commitment::<E>::decompress(&self.comm_Az)?;
+    let comm_Bz = Commitment::<E>::decompress(&self.comm_Bz)?;
+    let comm_Cz = Commitment::<E>::decompress(&self.comm_Cz)?;
+    let comm_L_row = Commitment::<E>::decompress(&self.comm_L_row)?;
+    let comm_L_col = Commitment::<E>::decompress(&self.comm_L_col)?;
+    let comm_t_plus_r_inv_row = Commitment::<E>::decompress(&self.comm_t_plus_r_inv_row)?;
+    let comm_w_plus_r_inv_row = Commitment::<E>::decompress(&self.comm_w_plus_r_inv_row)?;
+    let comm_t_plus_r_inv_col = Commitment::<E>::decompress(&self.comm_t_plus_r_inv_col)?;
+    let comm_w_plus_r_inv_col = Commitment::<E>::decompress(&self.comm_w_plus_r_inv_col)?;
 
     transcript.absorb(b"c", &[comm_Az, comm_Bz, comm_Cz].as_slice());
 
@@ -1376,7 +1376,7 @@ where
     let comm_vec = vec![comm_Az, comm_Bz, comm_Cz];
     transcript.absorb(b"e", &eval_vec.as_slice()); // c_vec is already in the transcript
     let c = transcript.squeeze(b"c")?;
-    let u: PolyEvalInstance<G> = PolyEvalInstance::batch(&comm_vec, &tau_coords, &eval_vec, &c);
+    let u: PolyEvalInstance<E> = PolyEvalInstance::batch(&comm_vec, &tau_coords, &eval_vec, &c);
     let claim = u.e;
 
     let gamma = transcript.squeeze(b"g")?;
@@ -1398,7 +1398,7 @@ where
 
     let num_claims = 9;
     let s = transcript.squeeze(b"r")?;
-    let coeffs = powers::<G>(&s, num_claims);
+    let coeffs = powers::<E>(&s, num_claims);
     let claim = (coeffs[7] + coeffs[8]) * claim; // rest are zeros
 
     // verify sc
@@ -1435,9 +1435,9 @@ where
           let (factor, rand_sc_unpad) = {
             let l = vk.S_comm.N.log_2() - (2 * vk.num_vars).log_2();
 
-            let mut factor = G::Scalar::ONE;
+            let mut factor = E::Scalar::ONE;
             for r_p in rand_sc.iter().take(l) {
-              factor *= G::Scalar::ONE - r_p
+              factor *= E::Scalar::ONE - r_p
             }
 
             let rand_sc_unpad = {
@@ -1455,7 +1455,7 @@ where
             poly_X.extend(
               (0..U.X.len())
                 .map(|i| (i + 1, U.X[i]))
-                .collect::<Vec<(usize, G::Scalar)>>(),
+                .collect::<Vec<(usize, E::Scalar)>>(),
             );
             SparsePolynomial::new(vk.num_vars.log_2(), poly_X).evaluate(&rand_sc_unpad[1..])
           };
@@ -1473,7 +1473,7 @@ where
         eval_w + r
       };
 
-      let claim_mem_final_expected: G::Scalar = coeffs[0]
+      let claim_mem_final_expected: E::Scalar = coeffs[0]
         * (self.eval_t_plus_r_inv_row - self.eval_w_plus_r_inv_row)
         + coeffs[1] * (self.eval_t_plus_r_inv_col - self.eval_w_plus_r_inv_col)
         + coeffs[2]
@@ -1481,13 +1481,13 @@ where
             * (self.eval_t_plus_r_inv_row * eval_t_plus_r_row - self.eval_ts_row))
         + coeffs[3]
           * (rand_eq_bound_rand_sc
-            * (self.eval_w_plus_r_inv_row * eval_w_plus_r_row - G::Scalar::ONE))
+            * (self.eval_w_plus_r_inv_row * eval_w_plus_r_row - E::Scalar::ONE))
         + coeffs[4]
           * (rand_eq_bound_rand_sc
             * (self.eval_t_plus_r_inv_col * eval_t_plus_r_col - self.eval_ts_col))
         + coeffs[5]
           * (rand_eq_bound_rand_sc
-            * (self.eval_w_plus_r_inv_col * eval_w_plus_r_col - G::Scalar::ONE));
+            * (self.eval_w_plus_r_inv_col * eval_w_plus_r_col - E::Scalar::ONE));
 
       let claim_outer_final_expected = coeffs[6]
         * taus_bound_rand_sc
@@ -1526,7 +1526,7 @@ where
       self.eval_ts_col,
     ]
     .into_iter()
-    .collect::<Vec<G::Scalar>>();
+    .collect::<Vec<E::Scalar>>();
     let comm_vec = [
       U.comm_W,
       comm_Az,
@@ -1549,7 +1549,7 @@ where
     ];
     transcript.absorb(b"e", &eval_vec.as_slice()); // comm_vec is already in the transcript
     let c = transcript.squeeze(b"c")?;
-    let u: PolyEvalInstance<G> = PolyEvalInstance::batch(&comm_vec, &rand_sc, &eval_vec, &c);
+    let u: PolyEvalInstance<E> = PolyEvalInstance::batch(&comm_vec, &rand_sc, &eval_vec, &c);
 
     // verify
     EE::verify(
diff --git a/src/spartan/snark.rs b/src/spartan/snark.rs
index 2f3ae02bf..f9f2d52c8 100644
--- a/src/spartan/snark.rs
+++ b/src/spartan/snark.rs
@@ -17,7 +17,7 @@ use crate::{
   traits::{
     evaluation::EvaluationEngineTrait,
     snark::{DigestHelperTrait, RelaxedR1CSSNARKTrait},
-    Group, TranscriptEngineTrait,
+    Engine, TranscriptEngineTrait,
   },
   Commitment, CommitmentKey,
 };
@@ -33,29 +33,29 @@ use serde::{Deserialize, Serialize};
 /// A type that represents the prover's key
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as ff::PrimeField>::Repr: Abomonation)]
-pub struct ProverKey<G: Group, EE: EvaluationEngineTrait<G>> {
+#[abomonation_bounds(where <E::Scalar as ff::PrimeField>::Repr: Abomonation)]
+pub struct ProverKey<E: Engine, EE: EvaluationEngineTrait<E>> {
   pk_ee: EE::ProverKey,
-  #[abomonate_with(<G::Scalar as ff::PrimeField>::Repr)]
-  vk_digest: G::Scalar, // digest of the verifier's key
+  #[abomonate_with(<E::Scalar as ff::PrimeField>::Repr)]
+  vk_digest: E::Scalar, // digest of the verifier's key
 }
 
 /// A type that represents the verifier's key
 #[derive(Clone, Serialize, Deserialize, Abomonation)]
 #[serde(bound = "")]
-#[abomonation_bounds(where <G::Scalar as ff::PrimeField>::Repr: Abomonation)]
-pub struct VerifierKey<G: Group, EE: EvaluationEngineTrait<G>> {
+#[abomonation_bounds(where <E::Scalar as ff::PrimeField>::Repr: Abomonation)]
+pub struct VerifierKey<E: Engine, EE: EvaluationEngineTrait<E>> {
   vk_ee: EE::VerifierKey,
-  S: R1CSShape<G>,
+  S: R1CSShape<E>,
   #[abomonation_skip]
   #[serde(skip, default = "OnceCell::new")]
-  digest: OnceCell<G::Scalar>,
+  digest: OnceCell<E::Scalar>,
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> SimpleDigestible for VerifierKey<G, EE> {}
+impl<E: Engine, EE: EvaluationEngineTrait<E>> SimpleDigestible for VerifierKey<E, EE> {}
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> VerifierKey<G, EE> {
-  fn new(shape: R1CSShape<G>, vk_ee: EE::VerifierKey) -> Self {
+impl<E: Engine, EE: EvaluationEngineTrait<E>> VerifierKey<E, EE> {
+  fn new(shape: R1CSShape<E>, vk_ee: EE::VerifierKey) -> Self {
     VerifierKey {
       vk_ee,
       S: shape,
@@ -64,13 +64,13 @@ impl<G: Group, EE: EvaluationEngineTrait<G>> VerifierKey<G, EE> {
   }
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> DigestHelperTrait<G> for VerifierKey<G, EE> {
+impl<E: Engine, EE: EvaluationEngineTrait<E>> DigestHelperTrait<E> for VerifierKey<E, EE> {
   /// Returns the digest of the verifier's key.
-  fn digest(&self) -> G::Scalar {
+  fn digest(&self) -> E::Scalar {
     self
       .digest
       .get_or_try_init(|| {
-        let dc = DigestComputer::<G::Scalar, _>::new(self);
+        let dc = DigestComputer::<E::Scalar, _>::new(self);
         dc.digest()
       })
       .cloned()
@@ -83,33 +83,33 @@ impl<G: Group, EE: EvaluationEngineTrait<G>> DigestHelperTrait<G> for VerifierKe
 /// the commitment to a vector viewed as a polynomial commitment
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub struct RelaxedR1CSSNARK<G: Group, EE: EvaluationEngineTrait<G>> {
-  sc_proof_outer: SumcheckProof<G>,
-  claims_outer: (G::Scalar, G::Scalar, G::Scalar),
-  eval_E: G::Scalar,
-  sc_proof_inner: SumcheckProof<G>,
-  eval_W: G::Scalar,
-  sc_proof_batch: SumcheckProof<G>,
-  evals_batch: Vec<G::Scalar>,
+pub struct RelaxedR1CSSNARK<E: Engine, EE: EvaluationEngineTrait<E>> {
+  sc_proof_outer: SumcheckProof<E>,
+  claims_outer: (E::Scalar, E::Scalar, E::Scalar),
+  eval_E: E::Scalar,
+  sc_proof_inner: SumcheckProof<E>,
+  eval_W: E::Scalar,
+  sc_proof_batch: SumcheckProof<E>,
+  evals_batch: Vec<E::Scalar>,
   eval_arg: EE::EvaluationArgument,
 }
 
-impl<G: Group, EE: EvaluationEngineTrait<G>> RelaxedR1CSSNARKTrait<G> for RelaxedR1CSSNARK<G, EE>
+impl<E: Engine, EE: EvaluationEngineTrait<E>> RelaxedR1CSSNARKTrait<E> for RelaxedR1CSSNARK<E, EE> 
 where
-  <G::Scalar as ff::PrimeField>::Repr: Abomonation,
+  <E::Scalar as ff::PrimeField>::Repr: Abomonation,
 {
-  type ProverKey = ProverKey<G, EE>;
-  type VerifierKey = VerifierKey<G, EE>;
+  type ProverKey = ProverKey<E, EE>;
+  type VerifierKey = VerifierKey<E, EE>;
 
   fn setup(
-    ck: &CommitmentKey<G>,
-    S: &R1CSShape<G>,
+    ck: &CommitmentKey<E>,
+    S: &R1CSShape<E>,
   ) -> Result<(Self::ProverKey, Self::VerifierKey), NovaError> {
     let (pk_ee, vk_ee) = EE::setup(ck);
 
     let S = S.pad();
 
-    let vk: VerifierKey<G, EE> = VerifierKey::new(S, vk_ee);
+    let vk: VerifierKey<E, EE> = VerifierKey::new(S, vk_ee);
 
     let pk = ProverKey {
       pk_ee,
@@ -122,11 +122,11 @@ where
   /// produces a succinct proof of satisfiability of a `RelaxedR1CS` instance
   #[tracing::instrument(skip_all, name = "SNARK::prove")]
   fn prove(
-    ck: &CommitmentKey<G>,
+    ck: &CommitmentKey<E>,
     pk: &Self::ProverKey,
-    S: &R1CSShape<G>,
-    U: &RelaxedR1CSInstance<G>,
-    W: &RelaxedR1CSWitness<G>,
+    S: &R1CSShape<E>,
+    U: &RelaxedR1CSInstance<E>,
+    W: &RelaxedR1CSWitness<E>,
   ) -> Result<Self, NovaError> {
     // pad the R1CSShape
     let S = S.pad();
@@ -134,7 +134,7 @@ where
     assert!(S.is_regular_shape());
 
     let W = W.pad(&S); // pad the witness
-    let mut transcript = G::TE::new(b"RelaxedR1CSSNARK");
+    let mut transcript = E::TE::new(b"RelaxedR1CSSNARK");
 
     // append the digest of vk (which includes R1CS matrices) and the RelaxedR1CSInstance to the transcript
     transcript.absorb(b"vk", &pk.vk_digest);
@@ -151,14 +151,14 @@ where
     // outer sum-check
     let tau = (0..num_rounds_x)
       .map(|_i| transcript.squeeze(b"t"))
-      .collect::<Result<Vec<G::Scalar>, NovaError>>()?;
+      .collect::<Result<Vec<E::Scalar>, NovaError>>()?;
 
     let mut poly_tau = MultilinearPolynomial::new(EqPolynomial::new(tau).evals());
     let (mut poly_Az, mut poly_Bz, poly_Cz, mut poly_uCz_E) = {
       let (poly_Az, poly_Bz, poly_Cz) = S.multiply_vec(&z)?;
       let poly_uCz_E = (0..S.num_cons)
         .map(|i| U.u * poly_Cz[i] + W.E[i])
-        .collect::<Vec<G::Scalar>>();
+        .collect::<Vec<E::Scalar>>();
       (
         MultilinearPolynomial::new(poly_Az),
         MultilinearPolynomial::new(poly_Bz),
@@ -168,13 +168,13 @@ where
     };
 
     let comb_func_outer =
-      |poly_A_comp: &G::Scalar,
-       poly_B_comp: &G::Scalar,
-       poly_C_comp: &G::Scalar,
-       poly_D_comp: &G::Scalar|
-       -> G::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
+      |poly_A_comp: &E::Scalar,
+       poly_B_comp: &E::Scalar,
+       poly_C_comp: &E::Scalar,
+       poly_D_comp: &E::Scalar|
+       -> E::Scalar { *poly_A_comp * (*poly_B_comp * *poly_C_comp - *poly_D_comp) };
     let (sc_proof_outer, r_x, claims_outer) = SumcheckProof::prove_cubic_with_additive_term(
-      &G::Scalar::ZERO, // claim is zero
+      &E::Scalar::ZERO, // claim is zero
       num_rounds_x,
       &mut poly_tau,
       &mut poly_Az,
@@ -185,7 +185,7 @@ where
     )?;
 
     // claims from the end of sum-check
-    let (claim_Az, claim_Bz): (G::Scalar, G::Scalar) = (claims_outer[1], claims_outer[2]);
+    let (claim_Az, claim_Bz): (E::Scalar, E::Scalar) = (claims_outer[1], claims_outer[2]);
     let claim_Cz = poly_Cz.evaluate(&r_x);
     let eval_E = MultilinearPolynomial::new(W.E.clone()).evaluate(&r_x);
     transcript.absorb(
@@ -203,10 +203,10 @@ where
 
       // Bounds "row" variables of (A, B, C) matrices viewed as 2d multilinear polynomials
       let compute_eval_table_sparse =
-        |S: &R1CSShape<G>, rx: &[G::Scalar]| -> (Vec<G::Scalar>, Vec<G::Scalar>, Vec<G::Scalar>) {
+        |S: &R1CSShape<E>, rx: &[E::Scalar]| -> (Vec<E::Scalar>, Vec<E::Scalar>, Vec<E::Scalar>) {
           assert_eq!(rx.len(), S.num_cons);
 
-          let inner = |M: &SparseMatrix<G::Scalar>, M_evals: &mut Vec<G::Scalar>| {
+          let inner = |M: &SparseMatrix<E::Scalar>, M_evals: &mut Vec<E::Scalar>| {
             for (row_idx, ptrs) in M.indptr.windows(2).enumerate() {
               for (val, col_idx) in M.get_row_unchecked(ptrs.try_into().unwrap()) {
                 M_evals[*col_idx] += rx[row_idx] * val;
@@ -216,19 +216,19 @@ where
 
           let (A_evals, (B_evals, C_evals)) = rayon::join(
             || {
-              let mut A_evals: Vec<G::Scalar> = vec![G::Scalar::ZERO; 2 * S.num_vars];
+              let mut A_evals: Vec<E::Scalar> = vec![E::Scalar::ZERO; 2 * S.num_vars];
               inner(&S.A, &mut A_evals);
               A_evals
             },
             || {
               rayon::join(
                 || {
-                  let mut B_evals: Vec<G::Scalar> = vec![G::Scalar::ZERO; 2 * S.num_vars];
+                  let mut B_evals: Vec<E::Scalar> = vec![E::Scalar::ZERO; 2 * S.num_vars];
                   inner(&S.B, &mut B_evals);
                   B_evals
                 },
                 || {
-                  let mut C_evals: Vec<G::Scalar> = vec![G::Scalar::ZERO; 2 * S.num_vars];
+                  let mut C_evals: Vec<E::Scalar> = vec![E::Scalar::ZERO; 2 * S.num_vars];
                   inner(&S.C, &mut C_evals);
                   C_evals
                 },
@@ -246,15 +246,15 @@ where
       (0..evals_A.len())
         .into_par_iter()
         .map(|i| evals_A[i] + r * evals_B[i] + r * r * evals_C[i])
-        .collect::<Vec<G::Scalar>>()
+        .collect::<Vec<E::Scalar>>()
     };
 
     let poly_z = {
-      z.resize(S.num_vars * 2, G::Scalar::ZERO);
+      z.resize(S.num_vars * 2, E::Scalar::ZERO);
       z
     };
 
-    let comb_func = |poly_A_comp: &G::Scalar, poly_B_comp: &G::Scalar| -> G::Scalar {
+    let comb_func = |poly_A_comp: &E::Scalar, poly_B_comp: &E::Scalar| -> E::Scalar {
       *poly_A_comp * *poly_B_comp
     };
     let (sc_proof_inner, r_y, _claims_inner) = SumcheckProof::prove_quad(
@@ -296,7 +296,7 @@ where
     // to the batched polynomial.
     assert!(w_u_vec.len() >= 2);
 
-    let (w_vec, u_vec): (Vec<PolyEvalWitness<G>>, Vec<PolyEvalInstance<G>>) =
+    let (w_vec, u_vec): (Vec<PolyEvalWitness<E>>, Vec<PolyEvalInstance<E>>) =
       w_u_vec.into_iter().unzip();
 
     let (batched_u, batched_w, sc_proof_batch, claims_batch_left) =
@@ -325,8 +325,8 @@ where
   }
 
   /// verifies a proof of satisfiability of a `RelaxedR1CS` instance
-  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<G>) -> Result<(), NovaError> {
-    let mut transcript = G::TE::new(b"RelaxedR1CSSNARK");
+  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<E>) -> Result<(), NovaError> {
+    let mut transcript = E::TE::new(b"RelaxedR1CSSNARK");
 
     // append the digest of R1CS matrices and the RelaxedR1CSInstance to the transcript
     transcript.absorb(b"vk", &vk.digest());
@@ -340,12 +340,12 @@ where
     // outer sum-check
     let tau = (0..num_rounds_x)
       .map(|_i| transcript.squeeze(b"t"))
-      .collect::<Result<Vec<G::Scalar>, NovaError>>()?;
+      .collect::<Result<Vec<E::Scalar>, NovaError>>()?;
 
     let (claim_outer_final, r_x) =
       self
         .sc_proof_outer
-        .verify(G::Scalar::ZERO, num_rounds_x, 3, &mut transcript)?;
+        .verify(E::Scalar::ZERO, num_rounds_x, 3, &mut transcript)?;
 
     // verify claim_outer_final
     let (claim_Az, claim_Bz, claim_Cz) = self.claims_outer;
@@ -386,28 +386,28 @@ where
         poly_X.extend(
           (0..U.X.len())
             .map(|i| (i + 1, U.X[i]))
-            .collect::<Vec<(usize, G::Scalar)>>(),
+            .collect::<Vec<(usize, E::Scalar)>>(),
         );
         SparsePolynomial::new(usize::try_from(vk.S.num_vars.ilog2()).unwrap(), poly_X)
           .evaluate(&r_y[1..])
       };
-      (G::Scalar::ONE - r_y[0]) * self.eval_W + r_y[0] * eval_X
+      (E::Scalar::ONE - r_y[0]) * self.eval_W + r_y[0] * eval_X
     };
 
     // compute evaluations of R1CS matrices
-    let multi_evaluate = |M_vec: &[&SparseMatrix<G::Scalar>],
-                          r_x: &[G::Scalar],
-                          r_y: &[G::Scalar]|
-     -> Vec<G::Scalar> {
+    let multi_evaluate = |M_vec: &[&SparseMatrix<E::Scalar>],
+                          r_x: &[E::Scalar],
+                          r_y: &[E::Scalar]|
+     -> Vec<E::Scalar> {
       let evaluate_with_table =
-        |M: &SparseMatrix<G::Scalar>, T_x: &[G::Scalar], T_y: &[G::Scalar]| -> G::Scalar {
+        |M: &SparseMatrix<E::Scalar>, T_x: &[E::Scalar], T_y: &[E::Scalar]| -> E::Scalar {
           M.indptr
             .par_windows(2)
             .enumerate()
             .map(|(row_idx, ptrs)| {
               M.get_row_unchecked(ptrs.try_into().unwrap())
                 .map(|(val, col_idx)| T_x[row_idx] * T_y[*col_idx] * val)
-                .sum::<G::Scalar>()
+                .sum::<E::Scalar>()
             })
             .sum()
         };
@@ -431,7 +431,7 @@ where
     }
 
     // add claims about W and E polynomials
-    let u_vec: Vec<PolyEvalInstance<G>> = vec![
+    let u_vec: Vec<PolyEvalInstance<E>> = vec![
       PolyEvalInstance {
         c: U.comm_W,
         x: r_y[1..].to_vec(),
@@ -467,16 +467,16 @@ where
 
 /// Proves a batch of polynomial evaluation claims using Sumcheck
 /// reducing them to a single claim at the same point.
-fn batch_eval_prove<G: Group>(
-  u_vec: Vec<PolyEvalInstance<G>>,
-  w_vec: Vec<PolyEvalWitness<G>>,
-  transcript: &mut G::TE,
+fn batch_eval_prove<E: Engine>(
+  u_vec: Vec<PolyEvalInstance<E>>,
+  w_vec: Vec<PolyEvalWitness<E>>,
+  transcript: &mut E::TE,
 ) -> Result<
   (
-    PolyEvalInstance<G>,
-    PolyEvalWitness<G>,
-    SumcheckProof<G>,
-    Vec<G::Scalar>,
+    PolyEvalInstance<E>,
+    PolyEvalWitness<E>,
+    SumcheckProof<E>,
+    Vec<E::Scalar>,
   ),
   NovaError,
 > {
@@ -488,25 +488,25 @@ fn batch_eval_prove<G: Group>(
   // generate a challenge
   let rho = transcript.squeeze(b"r")?;
   let num_claims = w_vec_padded.len();
-  let powers_of_rho = powers::<G>(&rho, num_claims);
+  let powers_of_rho = powers::<E>(&rho, num_claims);
   let claim_batch_joint = u_vec_padded
     .iter()
     .zip(powers_of_rho.iter())
     .map(|(u, p)| u.e * p)
     .sum();
 
-  let mut polys_left: Vec<MultilinearPolynomial<G::Scalar>> = w_vec_padded
+  let mut polys_left: Vec<MultilinearPolynomial<E::Scalar>> = w_vec_padded
     .iter()
     .map(|w| MultilinearPolynomial::new(w.p.clone()))
     .collect();
-  let mut polys_right: Vec<MultilinearPolynomial<G::Scalar>> = u_vec_padded
+  let mut polys_right: Vec<MultilinearPolynomial<E::Scalar>> = u_vec_padded
     .iter()
     .map(|u| MultilinearPolynomial::new(EqPolynomial::new(u.x.clone()).evals()))
     .collect();
 
   let num_rounds_z = u_vec_padded[0].x.len();
   let comb_func =
-    |poly_A_comp: &G::Scalar, poly_B_comp: &G::Scalar| -> G::Scalar { *poly_A_comp * *poly_B_comp };
+    |poly_A_comp: &E::Scalar, poly_B_comp: &E::Scalar| -> E::Scalar { *poly_A_comp * *poly_B_comp };
   let (sc_proof_batch, r_z, claims_batch) = SumcheckProof::prove_quad_batch(
     &claim_batch_joint,
     num_rounds_z,
@@ -517,18 +517,18 @@ fn batch_eval_prove<G: Group>(
     transcript,
   )?;
 
-  let (claims_batch_left, _): (Vec<G::Scalar>, Vec<G::Scalar>) = claims_batch;
+  let (claims_batch_left, _): (Vec<E::Scalar>, Vec<E::Scalar>) = claims_batch;
 
   transcript.absorb(b"l", &claims_batch_left.as_slice());
 
   // we now combine evaluation claims at the same point rz into one
   let gamma = transcript.squeeze(b"g")?;
-  let powers_of_gamma: Vec<G::Scalar> = powers::<G>(&gamma, num_claims);
+  let powers_of_gamma: Vec<E::Scalar> = powers::<E>(&gamma, num_claims);
   let comm_joint = u_vec_padded
     .iter()
     .zip(powers_of_gamma.iter())
     .map(|(u, g_i)| u.c * *g_i)
-    .fold(Commitment::<G>::default(), |acc, item| acc + item);
+    .fold(Commitment::<E>::default(), |acc, item| acc + item);
   let poly_joint = PolyEvalWitness::weighted_sum(&w_vec_padded, &powers_of_gamma);
   let eval_joint = claims_batch_left
     .iter()
@@ -537,7 +537,7 @@ fn batch_eval_prove<G: Group>(
     .sum();
 
   Ok((
-    PolyEvalInstance::<G> {
+    PolyEvalInstance::<E> {
       c: comm_joint,
       x: r_z,
       e: eval_joint,
@@ -550,12 +550,12 @@ fn batch_eval_prove<G: Group>(
 
 /// Verifies a batch of polynomial evaluation claims using Sumcheck
 /// reducing them to a single claim at the same point.
-fn batch_eval_verify<G: Group>(
-  u_vec: Vec<PolyEvalInstance<G>>,
-  transcript: &mut G::TE,
-  sc_proof_batch: &SumcheckProof<G>,
-  evals_batch: &[G::Scalar],
-) -> Result<PolyEvalInstance<G>, NovaError> {
+fn batch_eval_verify<E: Engine>(
+  u_vec: Vec<PolyEvalInstance<E>>,
+  transcript: &mut E::TE,
+  sc_proof_batch: &SumcheckProof<E>,
+  evals_batch: &[E::Scalar],
+) -> Result<PolyEvalInstance<E>, NovaError> {
   assert_eq!(evals_batch.len(), evals_batch.len());
 
   let u_vec_padded = PolyEvalInstance::pad(u_vec); // pad the evaluation points
@@ -563,7 +563,7 @@ fn batch_eval_verify<G: Group>(
   // generate a challenge
   let rho = transcript.squeeze(b"r")?;
   let num_claims: usize = u_vec_padded.len();
-  let powers_of_rho = powers::<G>(&rho, num_claims);
+  let powers_of_rho = powers::<E>(&rho, num_claims);
   let claim_batch_joint = u_vec_padded
     .iter()
     .zip(powers_of_rho.iter())
@@ -580,7 +580,7 @@ fn batch_eval_verify<G: Group>(
     let evals = u_vec_padded
       .iter()
       .map(|u| poly_rz.evaluate(&u.x))
-      .collect::<Vec<G::Scalar>>();
+      .collect::<Vec<E::Scalar>>();
 
     evals
       .iter()
@@ -598,19 +598,19 @@ fn batch_eval_verify<G: Group>(
 
   // we now combine evaluation claims at the same point rz into one
   let gamma = transcript.squeeze(b"g")?;
-  let powers_of_gamma: Vec<G::Scalar> = powers::<G>(&gamma, num_claims);
+  let powers_of_gamma: Vec<E::Scalar> = powers::<E>(&gamma, num_claims);
   let comm_joint = u_vec_padded
     .iter()
     .zip(powers_of_gamma.iter())
     .map(|(u, g_i)| u.c * *g_i)
-    .fold(Commitment::<G>::default(), |acc, item| acc + item);
+    .fold(Commitment::<E>::default(), |acc, item| acc + item);
   let eval_joint = evals_batch
     .iter()
     .zip(powers_of_gamma.iter())
     .map(|(e, g_i)| *e * *g_i)
     .sum();
 
-  Ok(PolyEvalInstance::<G> {
+  Ok(PolyEvalInstance::<E> {
     c: comm_joint,
     x: r_z,
     e: eval_joint,
diff --git a/src/spartan/sumcheck.rs b/src/spartan/sumcheck.rs
index 6c9f13d8e..fdf168bef 100644
--- a/src/spartan/sumcheck.rs
+++ b/src/spartan/sumcheck.rs
@@ -3,31 +3,31 @@ use crate::spartan::polys::{
   multilinear::MultilinearPolynomial,
   univariate::{CompressedUniPoly, UniPoly},
 };
-use crate::traits::{Group, TranscriptEngineTrait};
+use crate::traits::{Engine, TranscriptEngineTrait};
 use ff::Field;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(bound = "")]
-pub(crate) struct SumcheckProof<G: Group> {
-  compressed_polys: Vec<CompressedUniPoly<G::Scalar>>,
+pub(crate) struct SumcheckProof<E: Engine> {
+  compressed_polys: Vec<CompressedUniPoly<E::Scalar>>,
 }
 
-impl<G: Group> SumcheckProof<G> {
-  pub fn new(compressed_polys: Vec<CompressedUniPoly<G::Scalar>>) -> Self {
+impl<E: Engine> SumcheckProof<E> {
+  pub fn new(compressed_polys: Vec<CompressedUniPoly<E::Scalar>>) -> Self {
     Self { compressed_polys }
   }
 
   pub fn verify(
     &self,
-    claim: G::Scalar,
+    claim: E::Scalar,
     num_rounds: usize,
     degree_bound: usize,
-    transcript: &mut G::TE,
-  ) -> Result<(G::Scalar, Vec<G::Scalar>), NovaError> {
+    transcript: &mut E::TE,
+  ) -> Result<(E::Scalar, Vec<E::Scalar>), NovaError> {
     let mut e = claim;
-    let mut r: Vec<G::Scalar> = Vec::new();
+    let mut r: Vec<E::Scalar> = Vec::new();
 
     // verify that there is a univariate polynomial for each round
     if self.compressed_polys.len() != num_rounds {
@@ -63,12 +63,12 @@ impl<G: Group> SumcheckProof<G> {
 
   #[inline]
   pub(in crate::spartan) fn compute_eval_points_quad<F>(
-    poly_A: &MultilinearPolynomial<G::Scalar>,
-    poly_B: &MultilinearPolynomial<G::Scalar>,
+    poly_A: &MultilinearPolynomial<E::Scalar>,
+    poly_B: &MultilinearPolynomial<E::Scalar>,
     comb_func: &F,
-  ) -> (G::Scalar, G::Scalar)
+  ) -> (E::Scalar, E::Scalar)
   where
-    F: Fn(&G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
     let len = poly_A.len() / 2;
     (0..len)
@@ -84,24 +84,24 @@ impl<G: Group> SumcheckProof<G> {
         (eval_point_0, eval_point_2)
       })
       .reduce(
-        || (G::Scalar::ZERO, G::Scalar::ZERO),
+        || (E::Scalar::ZERO, E::Scalar::ZERO),
         |a, b| (a.0 + b.0, a.1 + b.1),
       )
   }
 
   pub fn prove_quad<F>(
-    claim: &G::Scalar,
+    claim: &E::Scalar,
     num_rounds: usize,
-    poly_A: &mut MultilinearPolynomial<G::Scalar>,
-    poly_B: &mut MultilinearPolynomial<G::Scalar>,
+    poly_A: &mut MultilinearPolynomial<E::Scalar>,
+    poly_B: &mut MultilinearPolynomial<E::Scalar>,
     comb_func: F,
-    transcript: &mut G::TE,
-  ) -> Result<(Self, Vec<G::Scalar>, Vec<G::Scalar>), NovaError>
+    transcript: &mut E::TE,
+  ) -> Result<(Self, Vec<E::Scalar>, Vec<E::Scalar>), NovaError>
   where
-    F: Fn(&G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
-    let mut r: Vec<G::Scalar> = Vec::new();
-    let mut polys: Vec<CompressedUniPoly<G::Scalar>> = Vec::new();
+    let mut r: Vec<E::Scalar> = Vec::new();
+    let mut polys: Vec<CompressedUniPoly<E::Scalar>> = Vec::new();
     let mut claim_per_round = *claim;
     for _ in 0..num_rounds {
       let poly = {
@@ -140,23 +140,23 @@ impl<G: Group> SumcheckProof<G> {
   }
 
   pub fn prove_quad_batch<F>(
-    claim: &G::Scalar,
+    claim: &E::Scalar,
     num_rounds: usize,
-    poly_A_vec: &mut Vec<MultilinearPolynomial<G::Scalar>>,
-    poly_B_vec: &mut Vec<MultilinearPolynomial<G::Scalar>>,
-    coeffs: &[G::Scalar],
+    poly_A_vec: &mut Vec<MultilinearPolynomial<E::Scalar>>,
+    poly_B_vec: &mut Vec<MultilinearPolynomial<E::Scalar>>,
+    coeffs: &[E::Scalar],
     comb_func: F,
-    transcript: &mut G::TE,
-  ) -> Result<(Self, Vec<G::Scalar>, (Vec<G::Scalar>, Vec<G::Scalar>)), NovaError>
+    transcript: &mut E::TE,
+  ) -> Result<(Self, Vec<E::Scalar>, (Vec<E::Scalar>, Vec<E::Scalar>)), NovaError>
   where
-    F: Fn(&G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
     let mut e = *claim;
-    let mut r: Vec<G::Scalar> = Vec::new();
-    let mut quad_polys: Vec<CompressedUniPoly<G::Scalar>> = Vec::new();
+    let mut r: Vec<E::Scalar> = Vec::new();
+    let mut quad_polys: Vec<CompressedUniPoly<E::Scalar>> = Vec::new();
 
     for _ in 0..num_rounds {
-      let evals: Vec<(G::Scalar, G::Scalar)> = poly_A_vec
+      let evals: Vec<(E::Scalar, E::Scalar)> = poly_A_vec
         .par_iter()
         .zip(poly_B_vec.par_iter())
         .map(|(poly_A, poly_B)| Self::compute_eval_points_quad(poly_A, poly_B, &comb_func))
@@ -199,13 +199,13 @@ impl<G: Group> SumcheckProof<G> {
 
   #[inline]
   pub(in crate::spartan) fn compute_eval_points_cubic<F>(
-    poly_A: &MultilinearPolynomial<G::Scalar>,
-    poly_B: &MultilinearPolynomial<G::Scalar>,
-    poly_C: &MultilinearPolynomial<G::Scalar>,
+    poly_A: &MultilinearPolynomial<E::Scalar>,
+    poly_B: &MultilinearPolynomial<E::Scalar>,
+    poly_C: &MultilinearPolynomial<E::Scalar>,
     comb_func: &F,
-  ) -> (G::Scalar, G::Scalar, G::Scalar)
+  ) -> (E::Scalar, E::Scalar, E::Scalar)
   where
-    F: Fn(&G::Scalar, &G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
     let len = poly_A.len() / 2;
     (0..len)
@@ -236,21 +236,21 @@ impl<G: Group> SumcheckProof<G> {
         (eval_point_0, eval_point_2, eval_point_3)
       })
       .reduce(
-        || (G::Scalar::ZERO, G::Scalar::ZERO, G::Scalar::ZERO),
+        || (E::Scalar::ZERO, E::Scalar::ZERO, E::Scalar::ZERO),
         |a, b| (a.0 + b.0, a.1 + b.1, a.2 + b.2),
       )
   }
 
   #[inline]
   pub(in crate::spartan) fn compute_eval_points_cubic_with_additive_term<F>(
-    poly_A: &MultilinearPolynomial<G::Scalar>,
-    poly_B: &MultilinearPolynomial<G::Scalar>,
-    poly_C: &MultilinearPolynomial<G::Scalar>,
-    poly_D: &MultilinearPolynomial<G::Scalar>,
+    poly_A: &MultilinearPolynomial<E::Scalar>,
+    poly_B: &MultilinearPolynomial<E::Scalar>,
+    poly_C: &MultilinearPolynomial<E::Scalar>,
+    poly_D: &MultilinearPolynomial<E::Scalar>,
     comb_func: &F,
-  ) -> (G::Scalar, G::Scalar, G::Scalar)
+  ) -> (E::Scalar, E::Scalar, E::Scalar)
   where
-    F: Fn(&G::Scalar, &G::Scalar, &G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar, &E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
     let len = poly_A.len() / 2;
     (0..len)
@@ -285,26 +285,26 @@ impl<G: Group> SumcheckProof<G> {
         (eval_point_0, eval_point_2, eval_point_3)
       })
       .reduce(
-        || (G::Scalar::ZERO, G::Scalar::ZERO, G::Scalar::ZERO),
+        || (E::Scalar::ZERO, E::Scalar::ZERO, E::Scalar::ZERO),
         |a, b| (a.0 + b.0, a.1 + b.1, a.2 + b.2),
       )
   }
 
   pub fn prove_cubic_with_additive_term<F>(
-    claim: &G::Scalar,
+    claim: &E::Scalar,
     num_rounds: usize,
-    poly_A: &mut MultilinearPolynomial<G::Scalar>,
-    poly_B: &mut MultilinearPolynomial<G::Scalar>,
-    poly_C: &mut MultilinearPolynomial<G::Scalar>,
-    poly_D: &mut MultilinearPolynomial<G::Scalar>,
+    poly_A: &mut MultilinearPolynomial<E::Scalar>,
+    poly_B: &mut MultilinearPolynomial<E::Scalar>,
+    poly_C: &mut MultilinearPolynomial<E::Scalar>,
+    poly_D: &mut MultilinearPolynomial<E::Scalar>,
     comb_func: F,
-    transcript: &mut G::TE,
-  ) -> Result<(Self, Vec<G::Scalar>, Vec<G::Scalar>), NovaError>
+    transcript: &mut E::TE,
+  ) -> Result<(Self, Vec<E::Scalar>, Vec<E::Scalar>), NovaError>
   where
-    F: Fn(&G::Scalar, &G::Scalar, &G::Scalar, &G::Scalar) -> G::Scalar + Sync,
+    F: Fn(&E::Scalar, &E::Scalar, &E::Scalar, &E::Scalar) -> E::Scalar + Sync,
   {
-    let mut r: Vec<G::Scalar> = Vec::new();
-    let mut polys: Vec<CompressedUniPoly<G::Scalar>> = Vec::new();
+    let mut r: Vec<E::Scalar> = Vec::new();
+    let mut polys: Vec<CompressedUniPoly<E::Scalar>> = Vec::new();
     let mut claim_per_round = *claim;
 
     for _ in 0..num_rounds {
diff --git a/src/traits/circuit.rs b/src/traits/circuit.rs
index d2cd2aaee..71037c6f7 100644
--- a/src/traits/circuit.rs
+++ b/src/traits/circuit.rs
@@ -26,10 +26,7 @@ pub struct TrivialCircuit<F: PrimeField> {
   _p: PhantomData<F>,
 }
 
-impl<F> StepCircuit<F> for TrivialCircuit<F>
-where
-  F: PrimeField,
-{
+impl<F: PrimeField> StepCircuit<F> for TrivialCircuit<F> {
   fn arity(&self) -> usize {
     1
   }
diff --git a/src/traits/commitment.rs b/src/traits/commitment.rs
index 70f05f9c0..5bc298a82 100644
--- a/src/traits/commitment.rs
+++ b/src/traits/commitment.rs
@@ -2,12 +2,12 @@
 //! We require the commitment engine to provide a commitment to vectors with a single group element
 use crate::{
   errors::NovaError,
-  traits::{AbsorbInROTrait, Group, TranscriptReprTrait},
+  traits::{AbsorbInROTrait, Engine, TranscriptReprTrait},
 };
 use abomonation::Abomonation;
 use core::{
   fmt::Debug,
-  ops::{Add, AddAssign, Mul, MulAssign},
+  ops::{Add, Mul, MulAssign},
 };
 use serde::{Deserialize, Serialize};
 
@@ -17,29 +17,8 @@ pub trait ScalarMul<Rhs, Output = Self>: Mul<Rhs, Output = Output> + MulAssign<R
 impl<T, Rhs, Output> ScalarMul<Rhs, Output> for T where T: Mul<Rhs, Output = Output> + MulAssign<Rhs>
 {}
 
-/// Defines basic operations on commitments
-pub trait CommitmentOps<Rhs = Self, Output = Self>:
-  Add<Rhs, Output = Output> + AddAssign<Rhs>
-{
-}
-
-impl<T, Rhs, Output> CommitmentOps<Rhs, Output> for T where
-  T: Add<Rhs, Output = Output> + AddAssign<Rhs>
-{
-}
-
-/// A helper trait for references with a commitment operation
-pub trait CommitmentOpsOwned<Rhs = Self, Output = Self>:
-  for<'r> CommitmentOps<&'r Rhs, Output>
-{
-}
-impl<T, Rhs, Output> CommitmentOpsOwned<Rhs, Output> for T where
-  T: for<'r> CommitmentOps<&'r Rhs, Output>
-{
-}
-
 /// This trait defines the behavior of the commitment
-pub trait CommitmentTrait<G: Group>:
+pub trait CommitmentTrait<E: Engine>:
   Clone
   + Copy
   + Debug
@@ -48,14 +27,13 @@ pub trait CommitmentTrait<G: Group>:
   + Eq
   + Send
   + Sync
-  + TranscriptReprTrait<G>
+  + TranscriptReprTrait<E::GE>
   + Serialize
   + for<'de> Deserialize<'de>
   + Abomonation
-  + AbsorbInROTrait<G>
-  + CommitmentOps
-  + CommitmentOpsOwned
-  + ScalarMul<G::Scalar>
+  + AbsorbInROTrait<E>
+  + Add<Self, Output = Self>
+  + ScalarMul<E::Scalar>
 {
   /// Holds the type of the compressed commitment
   type CompressedCommitment: Clone
@@ -64,7 +42,7 @@ pub trait CommitmentTrait<G: Group>:
     + Eq
     + Send
     + Sync
-    + TranscriptReprTrait<G>
+    + TranscriptReprTrait<E::GE>
     + Serialize
     + for<'de> Deserialize<'de>;
 
@@ -72,7 +50,7 @@ pub trait CommitmentTrait<G: Group>:
   fn compress(&self) -> Self::CompressedCommitment;
 
   /// Returns the coordinate representation of the commitment
-  fn to_coordinates(&self) -> (G::Base, G::Base, bool);
+  fn to_coordinates(&self) -> (E::Base, E::Base, bool);
 
   /// Decompresses a compressed commitment into a commitment
   fn decompress(c: &Self::CompressedCommitment) -> Result<Self, NovaError>;
@@ -86,7 +64,7 @@ pub trait Len {
 }
 
 /// A trait that ties different pieces of the commitment generation together
-pub trait CommitmentEngineTrait<G: Group>: Clone + Send + Sync {
+pub trait CommitmentEngineTrait<E: Engine>: Clone + Send + Sync {
   /// Holds the type of the commitment key
   /// The key should quantify its length in terms of group generators.
   type CommitmentKey: Len
@@ -100,11 +78,11 @@ pub trait CommitmentEngineTrait<G: Group>: Clone + Send + Sync {
     + Abomonation;
 
   /// Holds the type of the commitment
-  type Commitment: CommitmentTrait<G>;
+  type Commitment: CommitmentTrait<E>;
 
   /// Samples a new commitment key of a specified size
   fn setup(label: &'static [u8], n: usize) -> Self::CommitmentKey;
 
   /// Commits to the provided vector using the provided generators
-  fn commit(ck: &Self::CommitmentKey, v: &[G::Scalar]) -> Self::Commitment;
+  fn commit(ck: &Self::CommitmentKey, v: &[E::Scalar]) -> Self::Commitment;
 }
diff --git a/src/traits/evaluation.rs b/src/traits/evaluation.rs
index 5e29f0195..726aa3931 100644
--- a/src/traits/evaluation.rs
+++ b/src/traits/evaluation.rs
@@ -3,13 +3,13 @@
 //! and a commitment provided by the commitment engine is treated as a multilinear polynomial commitment
 use crate::{
   errors::NovaError,
-  traits::{commitment::CommitmentEngineTrait, Group},
+  traits::{commitment::CommitmentEngineTrait, Engine},
 };
 use abomonation::Abomonation;
 use serde::{Deserialize, Serialize};
 
 /// A trait that ties different pieces of the commitment evaluation together
-pub trait EvaluationEngineTrait<G: Group>: Clone + Send + Sync {
+pub trait EvaluationEngineTrait<E: Engine>: Clone + Send + Sync {
   /// A type that holds the prover key
   type ProverKey: Clone + Send + Sync + Serialize + for<'de> Deserialize<'de> + Abomonation;
 
@@ -21,27 +21,27 @@ pub trait EvaluationEngineTrait<G: Group>: Clone + Send + Sync {
 
   /// A method to perform any additional setup needed to produce proofs of evaluations
   fn setup(
-    ck: &<<G as Group>::CE as CommitmentEngineTrait<G>>::CommitmentKey,
+    ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey,
   ) -> (Self::ProverKey, Self::VerifierKey);
 
   /// A method to prove the evaluation of a multilinear polynomial
   fn prove(
-    ck: &<<G as Group>::CE as CommitmentEngineTrait<G>>::CommitmentKey,
+    ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey,
     pk: &Self::ProverKey,
-    transcript: &mut G::TE,
-    comm: &<<G as Group>::CE as CommitmentEngineTrait<G>>::Commitment,
-    poly: &[G::Scalar],
-    point: &[G::Scalar],
-    eval: &G::Scalar,
+    transcript: &mut E::TE,
+    comm: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment,
+    poly: &[E::Scalar],
+    point: &[E::Scalar],
+    eval: &E::Scalar,
   ) -> Result<Self::EvaluationArgument, NovaError>;
 
   /// A method to verify the purported evaluation of a multilinear polynomials
   fn verify(
     vk: &Self::VerifierKey,
-    transcript: &mut G::TE,
-    comm: &<<G as Group>::CE as CommitmentEngineTrait<G>>::Commitment,
-    point: &[G::Scalar],
-    eval: &G::Scalar,
+    transcript: &mut E::TE,
+    comm: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment,
+    point: &[E::Scalar],
+    eval: &E::Scalar,
     arg: &Self::EvaluationArgument,
   ) -> Result<(), NovaError>;
 }
diff --git a/src/traits/mod.rs b/src/traits/mod.rs
index 6ac2812cf..3440cbb32 100644
--- a/src/traits/mod.rs
+++ b/src/traits/mod.rs
@@ -15,17 +15,32 @@ use commitment::CommitmentEngineTrait;
 /// This is currently tailored for an elliptic curve group
 pub trait Group: Clone + Copy + Debug + Send + Sync + Sized + Eq + PartialEq {
   /// A type representing an element of the base field of the group
-  type Base: PrimeFieldBits + TranscriptReprTrait<Self> + Serialize + for<'de> Deserialize<'de>;
+  type Base: PrimeFieldBits + Serialize + for<'de> Deserialize<'de>;
+
+  /// A type representing an element of the scalar field of the group
+  type Scalar: PrimeFieldBits + PrimeFieldExt + Send + Sync + Serialize + for<'de> Deserialize<'de>;
+
+  /// Returns A, B, the order of the group, the size of the base field as big integers
+  fn group_params() -> (Self::Base, Self::Base, BigInt, BigInt);
+}
+
+/// A collection of engines that are required by the library
+pub trait Engine: Clone + Copy + Debug + Send + Sync + Sized + Eq + PartialEq {
+  /// A type representing an element of the base field of the group
+  type Base: PrimeFieldBits + TranscriptReprTrait<Self::GE> + Serialize + for<'de> Deserialize<'de>;
 
   /// A type representing an element of the scalar field of the group
   type Scalar: PrimeFieldBits
     + PrimeFieldExt
     + Send
     + Sync
-    + TranscriptReprTrait<Self>
+    + TranscriptReprTrait<Self::GE>
     + Serialize
     + for<'de> Deserialize<'de>;
 
+  /// A type that represents an element of the group
+  type GE: Group<Base = Self::Base, Scalar = Self::Scalar> + Serialize + for<'de> Deserialize<'de>;
+
   /// A type that represents a circuit-friendly sponge that consumes elements
   /// from the base field and squeezes out elements of the scalar field
   type RO: ROTrait<Self::Base, Self::Scalar>;
@@ -38,15 +53,12 @@ pub trait Group: Clone + Copy + Debug + Send + Sync + Sized + Eq + PartialEq {
 
   /// A type that defines a commitment engine over scalars in the group
   type CE: CommitmentEngineTrait<Self>;
-
-  /// Returns A, B, the order of the group, the size of the base field as big integers
-  fn get_curve_params() -> (Self::Base, Self::Base, BigInt, BigInt);
 }
 
 /// A helper trait to absorb different objects in RO
-pub trait AbsorbInROTrait<G: Group> {
+pub trait AbsorbInROTrait<E: Engine> {
   /// Absorbs the value in the provided RO
-  fn absorb_in_ro(&self, ro: &mut G::RO);
+  fn absorb_in_ro(&self, ro: &mut E::RO);
 }
 
 /// A helper trait that defines the behavior of a hash function that we use as an RO
@@ -96,18 +108,20 @@ pub trait ROCircuitTrait<Base: PrimeField> {
   fn absorb(&mut self, e: &AllocatedNum<Base>);
 
   /// Returns a challenge of `num_bits` by hashing the internal state
-  fn squeeze<CS>(&mut self, cs: CS, num_bits: usize) -> Result<Vec<AllocatedBit>, SynthesisError>
-  where
-    CS: ConstraintSystem<Base>;
+  fn squeeze<CS: ConstraintSystem<Base>>(
+    &mut self,
+    cs: CS,
+    num_bits: usize,
+  ) -> Result<Vec<AllocatedBit>, SynthesisError>;
 }
 
-/// An alias for constants associated with `G::RO`
-pub type ROConstants<G> =
-  <<G as Group>::RO as ROTrait<<G as Group>::Base, <G as Group>::Scalar>>::Constants;
+/// An alias for constants associated with E::RO
+pub type ROConstants<E> =
+  <<E as Engine>::RO as ROTrait<<E as Engine>::Base, <E as Engine>::Scalar>>::Constants;
 
-/// An alias for constants associated with `G::ROCircuit`
-pub type ROConstantsCircuit<G> =
-  <<G as Group>::ROCircuit as ROCircuitTrait<<G as Group>::Base>>::Constants;
+/// An alias for constants associated with `E::ROCircuit`
+pub type ROConstantsCircuit<E> =
+  <<E as Engine>::ROCircuit as ROCircuitTrait<<E as Engine>::Base>>::Constants;
 
 /// This trait allows types to implement how they want to be added to `TranscriptEngine`
 pub trait TranscriptReprTrait<G: Group>: Send + Sync {
@@ -116,15 +130,15 @@ pub trait TranscriptReprTrait<G: Group>: Send + Sync {
 }
 
 /// This trait defines the behavior of a transcript engine compatible with Spartan
-pub trait TranscriptEngineTrait<G: Group>: Send + Sync {
+pub trait TranscriptEngineTrait<E: Engine>: Send + Sync {
   /// initializes the transcript
   fn new(label: &'static [u8]) -> Self;
 
   /// returns a scalar element of the group as a challenge
-  fn squeeze(&mut self, label: &'static [u8]) -> Result<G::Scalar, NovaError>;
+  fn squeeze(&mut self, label: &'static [u8]) -> Result<E::Scalar, NovaError>;
 
   /// absorbs any type that implements `TranscriptReprTrait` under a label
-  fn absorb<T: TranscriptReprTrait<G>>(&mut self, label: &'static [u8], o: &T);
+  fn absorb<T: TranscriptReprTrait<E::GE>>(&mut self, label: &'static [u8], o: &T);
 
   /// adds a domain separator
   fn dom_sep(&mut self, bytes: &'static [u8]);
diff --git a/src/traits/snark.rs b/src/traits/snark.rs
index 1b2657bcb..b9c9b13d5 100644
--- a/src/traits/snark.rs
+++ b/src/traits/snark.rs
@@ -2,7 +2,7 @@
 use crate::{
   errors::NovaError,
   r1cs::{R1CSShape, RelaxedR1CSInstance, RelaxedR1CSWitness},
-  traits::Group,
+  traits::Engine,
   CommitmentKey,
 };
 
@@ -13,56 +13,51 @@ use serde::{Deserialize, Serialize};
 /// the final compressing SNARK the user expected to use with these public parameters, and the below
 /// is a sensible default, which is to not require any more bases then the usual (maximum of the number of
 /// variables and constraints of the involved R1CS circuit).
-pub fn default_ck_hint<G: Group>() -> Box<dyn for<'a> Fn(&'a R1CSShape<G>) -> usize> {
+pub fn default_ck_hint<E: Engine>() -> Box<dyn for<'a> Fn(&'a R1CSShape<E>) -> usize> {
   // The default is to not put an additional floor on the size of the commitment key
-  Box::new(|_shape: &R1CSShape<G>| 0)
+  Box::new(|_shape: &R1CSShape<E>| 0)
 }
 
 /// A trait that defines the behavior of a `zkSNARK`
-pub trait RelaxedR1CSSNARKTrait<G: Group>:
+pub trait RelaxedR1CSSNARKTrait<E: Engine>:
   Send + Sync + Serialize + for<'de> Deserialize<'de>
 {
   /// A type that represents the prover's key
   type ProverKey: Send + Sync + Serialize + for<'de> Deserialize<'de> + Abomonation;
 
   /// A type that represents the verifier's key
-  type VerifierKey: Send
-    + Sync
-    + Serialize
-    + for<'de> Deserialize<'de>
-    + DigestHelperTrait<G>
-    + Abomonation;
+  type VerifierKey: Send + Sync + Serialize + for<'de> Deserialize<'de> + DigestHelperTrait<E> + Abomonation;
 
   /// This associated function (not a method) provides a hint that offers
   /// a minimum sizing cue for the commitment key used by this SNARK
   /// implementation. The commitment key passed in setup should then
   /// be at least as large as this hint.
-  fn ck_floor() -> Box<dyn for<'a> Fn(&'a R1CSShape<G>) -> usize> {
+  fn ck_floor() -> Box<dyn for<'a> Fn(&'a R1CSShape<E>) -> usize> {
     // The default is to not put an additional floor on the size of the commitment key
     default_ck_hint()
   }
 
   /// Produces the keys for the prover and the verifier
   fn setup(
-    ck: &CommitmentKey<G>,
-    S: &R1CSShape<G>,
+    ck: &CommitmentKey<E>,
+    S: &R1CSShape<E>,
   ) -> Result<(Self::ProverKey, Self::VerifierKey), NovaError>;
 
   /// Produces a new SNARK for a relaxed R1CS
   fn prove(
-    ck: &CommitmentKey<G>,
+    ck: &CommitmentKey<E>,
     pk: &Self::ProverKey,
-    S: &R1CSShape<G>,
-    U: &RelaxedR1CSInstance<G>,
-    W: &RelaxedR1CSWitness<G>,
+    S: &R1CSShape<E>,
+    U: &RelaxedR1CSInstance<E>,
+    W: &RelaxedR1CSWitness<E>,
   ) -> Result<Self, NovaError>;
 
   /// Verifies a SNARK for a relaxed R1CS
-  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<G>) -> Result<(), NovaError>;
+  fn verify(&self, vk: &Self::VerifierKey, U: &RelaxedR1CSInstance<E>) -> Result<(), NovaError>;
 }
 
 /// A helper trait that defines the behavior of a verifier key of `zkSNARK`
-pub trait DigestHelperTrait<G: Group> {
+pub trait DigestHelperTrait<E: Engine> {
   /// Returns the digest of the verifier's key
-  fn digest(&self) -> G::Scalar;
+  fn digest(&self) -> E::Scalar;
 }