diff --git a/halo2_backend/Cargo.toml b/halo2_backend/Cargo.toml
index 7b24994c3..d812d97f1 100644
--- a/halo2_backend/Cargo.toml
+++ b/halo2_backend/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Privacy Scaling Explorations team",
 ]
 edition = "2021"
-rust-version = "1.66.0"
+rust-version = "1.70.0"
 description = """
 Halo2 backend implementation.  This package implements the halo2 proof system which includes setup (key generation), proving and verifying.
 """
diff --git a/halo2_debug/Cargo.toml b/halo2_debug/Cargo.toml
index d86ea3755..a5e1763d6 100644
--- a/halo2_debug/Cargo.toml
+++ b/halo2_debug/Cargo.toml
@@ -5,7 +5,7 @@ authors = [
     "Privacy Scaling Explorations team",
 ]
 edition = "2021"
-rust-version = "1.66.0"
+rust-version = "1.70.0"
 description = """
 Halo2 Debug.  This package contains utilities for debugging and testing within
 the halo2 ecosystem.
diff --git a/halo2_frontend/Cargo.toml b/halo2_frontend/Cargo.toml
index 960d00f0b..20fed98cd 100644
--- a/halo2_frontend/Cargo.toml
+++ b/halo2_frontend/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Privacy Scaling Explorations team",
 ]
 edition = "2021"
-rust-version = "1.66.0"
+rust-version = "1.70.0"
 description = """
 Halo2 frontend implementation.  This package implements an API to write circuits, handles witness generation and contains the MockProver.
 """
@@ -38,9 +38,6 @@ halo2_middleware = { path = "../halo2_middleware" }
 # Developer tooling dependencies
 plotters = { version = "0.3.0", default-features = false, optional = true }
 tabbycat = { version = "0.1", features = ["attributes"], optional = true }
-once_cell = "1.19.0"
-parking_lot = "0.12.3"
-paste = "1.0.15"
 
 [dev-dependencies]
 proptest = "1"
diff --git a/halo2_frontend/src/circuit/table_layouter.rs b/halo2_frontend/src/circuit/table_layouter.rs
index 1c871b42a..3e93bec0f 100644
--- a/halo2_frontend/src/circuit/table_layouter.rs
+++ b/halo2_frontend/src/circuit/table_layouter.rs
@@ -380,7 +380,7 @@ mod tests {
                 meta.lookup("", |cells| {
                     let a = cells.query_advice(a, Rotation::cur());
 
-                    vec![(a.clone(), table.0), (a, table.1)]
+                    vec![(a, table.0), (a, table.1)]
                 });
 
                 Self::Config { table }
diff --git a/halo2_frontend/src/dev.rs b/halo2_frontend/src/dev.rs
index 2397147f4..6262e52a2 100644
--- a/halo2_frontend/src/dev.rs
+++ b/halo2_frontend/src/dev.rs
@@ -184,7 +184,7 @@ impl<F: FieldFront> Mul<F> for Value<F> {
 /// use halo2_frontend::{
 ///     circuit::{Layouter, SimpleFloorPlanner, Value},
 ///     dev::{FailureLocation, MockProver, VerifyFailure},
-///     plonk::{circuit::Column, Circuit, ConstraintSystem, Error, Advice, Selector},
+///     plonk::{circuit::Column, Circuit, ConstraintSystem, Error, Advice, Selector, FieldFront},
 /// };
 /// use halo2_middleware::circuit::{Any, ColumnMid};
 /// use halo2_middleware::poly::Rotation;
@@ -206,7 +206,7 @@ impl<F: FieldFront> Mul<F> for Value<F> {
 ///     b: Value<u64>,
 /// }
 ///
-/// impl<F: PrimeField> Circuit<F> for MyCircuit {
+/// impl<F: FieldFront + From<u64>> Circuit<F> for MyCircuit {
 ///     type Config = MyConfig;
 ///     type FloorPlanner = SimpleFloorPlanner;
 ///     #[cfg(feature = "circuit-params")]
@@ -284,7 +284,7 @@ impl<F: FieldFront> Mul<F> for Value<F> {
 ///     MockProver::<Fp>::run(2, &circuit, vec![]).unwrap_err()
 /// });
 /// assert_eq!(
-///     result.unwrap_err().downcast_rF::<String>().unwrap(),
+///     result.unwrap_err().downcast_ref::<String>().unwrap(),
 ///     "n=4, minimum_rows=8, k=2"
 /// );
 /// ```
@@ -1376,13 +1376,10 @@ mod tests {
 
                     // If q is enabled, a must be in the table.
                     // When q is not enabled, lookup the default value instead.
-                    let not_q = Expression::Constant(Fp::one()) - q.clone();
+                    let not_q = Expression::Constant(Fp::one()) - q;
                     let default = Expression::Constant(Fp::from(2));
                     vec![
-                        (
-                            q.clone() * a.clone() + not_q.clone() * default.clone(),
-                            table,
-                        ),
+                        (q * a + not_q * default, table),
                         (q * a + not_q * default, advice_table),
                     ]
                 });
@@ -1540,7 +1537,7 @@ mod tests {
 
                     // If q is enabled, a must be in the table.
                     // When q is not enabled, lookup the default value instead.
-                    let not_q = Expression::Constant(Fp::one()) - q.clone();
+                    let not_q = Expression::Constant(Fp::one()) - q;
                     let default = Expression::Constant(Fp::from(2));
                     vec![(q * a + not_q * default, table)]
                 });
diff --git a/halo2_frontend/src/dev/gates.rs b/halo2_frontend/src/dev/gates.rs
index 54fb8c471..4ac5e7717 100644
--- a/halo2_frontend/src/dev/gates.rs
+++ b/halo2_frontend/src/dev/gates.rs
@@ -29,7 +29,7 @@ struct Gate {
 /// use halo2_frontend::{
 ///     circuit::{Layouter, SimpleFloorPlanner},
 ///     dev::CircuitGates,
-///     plonk::{Circuit, ConstraintSystem, Error},
+///     plonk::{Circuit, ConstraintSystem, Error, FieldFront},
 /// };
 /// use halo2curves::pasta::pallas;
 ///
diff --git a/halo2_frontend/src/dev/tfp.rs b/halo2_frontend/src/dev/tfp.rs
index eecb9cb9f..892e1c4e9 100644
--- a/halo2_frontend/src/dev/tfp.rs
+++ b/halo2_frontend/src/dev/tfp.rs
@@ -35,7 +35,7 @@ use crate::{
 /// use halo2_frontend::{
 ///     circuit::{floor_planner, Layouter, Value},
 ///     dev::TracingFloorPlanner,
-///     plonk::{Circuit, ConstraintSystem, Error},
+///     plonk::{Circuit, ConstraintSystem, Error, FieldFront},
 /// };
 ///
 /// # struct MyCircuit<F: FieldFront> {
diff --git a/halo2_frontend/src/plonk/circuit.rs b/halo2_frontend/src/plonk/circuit.rs
index 552e415fd..14ba46f32 100644
--- a/halo2_frontend/src/plonk/circuit.rs
+++ b/halo2_frontend/src/plonk/circuit.rs
@@ -3,10 +3,13 @@ use crate::plonk::{Assigned, Error};
 use halo2_middleware::circuit::Any;
 use halo2_middleware::poly::Rotation;
 
+pub mod arena;
 pub mod compress_selectors;
 pub mod constraint_system;
 pub mod expression;
 
+pub use arena::FieldFront;
+
 pub use constraint_system::*;
 pub use expression::*;
 
diff --git a/halo2_frontend/src/plonk/circuit/arena.rs b/halo2_frontend/src/plonk/circuit/arena.rs
new file mode 100644
index 000000000..676c73845
--- /dev/null
+++ b/halo2_frontend/src/plonk/circuit/arena.rs
@@ -0,0 +1,73 @@
+use super::ExprRef;
+use super::Expression;
+
+use halo2_middleware::ff::Field;
+
+/// A field that allows to store `Expression`s in an arena.
+pub trait FieldFront: Field {
+    // Since base trait is not referenciable, we need a way to access it.
+    // This is necessary to provide a way to transform fields from/to backend.
+    type Field: Field;
+
+    /// Transform FieldFront to Field
+    fn into_field(self) -> Self::Field;
+
+    /// Transform Field to FieldFront
+    fn into_fieldfront(f: Self::Field) -> Self;
+
+    /// Allocate a new expression to the arena.
+    fn alloc(expr: Expression<Self>) -> ExprRef<Self>;
+
+    /// Get an expression from the arena, panics if the reference is invalid.
+    fn get(ref_: &ExprRef<Self>) -> Expression<Self>;
+}
+
+#[derive(Default)]
+struct ExprArena<F: FieldFront>(Vec<Expression<F>>);
+
+impl<F: FieldFront> ExprArena<F> {
+    fn push(&mut self, expr: Expression<F>) -> crate::plonk::ExprRef<F> {
+        let index = self.0.len();
+        self.0.push(expr);
+        ExprRef(index, std::marker::PhantomData)
+    }
+    fn get(&self, ref_: crate::plonk::ExprRef<F>) -> &Expression<F> {
+        &self.0[ref_.0]
+    }
+}
+
+#[macro_export]
+macro_rules! expression_arena {
+    ($arena:ident, $field:ty) => {
+        fn $arena() -> &'static std::sync::RwLock<ExprArena<$field>> {
+            static LINES: std::sync::OnceLock<std::sync::RwLock<ExprArena<$field>>> =
+                std::sync::OnceLock::new();
+            LINES.get_or_init(|| std::sync::RwLock::new(ExprArena::default()))
+        }
+
+        impl $crate::plonk::FieldFront for $field {
+            type Field = $field;
+            fn into_field(self) -> Self::Field {
+                self
+            }
+            fn into_fieldfront(f: Self::Field) -> Self {
+                f
+            }
+            fn alloc(expr: $crate::plonk::Expression<Self>) -> $crate::plonk::ExprRef<Self> {
+                $arena().write().unwrap().push(expr)
+            }
+            fn get(ref_: &$crate::plonk::ExprRef<Self>) -> $crate::plonk::Expression<Self> {
+                *$arena().read().unwrap().get(*ref_)
+            }
+        }
+        impl From<$field> for $crate::plonk::ExprRef<$field> {
+            fn from(f: $field) -> Self {
+                $crate::plonk::FieldFront::alloc($crate::plonk::Expression::Constant(f))
+            }
+        }
+    };
+}
+
+// Field scalar arenas
+expression_arena!(arena_bn256_fr, halo2curves::bn256::Fr);
+expression_arena!(arena_pasta_fp, halo2curves::pasta::Fp);
\ No newline at end of file
diff --git a/halo2_frontend/src/plonk/circuit/compress_selectors.rs b/halo2_frontend/src/plonk/circuit/compress_selectors.rs
index 70c252067..406f1cc8f 100644
--- a/halo2_frontend/src/plonk/circuit/compress_selectors.rs
+++ b/halo2_frontend/src/plonk/circuit/compress_selectors.rs
@@ -190,11 +190,11 @@ where
             // which is non-zero only on rows where `combination_assignment` is set to
             // `assigned_root`. In particular, rows set to 0 correspond to all selectors
             // being disabled.
-            let mut expression = query.clone();
+            let mut expression = query;
             let mut root = F::ONE;
             for _ in 0..combination_len {
                 if root != assigned_root {
-                    expression = expression * (Expression::Constant(root) - query.clone());
+                    expression = expression * (Expression::Constant(root) - query);
                 }
                 root += F::ONE;
             }
diff --git a/halo2_frontend/src/plonk/circuit/constraint_system.rs b/halo2_frontend/src/plonk/circuit/constraint_system.rs
index f7edbb6b3..68c69aa55 100644
--- a/halo2_frontend/src/plonk/circuit/constraint_system.rs
+++ b/halo2_frontend/src/plonk/circuit/constraint_system.rs
@@ -709,7 +709,7 @@ impl<F: FieldFront> ConstraintSystem<F> {
                         assert!(!selector.is_simple());
                     }
 
-                    selector_replacements[selector.0].clone()
+                    selector_replacements[selector.0]
                 },
                 &|query| Expression::Fixed(query),
                 &|query| Expression::Advice(query),
diff --git a/halo2_frontend/src/plonk/circuit/expression.rs b/halo2_frontend/src/plonk/circuit/expression.rs
index 4279b7a18..1970a1e7f 100644
--- a/halo2_frontend/src/plonk/circuit/expression.rs
+++ b/halo2_frontend/src/plonk/circuit/expression.rs
@@ -1,3 +1,4 @@
+use super::arena::FieldFront;
 use crate::circuit::Region;
 use crate::plonk::circuit::{Advice, ColumnType, Fixed, Instance, VirtualCells};
 use crate::plonk::Error;
@@ -253,7 +254,7 @@ impl SealedPhase for ThirdPhase {
 /// row when required:
 /// ```
 /// use halo2_frontend::circuit::{Chip, Layouter, Value};
-/// use halo2_frontend::plonk::{Advice, Fixed, Error, Column, Selector};
+/// use halo2_frontend::plonk::{Advice, Fixed, Error, Column, Selector, FieldFront};
 /// use halo2_middleware::ff::Field;
 ///
 /// struct Config {
@@ -470,47 +471,16 @@ pub enum Expression<F: FieldFront> {
     Ref(ExprRef<F>),
 }
 
-// Arena context
-pub trait FieldFront: Field {
-    type Field: Field;
-    fn alloc(expr: Expression<Self>) -> ExprRef<Self>;
-    fn get(ref_: &ExprRef<Self>) -> Expression<Self>;
-    fn into_field(self) -> Self::Field;
-    fn into_field_fr(f: Self::Field) -> Self;
-}
-
 #[derive(Clone, Copy, Eq, PartialEq)]
-pub struct ExprRef<F>(usize, std::marker::PhantomData<F>);
-impl<F: FieldFront> Into<ExprRef<F>> for Expression<F> {
-    fn into(self) -> ExprRef<F> {
-        F::alloc(self)
-    }
-}
-
-#[allow(unused)]
-struct ArenaPool<F: FieldFront> {
-    expressions: Vec<Expression<F>>,
-}
-
-#[allow(unused)]
-impl<F: FieldFront> ArenaPool<F> {
-    fn new() -> Self {
-        Self {
-            expressions: Vec::new(),
-        }
-    }
-    fn push(&mut self, expr: Expression<F>) -> ExprRef<F> {
-        let index = self.expressions.len();
-        self.expressions.push(expr);
-        ExprRef(index, std::marker::PhantomData)
-    }
-    fn get(&self, ref_: ExprRef<F>) -> &Expression<F> {
-        &self.expressions[ref_.0]
+pub struct ExprRef<F>(pub(crate) usize, pub(crate) std::marker::PhantomData<F>);
+impl<F: FieldFront> From<Expression<F>> for ExprRef<F> {
+    fn from(val: Expression<F>) -> Self {
+        F::alloc(val)
     }
 }
 
-impl<F: FieldFront<Field = IF>, IF: Field> From<Expression<F>> for ExpressionMid<IF> {
-    fn from(val: Expression<F>) -> Self {
+impl<FF: FieldFront<Field = F>, F: Field> From<Expression<FF>> for ExpressionMid<F> {
+    fn from(val: Expression<FF>) -> Self {
         match val {
             Expression::Constant(c) => ExpressionMid::Constant(c.into_field()),
             Expression::Selector(_) => unreachable!(),
@@ -542,18 +512,20 @@ impl<F: FieldFront<Field = IF>, IF: Field> From<Expression<F>> for ExpressionMid
                 rotation,
             })),
             Expression::Challenge(c) => ExpressionMid::Var(VarMid::Challenge(c.into())),
-            Expression::Negated(e) => ExpressionMid::Negated(Box::new((F::get(&e)).into())),
-            Expression::Sum(lhs, rhs) => {
-                ExpressionMid::Sum(Box::new(F::get(&lhs).into()), Box::new(F::get(&rhs).into()))
-            }
-            Expression::Product(lhs, rhs) => {
-                ExpressionMid::Product(Box::new(F::get(&lhs).into()), Box::new(F::get(&rhs).into()))
-            }
+            Expression::Negated(e) => ExpressionMid::Negated(Box::new((FF::get(&e)).into())),
+            Expression::Sum(lhs, rhs) => ExpressionMid::Sum(
+                Box::new(FF::get(&lhs).into()),
+                Box::new(FF::get(&rhs).into()),
+            ),
+            Expression::Product(lhs, rhs) => ExpressionMid::Product(
+                Box::new(FF::get(&lhs).into()),
+                Box::new(FF::get(&rhs).into()),
+            ),
             Expression::Scaled(e, c) => ExpressionMid::Product(
-                Box::new(F::get(&e).into()),
+                Box::new(FF::get(&e).into()),
                 Box::new(ExpressionMid::Constant(c.into_field())),
             ),
-            Expression::Ref(ref_) => F::get(&ref_).into(),
+            Expression::Ref(ref_) => FF::get(&ref_).into(),
         }
     }
 }
@@ -1182,61 +1154,6 @@ impl<F: FieldFront> Product<Self> for Expression<F> {
     }
 }
 
-#[allow(non_camel_case_types)]
-pub struct ExprArena<F: FieldFront>(Vec<Expression<F>>);
-
-impl<F: FieldFront> ExprArena<F> {
-    pub fn new() -> Self {
-        Self(Vec::new())
-    }
-    pub fn push(&mut self, expr: Expression<F>) -> crate::plonk::ExprRef<F> {
-        let index = self.0.len();
-        self.0.push(expr);
-        ExprRef(index, std::marker::PhantomData)
-    }
-    pub fn get(&self, ref_: crate::plonk::ExprRef<F>) -> &Expression<F> {
-        &self.0[ref_.0]
-    }
-}
-
-#[macro_export]
-macro_rules! expression_arena {
-    ($arena:ident, $field:ty) => {
-        fn $arena() -> &'static std::sync::RwLock<ExprArena<$field>> {
-            static LINES: std::sync::OnceLock<std::sync::RwLock<ExprArena<$field>>> =
-                std::sync::OnceLock::new();
-            LINES.get_or_init(|| std::sync::RwLock::new(ExprArena::new()))
-        }
-
-        impl crate::plonk::FieldFront for $field {
-            type Field = $field;
-            fn into_field(self) -> Self::Field {
-                self
-            }
-            fn into_field_fr(f: Self::Field) -> Self {
-                f
-            }
-            fn alloc(expr: crate::plonk::Expression<Self>) -> crate::plonk::ExprRef<Self> {
-                $arena().write().unwrap().push(expr)
-            }
-            fn get(ref_: &crate::plonk::ExprRef<Self>) -> crate::plonk::Expression<Self> {
-                *$arena().read().unwrap().get(*ref_)
-            }
-        }
-
-        impl Into<crate::plonk::ExprRef<$field>> for $field {
-            fn into(self) -> crate::plonk::ExprRef<$field> {
-                crate::plonk::FieldFront::alloc(crate::plonk::Expression::Constant(self))
-            }
-        }
-    };
-}
-
-//#[cfg(test)]
-expression_arena!(arena_bn256_fr, halo2curves::bn256::Fr);
-expression_arena!(arena_bn256_fq, halo2curves::bn256::Fq);
-expression_arena!(arena_pasta_fp, halo2curves::pasta::Fp);
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/halo2_middleware/Cargo.toml b/halo2_middleware/Cargo.toml
index 1c24c77c6..c2ae45eb1 100644
--- a/halo2_middleware/Cargo.toml
+++ b/halo2_middleware/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Privacy Scaling Explorations team",
 ]
 edition = "2021"
-rust-version = "1.66.0"
+rust-version = "1.70.0"
 description = """
 Halo2 middleware.  This package contains the types and traits required for the frontend-backend interaction.
 """
diff --git a/halo2_proofs/Cargo.toml b/halo2_proofs/Cargo.toml
index 174bcae6c..5a690f65a 100644
--- a/halo2_proofs/Cargo.toml
+++ b/halo2_proofs/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Privacy Scaling Explorations team",
 ]
 edition = "2021"
-rust-version = "1.66.0"
+rust-version = "1.70.0"
 description = """
 Fast PLONK-based zero-knowledge proving system with no trusted setup
 """
@@ -63,8 +63,6 @@ proptest = "1"
 dhat = "0.3.2"
 serde_json = "1"
 halo2_debug = { path = "../halo2_debug" }
-parking_lot = "0.12.3"
-once_cell = "1.19"
 
 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dev-dependencies]
 getrandom = { version = "0.2", features = ["js"] }
diff --git a/halo2_proofs/benches/dev_lookup.rs b/halo2_proofs/benches/dev_lookup.rs
index ad03956d9..d30ba1107 100644
--- a/halo2_proofs/benches/dev_lookup.rs
+++ b/halo2_proofs/benches/dev_lookup.rs
@@ -1,7 +1,6 @@
 #[macro_use]
 extern crate criterion;
 
-use ff::{Field, PrimeField};
 use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::circuit::{Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::dev::MockProver;
@@ -45,7 +44,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
             meta.lookup("lookup", |meta| {
                 let selector = meta.query_selector(config.selector);
-                let not_selector = Expression::Constant(F::ONE) - selector.clone();
+                let not_selector = Expression::Constant(F::ONE) - selector;
                 let advice = meta.query_advice(config.advice, Rotation::cur());
                 vec![(selector * advice + not_selector, config.table)]
             });
diff --git a/halo2_proofs/benches/plonk.rs b/halo2_proofs/benches/plonk.rs
index 100c76b5f..bde08dc00 100644
--- a/halo2_proofs/benches/plonk.rs
+++ b/halo2_proofs/benches/plonk.rs
@@ -226,7 +226,7 @@ fn criterion_benchmark(c: &mut Criterion) {
                 let sc = meta.query_fixed(sc, Rotation::cur());
                 let sm = meta.query_fixed(sm, Rotation::cur());
 
-                vec![a.clone() * sa + b.clone() * sb + a * b * sm - (c * sc)]
+                vec![a * sa + b * sb + a * b * sm - (c * sc)]
             });
 
             PlonkConfig {
@@ -311,7 +311,14 @@ fn criterion_benchmark(c: &mut Criterion) {
     fn verifier(params: &ParamsIPA<EqAffine>, vk: &VerifyingKey<EqAffine>, proof: &[u8]) {
         let strategy = SingleStrategy::new(params);
         let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(proof);
-        assert!(verify_proof(params, vk, strategy, &[vec![vec![]]], &mut transcript).is_ok());
+        assert!(verify_proof::<_, _, _, _, _, halo2curves::pasta::Fp>(
+            params,
+            vk,
+            strategy,
+            &[vec![vec![]]],
+            &mut transcript
+        )
+        .is_ok());
     }
 
     let k_range = 8..=16;
diff --git a/halo2_proofs/examples/circuit-layout.rs b/halo2_proofs/examples/circuit-layout.rs
index c0e206fee..8516762ad 100644
--- a/halo2_proofs/examples/circuit-layout.rs
+++ b/halo2_proofs/examples/circuit-layout.rs
@@ -1,7 +1,10 @@
 use ff::Field;
 use halo2_proofs::{
     circuit::{Cell, Layouter, Region, SimpleFloorPlanner, Value},
-    plonk::{Advice, Assigned, Circuit, Column, ConstraintSystem, ErrorFront, Fixed, TableColumn},
+    plonk::{
+        Advice, Assigned, Circuit, Column, ConstraintSystem, ErrorFront, FieldFront, Fixed,
+        TableColumn,
+    },
     poly::Rotation,
 };
 use halo2curves::pasta::Fp;
@@ -28,7 +31,7 @@ struct PlonkConfig {
     sl: TableColumn,
 }
 
-trait StandardCs<FF: Field> {
+trait StandardCs<FF: FieldFront> {
     fn raw_multiply<F>(
         &self,
         region: &mut Region<FF>,
@@ -57,7 +60,7 @@ struct StandardPlonk<F: FieldFront> {
     _marker: PhantomData<F>,
 }
 
-impl<FF: Field> StandardPlonk<FF> {
+impl<FF: FieldFront> StandardPlonk<FF> {
     fn new(config: PlonkConfig) -> Self {
         StandardPlonk {
             config,
@@ -66,7 +69,7 @@ impl<FF: Field> StandardPlonk<FF> {
     }
 }
 
-impl<FF: Field> StandardCs<FF> for StandardPlonk<FF> {
+impl<FF: FieldFront> StandardCs<FF> for StandardPlonk<FF> {
     fn raw_multiply<F>(
         &self,
         region: &mut Region<FF>,
diff --git a/halo2_proofs/examples/simple-example.rs b/halo2_proofs/examples/simple-example.rs
index 2578c36d2..f18a9c4df 100644
--- a/halo2_proofs/examples/simple-example.rs
+++ b/halo2_proofs/examples/simple-example.rs
@@ -2,7 +2,6 @@ use std::marker::PhantomData;
 
 use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
-    arithmetic::Field,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
     plonk::{Advice, Circuit, Column, ConstraintSystem, ErrorFront, Fixed, Instance, Selector},
     poly::Rotation,
diff --git a/halo2_proofs/examples/vector-mul.rs b/halo2_proofs/examples/vector-mul.rs
index 28ec830a6..e6af78429 100644
--- a/halo2_proofs/examples/vector-mul.rs
+++ b/halo2_proofs/examples/vector-mul.rs
@@ -2,7 +2,6 @@ use std::marker::PhantomData;
 
 use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
-    arithmetic::Field,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
     plonk::{Advice, Circuit, Column, ConstraintSystem, ErrorFront, Instance, Selector},
     poly::Rotation,
diff --git a/halo2_proofs/src/plonk.rs b/halo2_proofs/src/plonk.rs
index b3d3232f9..9605afcac 100644
--- a/halo2_proofs/src/plonk.rs
+++ b/halo2_proofs/src/plonk.rs
@@ -8,15 +8,11 @@
 mod error;
 mod keygen;
 mod prover;
-mod verifier {
-    pub use halo2_backend::plonk::verifier::verify_proof;
-}
 
-use halo2_frontend::{circuit::compile_circuit, plonk::FieldFront};
+pub use halo2_frontend::{circuit::compile_circuit, plonk::FieldFront};
 pub use keygen::{keygen_pk, keygen_pk_custom, keygen_vk, keygen_vk_custom};
 
-pub use prover::{create_proof, create_proof_with_engine};
-pub use verifier::verify_proof;
+pub use prover::{create_proof, create_proof_with_engine, verify_proof};
 
 pub use error::Error;
 pub use halo2_backend::plonk::{Error as ErrorBack, ProvingKey, VerifyingKey};
diff --git a/halo2_proofs/src/plonk/prover.rs b/halo2_proofs/src/plonk/prover.rs
index e4fefb1a7..8449eb127 100644
--- a/halo2_proofs/src/plonk/prover.rs
+++ b/halo2_proofs/src/plonk/prover.rs
@@ -1,7 +1,11 @@
 use crate::plonk::{Error, ErrorBack};
 use crate::poly::commitment::{self, CommitmentScheme, Params};
 use crate::transcript::{EncodedChallenge, TranscriptWrite};
+use halo2_backend::plonk::VerifyingKey;
 use halo2_backend::plonk::{prover::Prover, ProvingKey};
+use halo2_backend::poly::commitment::Verifier;
+use halo2_backend::poly::VerificationStrategy;
+use halo2_backend::transcript::TranscriptRead;
 use halo2_frontend::circuit::WitnessCalculator;
 use halo2_frontend::plonk::{Circuit, ConstraintSystem, FieldFront};
 use halo2_middleware::ff::{FromUniformBytes, WithSmallOrderMulGroup};
@@ -12,6 +16,35 @@ use halo2_middleware::zal::{
 use rand_core::RngCore;
 use std::collections::HashMap;
 
+fn instances_frontfield_to_field<F: FieldFront>(
+    instances: &[Vec<Vec<F>>],
+) -> Vec<Vec<Vec<F::Field>>> {
+    instances
+        .iter()
+        .map(|v| {
+            v.iter()
+                .map(|v| v.iter().map(|f| f.into_field()).collect())
+                .collect()
+        })
+        .collect()
+}
+
+fn witnesses_frontfield_to_field<F: FieldFront>(
+    witnesses: Vec<Vec<Option<Vec<F>>>>,
+) -> Vec<Vec<Option<Vec<F::Field>>>> {
+    witnesses
+        .iter()
+        .map(|v| {
+            v.iter()
+                .map(|v| {
+                    v.as_ref()
+                        .map(|v| v.iter().map(|f| f.into_field()).collect())
+                })
+                .collect()
+        })
+        .collect()
+}
+
 /// This creates a proof for the provided `circuit` when given the public
 /// parameters `params` and the proving key [`ProvingKey`] that was
 /// generated previously for the same circuit. The provided `instances`
@@ -57,14 +90,7 @@ where
         })
         .collect();
 
-    let instances: Vec<Vec<Vec<Scheme::Scalar>>> = instances
-        .iter()
-        .map(|v| {
-            v.into_iter()
-                .map(|v| v.into_iter().map(|f| f.into_field()).collect())
-                .collect()
-        })
-        .collect();
+    let instances = instances_frontfield_to_field(instances);
 
     let mut prover = Prover::<Scheme, P, _, _, _, _>::new_with_engine(
         engine, params, pk, &instances, rng, transcript,
@@ -77,23 +103,13 @@ where
             witnesses.push(witness_calc.calc(*phase, &challenges)?);
         }
 
-        let witnesses: Vec<Vec<Option<Vec<Scheme::Scalar>>>> = witnesses
-            .iter()
-            .map(|v| {
-                v.into_iter()
-                    .map(|v| {
-                        v.as_ref()
-                            .map(|v| v.into_iter().map(|f| f.into_field()).collect())
-                    })
-                    .collect()
-            })
-            .collect();
+        let witnesses = witnesses_frontfield_to_field(witnesses);
 
         challenges = prover
             .commit_phase(*phase, witnesses)
             .unwrap()
             .into_iter()
-            .map(|(k, v)| (k, F::into_field_fr(v)))
+            .map(|(k, v)| (k, F::into_fieldfront(v)))
             .collect();
     }
     Ok(prover.create_proof()?)
@@ -126,10 +142,35 @@ where
     let engine = PlonkEngineConfig::build_default();
 
     create_proof_with_engine::<Scheme, P, _, _, _, _, _, _>(
-        engine, params, pk, circuits, &instances, rng, transcript,
+        engine, params, pk, circuits, instances, rng, transcript,
     )
 }
 
+/// Returns a boolean indicating whether or not the proof is valid
+pub fn verify_proof<
+    'params,
+    Scheme: CommitmentScheme,
+    V: Verifier<'params, Scheme>,
+    E: EncodedChallenge<Scheme::Curve>,
+    T: TranscriptRead<Scheme::Curve, E>,
+    Strategy: VerificationStrategy<'params, Scheme, V>,
+    F: FieldFront<Field = Scheme::Scalar>,
+>(
+    params: &'params Scheme::ParamsVerifier,
+    vk: &VerifyingKey<Scheme::Curve>,
+    strategy: Strategy,
+    instances: &[Vec<Vec<F>>],
+    transcript: &mut T,
+) -> Result<Strategy::Output, Error>
+where
+    Scheme::Scalar: WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
+{
+    let instances = instances_frontfield_to_field(instances);
+    Ok(halo2_backend::plonk::verifier::verify_proof(
+        params, vk, strategy, &instances, transcript,
+    )?)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/halo2_proofs/tests/compress_selectors.rs b/halo2_proofs/tests/compress_selectors.rs
index b14ae5324..a90b36453 100644
--- a/halo2_proofs/tests/compress_selectors.rs
+++ b/halo2_proofs/tests/compress_selectors.rs
@@ -399,14 +399,13 @@ fn test_mycircuit(
         Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice());
     let strategy = SingleStrategy::new(&verifier_params);
 
-    verify_proof::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _>(
+    verify_proof::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _, _>(
         &verifier_params,
         &vk,
         strategy,
         instances.as_slice(),
         &mut verifier_transcript,
     )
-    .map_err(halo2_proofs::plonk::Error::Backend)
 }
 
 /*
diff --git a/halo2_proofs/tests/frontend_backend_split.rsx b/halo2_proofs/tests/frontend_backend_split.rs
similarity index 96%
rename from halo2_proofs/tests/frontend_backend_split.rsx
rename to halo2_proofs/tests/frontend_backend_split.rs
index 5c965191b..870fbd4fd 100644
--- a/halo2_proofs/tests/frontend_backend_split.rsx
+++ b/halo2_proofs/tests/frontend_backend_split.rs
@@ -64,7 +64,7 @@ struct MyCircuitConfig {
 
 impl MyCircuitConfig {
     #[allow(clippy::type_complexity)]
-    fn assign_gate<F: Field + From<u64>>(
+    fn assign_gate<F: FieldFront + From<u64>>(
         &self,
         region: &mut Region<'_, F>,
         offset: &mut usize,
@@ -103,7 +103,7 @@ struct MyCircuit<F: Field, const WIDTH_FACTOR: usize> {
     _marker: std::marker::PhantomData<F>,
 }
 
-impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR> {
+impl<F: FieldFront + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR> {
     fn new(k: u32, input: u64) -> Self {
         Self {
             k,
@@ -180,8 +180,8 @@ impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR>
             let b = meta.query_advice(b, Rotation::cur());
             let c = meta.query_advice(c, Rotation::cur());
             let d = meta.query_fixed(d, Rotation::cur());
-            let lhs = [one.clone(), a, b].map(|c| c * s_lookup.clone());
-            let rhs = [one.clone(), d, c].map(|c| c * s_ltable.clone());
+            let lhs = [one, a, b].map(|c| c * s_lookup);
+            let rhs = [one, d, c].map(|c| c * s_ltable);
             lhs.into_iter().zip(rhs).collect()
         });
 
@@ -190,8 +190,8 @@ impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR>
             let s_stable = meta.query_fixed(s_stable, Rotation::cur());
             let a = meta.query_advice(a, Rotation::cur());
             let b = meta.query_advice(b, Rotation::cur());
-            let lhs = [one.clone(), a].map(|c| c * s_shuffle.clone());
-            let rhs = [one.clone(), b].map(|c| c * s_stable.clone());
+            let lhs = [one, a].map(|c| c * s_shuffle);
+            let rhs = [one, b].map(|c| c * s_stable);
             lhs.into_iter().zip(rhs).collect()
         });
 
@@ -205,7 +205,7 @@ impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR>
             let challenge = meta.query_challenge(challenge);
 
             vec![
-                s_rlc.clone() * (a + challenge.clone() * b - e.clone()),
+                s_rlc * (a + challenge * b - e),
                 s_rlc * (c + challenge * d - e),
             ]
         });
@@ -413,7 +413,9 @@ impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> MyCircuit<F, WIDTH_FACTOR>
     }
 }
 
-impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> Circuit<F> for MyCircuit<F, WIDTH_FACTOR> {
+impl<F: FieldFront + From<u64>, const WIDTH_FACTOR: usize> Circuit<F>
+    for MyCircuit<F, WIDTH_FACTOR>
+{
     type Config = Vec<MyCircuitConfig>;
     type FloorPlanner = SimpleFloorPlanner;
     #[cfg(feature = "circuit-params")]
@@ -466,9 +468,12 @@ impl<F: Field + From<u64>, const WIDTH_FACTOR: usize> Circuit<F> for MyCircuit<F
     }
 }
 
-use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG};
 use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
+use halo2_proofs::{
+    plonk::FieldFront,
+    poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG},
+};
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 use rand_core::block::BlockRng;
 use rand_core::block::BlockRngCore;
@@ -504,9 +509,6 @@ const WIDTH_FACTOR: usize = 1;
 
 #[test]
 fn test_mycircuit_full_legacy() {
-    #[cfg(all(feature = "heap-profiling", not(coverage)))]
-    let _profiler = dhat::Profiler::new_heap();
-
     use halo2_proofs::plonk::{
         create_proof, keygen_pk as keygen_pk_legacy, keygen_vk as keygen_vk_legacy,
     };
@@ -527,7 +529,15 @@ fn test_mycircuit_full_legacy() {
 
     let start = Instant::now();
     let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
-    create_proof::<KZGCommitmentScheme<Bn256>, ProverSHPLONK<'_, Bn256>, _, _, _, _>(
+    create_proof::<
+        KZGCommitmentScheme<Bn256>,
+        ProverSHPLONK<'_, Bn256>,
+        _,
+        _,
+        _,
+        _,
+        halo2curves::bn256::Fr,
+    >(
         &params,
         &pk,
         &[circuit],
diff --git a/halo2_proofs/tests/plonk_api.rsx b/halo2_proofs/tests/plonk_api.rs
similarity index 93%
rename from halo2_proofs/tests/plonk_api.rsx
rename to halo2_proofs/tests/plonk_api.rs
index 5ca0fe358..2a90abe2e 100644
--- a/halo2_proofs/tests/plonk_api.rsx
+++ b/halo2_proofs/tests/plonk_api.rs
@@ -7,7 +7,6 @@ use halo2_middleware::zal::{
     impls::{PlonkEngine, PlonkEngineConfig},
     traits::MsmAccel,
 };
-use halo2_proofs::arithmetic::Field;
 use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::plonk::{
@@ -22,9 +21,22 @@ use halo2_proofs::transcript::{
     Blake2bRead, Blake2bWrite, Challenge255, EncodedChallenge, TranscriptReadBuffer,
     TranscriptWriterBuffer,
 };
+use halo2_proofs::{arithmetic::Field, plonk::FieldFront};
 use rand_core::{OsRng, RngCore};
 use std::marker::PhantomData;
 
+macro_rules! common {
+    ($scheme:ident) => {{
+        let a = <$scheme as CommitmentScheme>::Scalar::from(2834758237)
+            * <$scheme as CommitmentScheme>::Scalar::ZETA;
+        let instance =
+            <$scheme as CommitmentScheme>::Scalar::ONE + <$scheme as CommitmentScheme>::Scalar::ONE;
+        let lookup_table = vec![instance, a, a, <$scheme as CommitmentScheme>::Scalar::ZERO];
+
+        (a, instance, lookup_table)
+    }};
+}
+
 #[test]
 fn plonk_api() {
     const K: u32 = 5;
@@ -51,7 +63,7 @@ fn plonk_api() {
     }
 
     #[allow(clippy::type_complexity)]
-    trait StandardCs<FF: Field> {
+    trait StandardCs<FF: FieldFront> {
         fn raw_multiply<F>(
             &self,
             layouter: &mut impl Layouter<FF>,
@@ -97,7 +109,7 @@ fn plonk_api() {
         _marker: PhantomData<F>,
     }
 
-    impl<FF: Field> StandardPlonk<FF> {
+    impl<FF: FieldFront> StandardPlonk<FF> {
         fn new(config: PlonkConfig) -> Self {
             StandardPlonk {
                 config,
@@ -106,7 +118,7 @@ fn plonk_api() {
         }
     }
 
-    impl<FF: Field> StandardCs<FF> for StandardPlonk<FF> {
+    impl<FF: FieldFront> StandardCs<FF> for StandardPlonk<FF> {
         fn raw_multiply<F>(
             &self,
             layouter: &mut impl Layouter<FF>,
@@ -347,7 +359,7 @@ fn plonk_api() {
                 let sc = meta.query_fixed(sc, Rotation::cur());
                 let sm = meta.query_fixed(sm, Rotation::cur());
 
-                vec![a.clone() * sa + b.clone() * sb + a * b * sm - (c * sc) + sf * (d * e)]
+                vec![a * sa + b * sb + a * b * sm - (c * sc) + sf * (d * e)]
             });
 
             meta.create_gate("Public input", |meta| {
@@ -415,17 +427,6 @@ fn plonk_api() {
         }
     }
 
-    macro_rules! common {
-        ($scheme:ident) => {{
-            let a = <$scheme as CommitmentScheme>::Scalar::from(2834758237)
-                * <$scheme as CommitmentScheme>::Scalar::ZETA;
-            let instance = <$scheme as CommitmentScheme>::Scalar::ONE
-                + <$scheme as CommitmentScheme>::Scalar::ONE;
-            let lookup_table = vec![instance, a, a, <$scheme as CommitmentScheme>::Scalar::ZERO];
-            (a, instance, lookup_table)
-        }};
-    }
-
     macro_rules! bad_keys {
         ($scheme:ident) => {{
             let (_, _, lookup_table) = common!($scheme);
@@ -433,7 +434,6 @@ fn plonk_api() {
                 a: Value::unknown(),
                 lookup_table: lookup_table.clone(),
             };
-
             // Check that we get an error if we try to initialize the proving key with a value of
             // k that is too small for the minimum required number of rows.
             let much_too_small_params= <$scheme as CommitmentScheme>::ParamsProver::new(1);
@@ -456,12 +456,16 @@ fn plonk_api() {
         }};
     }
 
-    fn keygen<Scheme: CommitmentScheme>(params: &Scheme::ParamsProver) -> ProvingKey<Scheme::Curve>
+    fn keygen<Scheme: CommitmentScheme, F: FieldFront<Field = Scheme::Scalar>>(
+        params: &Scheme::ParamsProver,
+    ) -> ProvingKey<Scheme::Curve>
     where
         Scheme::Scalar: FromUniformBytes<64> + WithSmallOrderMulGroup<3>,
     {
         let (_, _, lookup_table) = common!(Scheme);
-        let empty_circuit: MyCircuit<Scheme::Scalar> = MyCircuit {
+        let lookup_table: Vec<_> = lookup_table.into_iter().map(F::into_fieldfront).collect();
+
+        let empty_circuit: MyCircuit<F> = MyCircuit {
             a: Value::unknown(),
             lookup_table,
         };
@@ -480,6 +484,7 @@ fn plonk_api() {
         R: RngCore,
         T: TranscriptWriterBuffer<Vec<u8>, Scheme::Curve, E>,
         M: MsmAccel<Scheme::Curve>,
+        F: FieldFront<Field = Scheme::Scalar> + FromUniformBytes<64> + Ord,
     >(
         engine: PlonkEngine<Scheme::Curve, M>,
         rng: R,
@@ -490,8 +495,10 @@ fn plonk_api() {
         Scheme::Scalar: Ord + WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
     {
         let (a, instance_val, lookup_table) = common!(Scheme);
-
-        let circuit: MyCircuit<Scheme::Scalar> = MyCircuit {
+        let a = F::into_fieldfront(a);
+        let instance_val = F::into_fieldfront(instance_val);
+        let lookup_table: Vec<_> = lookup_table.into_iter().map(F::into_fieldfront).collect();
+        let circuit: MyCircuit<F> = MyCircuit {
             a: Value::known(a),
             lookup_table,
         };
@@ -499,7 +506,7 @@ fn plonk_api() {
         let mut transcript = T::init(vec![]);
 
         let instance = [vec![vec![instance_val]], vec![vec![instance_val]]];
-        create_plonk_proof_with_engine::<Scheme, P, _, _, _, _, _>(
+        create_plonk_proof_with_engine::<Scheme, P, _, _, _, _, _, F>(
             engine,
             params,
             pk,
@@ -527,6 +534,7 @@ fn plonk_api() {
         E: EncodedChallenge<Scheme::Curve>,
         R: RngCore,
         T: TranscriptWriterBuffer<Vec<u8>, Scheme::Curve, E>,
+        F: FieldFront<Field = Scheme::Scalar> + FromUniformBytes<64> + Ord,
     >(
         rng: R,
         params: &'params Scheme::ParamsProver,
@@ -536,7 +544,7 @@ fn plonk_api() {
         Scheme::Scalar: Ord + WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
     {
         let engine = PlonkEngineConfig::build_default();
-        create_proof_with_engine::<Scheme, P, _, _, T, _>(engine, rng, params, pk)
+        create_proof_with_engine::<Scheme, P, _, _, T, _, F>(engine, rng, params, pk)
     }
 
     fn verify_proof<
@@ -547,6 +555,7 @@ fn plonk_api() {
         E: EncodedChallenge<Scheme::Curve>,
         T: TranscriptReadBuffer<&'a [u8], Scheme::Curve, E>,
         Strategy: VerificationStrategy<'params, Scheme, V, Output = Strategy>,
+        F: FieldFront<Field = Scheme::Scalar> + FromUniformBytes<64> + Ord,
     >(
         params_verifier: &'params Scheme::ParamsVerifier,
         vk: &VerifyingKey<Scheme::Curve>,
@@ -555,6 +564,7 @@ fn plonk_api() {
         Scheme::Scalar: Ord + WithSmallOrderMulGroup<3> + FromUniformBytes<64>,
     {
         let (_, instance_val, _) = common!(Scheme);
+        let instance_val = F::into_fieldfront(instance_val);
 
         let mut transcript = T::init(proof);
         let instance = [vec![vec![instance_val]], vec![vec![instance_val]]];
@@ -573,16 +583,22 @@ fn plonk_api() {
         use halo2curves::bn256::Bn256;
 
         type Scheme = KZGCommitmentScheme<Bn256>;
+
         bad_keys!(Scheme);
 
         let params = ParamsKZG::<Bn256>::new(K);
         let rng = OsRng;
 
-        let pk = keygen::<KZGCommitmentScheme<_>>(&params);
+        let pk = keygen::<KZGCommitmentScheme<_>, <Scheme as CommitmentScheme>::Scalar>(&params);
 
-        let proof = create_proof::<_, ProverGWC<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>(
-            rng, &params, &pk,
-        );
+        let proof = create_proof::<
+            _,
+            ProverGWC<_>,
+            _,
+            _,
+            Blake2bWrite<_, _, Challenge255<_>>,
+            <Scheme as CommitmentScheme>::Scalar,
+        >(rng, &params, &pk);
 
         let verifier_params = params.verifier_params();
 
@@ -592,6 +608,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
+            <Scheme as CommitmentScheme>::Scalar,
         >(&verifier_params, pk.get_vk(), &proof[..]);
     }
 
@@ -607,11 +624,16 @@ fn plonk_api() {
         let params = ParamsKZG::<Bn256>::new(K);
         let rng = OsRng;
 
-        let pk = keygen::<KZGCommitmentScheme<_>>(&params);
+        let pk = keygen::<KZGCommitmentScheme<_>, <Scheme as CommitmentScheme>::Scalar>(&params);
 
-        let proof = create_proof::<_, ProverSHPLONK<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>(
-            rng, &params, &pk,
-        );
+        let proof = create_proof::<
+            _,
+            ProverSHPLONK<_>,
+            _,
+            _,
+            Blake2bWrite<_, _, Challenge255<_>>,
+            <Scheme as CommitmentScheme>::Scalar,
+        >(rng, &params, &pk);
 
         let verifier_params = params.verifier_params();
 
@@ -621,6 +643,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
+            <Scheme as CommitmentScheme>::Scalar,
         >(&verifier_params, pk.get_vk(), &proof[..]);
     }
 
@@ -636,11 +659,17 @@ fn plonk_api() {
         let params = ParamsIPA::<EqAffine>::new(K);
         let rng = OsRng;
 
-        let pk = keygen::<IPACommitmentScheme<EqAffine>>(&params);
+        let pk =
+            keygen::<IPACommitmentScheme<EqAffine>, <Scheme as CommitmentScheme>::Scalar>(&params);
 
-        let proof = create_proof::<_, ProverIPA<_>, _, _, Blake2bWrite<_, _, Challenge255<_>>>(
-            rng, &params, &pk,
-        );
+        let proof = create_proof::<
+            _,
+            ProverIPA<_>,
+            _,
+            _,
+            Blake2bWrite<_, _, Challenge255<_>>,
+            <Scheme as CommitmentScheme>::Scalar,
+        >(rng, &params, &pk);
 
         let verifier_params = params;
 
@@ -650,6 +679,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
+            <Scheme as CommitmentScheme>::Scalar,
         >(&verifier_params, pk.get_vk(), &proof[..]);
 
         // Check that the verification key has not changed unexpectedly
diff --git a/halo2_proofs/tests/serialization.rsx b/halo2_proofs/tests/serialization.rs
similarity index 93%
rename from halo2_proofs/tests/serialization.rsx
rename to halo2_proofs/tests/serialization.rs
index 93dfca7df..4c1c36379 100644
--- a/halo2_proofs/tests/serialization.rsx
+++ b/halo2_proofs/tests/serialization.rs
@@ -23,7 +23,7 @@ use halo2_proofs::{
     },
     SerdeFormat,
 };
-use halo2curves::bn256::{Bn256, Fr, G1Affine};
+use halo2curves::bn256::{self, Bn256, Fr, G1Affine};
 use rand_core::OsRng;
 
 #[derive(Clone, Copy)]
@@ -55,14 +55,7 @@ impl StandardPlonkConfig {
                 let [q_a, q_b, q_c, q_ab, constant] = [q_a, q_b, q_c, q_ab, constant]
                     .map(|column| meta.query_fixed(column, Rotation::cur()));
                 let instance = meta.query_instance(instance, Rotation::cur());
-                Some(
-                    q_a * a.clone()
-                        + q_b * b.clone()
-                        + q_c * c
-                        + q_ab * a * b
-                        + constant
-                        + instance,
-                )
+                Some(q_a * a + q_b * b + q_c * c + q_ab * a * b + constant + instance)
             },
         );
 
@@ -145,7 +138,7 @@ fn test_serialization() {
     let f = File::open("serialization-test.pk").unwrap();
     let mut reader = BufReader::new(f);
     #[allow(clippy::unit_arg)]
-    let pk = pk_read::<G1Affine, _, StandardPlonk>(
+    let pk = pk_read::<G1Affine, _, _, StandardPlonk>(
         &mut reader,
         SerdeFormat::RawBytes,
         k,
@@ -165,6 +158,7 @@ fn test_serialization() {
         _,
         Blake2bWrite<Vec<u8>, G1Affine, Challenge255<_>>,
         _,
+        bn256::Fr,
     >(
         &params,
         &pk,
@@ -185,6 +179,7 @@ fn test_serialization() {
         Challenge255<G1Affine>,
         Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
         SingleStrategy<Bn256>,
+        _,
     >(
         &verifier_params,
         pk.get_vk(),
diff --git a/halo2_proofs/tests/shuffle.rsx b/halo2_proofs/tests/shuffle.rsx
index 7c35061d3..958a42648 100644
--- a/halo2_proofs/tests/shuffle.rsx
+++ b/halo2_proofs/tests/shuffle.rsx
@@ -1,7 +1,7 @@
 use ff::{BatchInvert, FromUniformBytes};
 use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
-    arithmetic::{CurveAffine, Field},
+    arithmetic::CurveAffine,
     circuit::{floor_planner::V1, Layouter, Value},
     dev::{metadata, FailureLocation, MockProver, VerifyFailure},
     halo2curves::pasta::EqAffine,
@@ -243,7 +243,7 @@ impl<F: FieldFront, const W: usize, const H: usize> Circuit<F> for MyCircuit<F,
     }
 }
 
-fn test_mock_prover<F: Ord + FromUniformBytes<64>, const W: usize, const H: usize>(
+fn test_mock_prover<F: FieldFront + Ord + FromUniformBytes<64>, const W: usize, const H: usize>(
     k: u32,
     circuit: MyCircuit<F, W, H>,
     expected: Result<(), Vec<(metadata::Constraint, FailureLocation)>>,
@@ -270,9 +270,9 @@ fn test_mock_prover<F: Ord + FromUniformBytes<64>, const W: usize, const H: usiz
     };
 }
 
-fn test_prover<C: CurveAffine, const W: usize, const H: usize>(
+fn test_prover<C: CurveAffine, F: FieldFront<Field=C::Scalar>, const W: usize, const H: usize>(
     k: u32,
-    circuit: MyCircuit<C::Scalar, W, H>,
+    circuit: MyCircuit<F, W, H>,
     expected: bool,
 ) where
     C::Scalar: FromUniformBytes<64>,
@@ -284,7 +284,7 @@ fn test_prover<C: CurveAffine, const W: usize, const H: usize>(
     let proof = {
         let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
 
-        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _>(
+        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _, F>(
             &params,
             &pk,
             &[circuit],
@@ -301,7 +301,7 @@ fn test_prover<C: CurveAffine, const W: usize, const H: usize>(
         let strategy = AccumulatorStrategy::new(&params);
         let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
 
-        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _>(
+        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _, F>(
             &params,
             pk.get_vk(),
             strategy,
@@ -325,7 +325,7 @@ fn test_shuffle() {
 
     {
         test_mock_prover(K, circuit.clone(), Ok(()));
-        test_prover::<EqAffine, W, H>(K, circuit.clone(), true);
+        test_prover::<EqAffine,halo2curves::pasta::Fp, W, H>(K, circuit.clone(), true);
     }
 
     #[cfg(not(feature = "sanity-checks"))]
@@ -349,6 +349,6 @@ fn test_shuffle() {
                 },
             )]),
         );
-        test_prover::<EqAffine, W, H>(K, circuit, false);
+        test_prover::<EqAffine,halo2curves::pasta::Fp, W, H>(K, circuit, false);
     }
 }
diff --git a/halo2_proofs/tests/shuffle_api.rsx b/halo2_proofs/tests/shuffle_api.rs
similarity index 94%
rename from halo2_proofs/tests/shuffle_api.rsx
rename to halo2_proofs/tests/shuffle_api.rs
index e3368fa5b..595705737 100644
--- a/halo2_proofs/tests/shuffle_api.rsx
+++ b/halo2_proofs/tests/shuffle_api.rs
@@ -2,13 +2,11 @@ use std::{marker::PhantomData, vec};
 
 use ff::FromUniformBytes;
 use halo2_proofs::{
-    arithmetic::Field,
     circuit::{Layouter, SimpleFloorPlanner, Value},
     plonk::{
         create_proof, keygen_pk, keygen_vk, verify_proof, Advice, Circuit, Column,
-        ConstraintSystem, ErrorFront, Fixed, Selector,
+        ConstraintSystem, ErrorFront, FieldFront, Fixed, Selector,
     },
-    poly::Rotation,
     poly::{
         commitment::ParamsProver,
         ipa::{
@@ -16,7 +14,7 @@ use halo2_proofs::{
             multiopen::{ProverIPA, VerifierIPA},
             strategy::AccumulatorStrategy,
         },
-        VerificationStrategy,
+        Rotation, VerificationStrategy,
     },
     transcript::{
         Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer,
@@ -65,7 +63,7 @@ impl<F: FieldFront> ShuffleChip<F> {
             let shuffle_0 = meta.query_advice(shuffle_0, Rotation::cur());
             let shuffle_1 = meta.query_advice(shuffle_1, Rotation::cur());
             vec![
-                (s_input.clone() * input_0, s_shuffle.clone() * shuffle_0),
+                (s_input * input_0, s_shuffle * shuffle_0),
                 (s_input * input_1, s_shuffle * shuffle_1),
             ]
         });
@@ -148,8 +146,11 @@ impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     }
 }
 
-fn test_prover<C: CurveAffine>(k: u32, circuit: MyCircuit<C::Scalar>, expected: bool)
-where
+fn test_prover<C: CurveAffine, F: FieldFront<Field = C::Scalar>>(
+    k: u32,
+    circuit: MyCircuit<F>,
+    expected: bool,
+) where
     C::Scalar: FromUniformBytes<64>,
 {
     let params = ParamsIPA::<C>::new(k);
@@ -159,7 +160,7 @@ where
     let proof = {
         let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
 
-        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _>(
+        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _, F>(
             &params,
             &pk,
             &[circuit],
@@ -176,7 +177,7 @@ where
         let strategy = AccumulatorStrategy::new(&params);
         let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
 
-        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _>(
+        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _, F>(
             &params,
             pk.get_vk(),
             strategy,
@@ -213,5 +214,5 @@ fn test_shuffle_api() {
     };
     let prover = MockProver::run(K, &circuit, vec![]).unwrap();
     prover.assert_satisfied();
-    test_prover::<EqAffine>(K, circuit, true);
+    test_prover::<EqAffine, halo2curves::pasta::Fp>(K, circuit, true);
 }
diff --git a/halo2_proofs/tests/vector-ops-unblinded.rsx b/halo2_proofs/tests/vector-ops-unblinded.rs
similarity index 97%
rename from halo2_proofs/tests/vector-ops-unblinded.rsx
rename to halo2_proofs/tests/vector-ops-unblinded.rs
index b33689b07..81fe7f8b9 100644
--- a/halo2_proofs/tests/vector-ops-unblinded.rsx
+++ b/halo2_proofs/tests/vector-ops-unblinded.rs
@@ -6,7 +6,7 @@ use std::marker::PhantomData;
 use ff::FromUniformBytes;
 use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
-    arithmetic::{CurveAffine, Field},
+    arithmetic::CurveAffine,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
     plonk::*,
     poly::{
@@ -467,11 +467,11 @@ impl<F: FieldFront> Circuit<F> for AddCircuit<F> {
 }
 // ANCHOR_END: circuit
 
-fn test_prover<C: CurveAffine, FE: FieldFront<Field=C::Scalar>>(
+fn test_prover<C: CurveAffine, F: FieldFront<Field = C::Scalar>>(
     k: u32,
-    circuit: impl Circuit<FE>,
+    circuit: impl Circuit<F>,
     expected: bool,
-    instances: Vec<C::Scalar>,
+    instances: Vec<F>,
 ) -> Vec<u8>
 where
     C::Scalar: FromUniformBytes<64>,
@@ -484,7 +484,7 @@ where
     let proof = {
         let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
 
-        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _, C::ScalarExt>(
+        create_proof::<IPACommitmentScheme<C>, ProverIPA<C>, _, _, _, _, F>(
             &params,
             &pk,
             &[circuit],
@@ -501,7 +501,7 @@ where
         let strategy = AccumulatorStrategy::new(&params);
         let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
 
-        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _>(
+        verify_proof::<IPACommitmentScheme<C>, VerifierIPA<C>, _, _, _, F>(
             &params,
             pk.get_vk(),
             strategy,
@@ -546,9 +546,9 @@ fn test_vector_ops_unbinded() {
     };
 
     // the commitments will be the first columns of the proof transcript so we can compare them easily
-    let proof_1 = test_prover::<halo2curves::pasta::EqAffine>(k, mul_circuit, true, c_mul);
+    let proof_1 = test_prover::<halo2curves::pasta::EqAffine, _>(k, mul_circuit, true, c_mul);
     // the commitments will be the first columns of the proof transcript so we can compare them easily
-    let proof_2 = test_prover::<halo2curves::pasta::EqAffine>(k, add_circuit, true, c_add);
+    let proof_2 = test_prover::<halo2curves::pasta::EqAffine, _>(k, add_circuit, true, c_add);
 
     // the commitments will be the first columns of the proof transcript so we can compare them easily
     // here we compare the first 10 bytes of the commitments