From e657c446cf96deab508c5d86ba83b42e2af02477 Mon Sep 17 00:00:00 2001
From: iakovenkos <sergey.s.yakovenko@gmail.com>
Date: Fri, 4 Jul 2025 16:56:45 +0000
Subject: [PATCH] remove templates from ECCVM, Translator, and from rec
 Protogalaxy tests

---
 .../cpp/src/barretenberg/flavor/flavor.hpp    |  4 +-
 .../barretenberg/flavor/flavor_concepts.hpp   | 11 ++-
 .../eccvm_verifier/ecc_bools_relation.cpp     |  4 +-
 .../eccvm_verifier/ecc_lookup_relation.cpp    |  4 +-
 .../eccvm_verifier/ecc_msm_relation.cpp       |  4 +-
 .../ecc_point_table_relation.cpp              |  4 +-
 .../ecc_relation_consistency.test.cpp         |  8 +--
 .../eccvm_verifier/ecc_set_relation.cpp       |  8 +--
 .../ecc_transcript_relation.cpp               |  4 +-
 .../eccvm_verifier/ecc_wnaf_relation.cpp      |  4 +-
 .../eccvm_verifier/eccvm_recursive_flavor.hpp |  7 +-
 .../eccvm_recursive_verifier.cpp              | 28 +++-----
 .../eccvm_recursive_verifier.hpp              | 31 ++++----
 .../eccvm_recursive_verifier.test.cpp         | 72 +++++++++----------
 .../goblin_recursive_verifier.hpp             |  9 +--
 .../circuit_builders/circuit_builders_fwd.hpp |  4 +-
 .../protogalaxy_recursive_verifier.test.cpp   | 50 ++++++-------
 ...translator_decomposition_relation_mega.cpp | 16 -----
 ...ranslator_decomposition_relation_ultra.cpp |  3 +-
 ...slator_delta_range_constraint_relation.cpp |  7 +-
 .../translator_extra_relations.cpp            | 20 ++----
 .../translator_non_native_field_relation.cpp  |  8 +--
 .../translator_permutation_relation.cpp       |  8 +--
 .../translator_recursive_flavor.hpp           |  6 +-
 .../translator_recursive_verifier.cpp         | 39 +++++-----
 .../translator_recursive_verifier.hpp         | 31 ++++----
 .../translator_recursive_verifier.test.cpp    | 41 +++++------
 27 files changed, 173 insertions(+), 262 deletions(-)
 delete mode 100644 barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_mega.cpp

diff --git a/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
index 7aaf67a26d32..5913c74d88a2 100644
--- a/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
@@ -448,14 +448,14 @@ class UltraKeccakZKFlavor;
 class MegaFlavor;
 class MegaZKFlavor;
 class TranslatorFlavor;
+class ECCVMRecursiveFlavor;
+class TranslatorRecursiveFlavor;
 
 template <typename BuilderType> class UltraRecursiveFlavor_;
 template <typename BuilderType> class UltraZKRecursiveFlavor_;
 template <typename BuilderType> class UltraRollupRecursiveFlavor_;
 template <typename BuilderType> class MegaRecursiveFlavor_;
 template <typename BuilderType> class MegaZKRecursiveFlavor_;
-template <typename BuilderType> class TranslatorRecursiveFlavor_;
-template <typename BuilderType> class ECCVMRecursiveFlavor_;
 template <typename BuilderType> class AvmRecursiveFlavor_;
 namespace avm2 {
 
diff --git a/barretenberg/cpp/src/barretenberg/flavor/flavor_concepts.hpp b/barretenberg/cpp/src/barretenberg/flavor/flavor_concepts.hpp
index 1c16d6e2eba2..456e404e0d5f 100644
--- a/barretenberg/cpp/src/barretenberg/flavor/flavor_concepts.hpp
+++ b/barretenberg/cpp/src/barretenberg/flavor/flavor_concepts.hpp
@@ -37,7 +37,7 @@ concept HasDataBus = IsMegaFlavor<T>;
 // hence requiring an adjustment to the round univariates via the RowDisablingPolynomial.
 // This is not the case for Translator, where randomness resides in different parts of the trace and the locations will
 // be reflected via Translator relations.
-template <typename T> concept UseRowDisablingPolynomial = !IsAnyOf<T,TranslatorFlavor, TranslatorRecursiveFlavor_<UltraCircuitBuilder>, TranslatorRecursiveFlavor_<MegaCircuitBuilder>>;
+template <typename T> concept UseRowDisablingPolynomial = !IsAnyOf<T,TranslatorFlavor, TranslatorRecursiveFlavor>;
 
 template <typename T>
 concept HasIPAAccumulator = IsAnyOf<T, UltraRollupFlavor, UltraRollupRecursiveFlavor_<UltraCircuitBuilder>>;
@@ -52,17 +52,16 @@ concept IsRecursiveFlavor = IsAnyOf<T, UltraRecursiveFlavor_<UltraCircuitBuilder
                                        MegaRecursiveFlavor_<MegaCircuitBuilder>,
                                        MegaZKRecursiveFlavor_<MegaCircuitBuilder>,
                                        MegaZKRecursiveFlavor_<UltraCircuitBuilder>,
-                                       TranslatorRecursiveFlavor_<UltraCircuitBuilder>,
-                                       TranslatorRecursiveFlavor_<MegaCircuitBuilder>,
-                                       ECCVMRecursiveFlavor_<UltraCircuitBuilder>,
+                                       TranslatorRecursiveFlavor,
+                                       ECCVMRecursiveFlavor,
                                        AvmRecursiveFlavor_<UltraCircuitBuilder>,
                                        AvmRecursiveFlavor_<MegaCircuitBuilder>,
                                        avm2::AvmRecursiveFlavor_<UltraCircuitBuilder>,
                                        avm2::AvmRecursiveFlavor_<MegaCircuitBuilder>>;
 
 // These concepts are relevant for Sumcheck, where the logic is different for BN254 and Grumpkin Flavors
-template <typename T> concept IsGrumpkinFlavor = IsAnyOf<T, ECCVMFlavor, ECCVMRecursiveFlavor_<UltraCircuitBuilder>>;
-template <typename T> concept IsECCVMRecursiveFlavor = IsAnyOf<T, ECCVMRecursiveFlavor_<UltraCircuitBuilder>>;
+template <typename T> concept IsGrumpkinFlavor = IsAnyOf<T, ECCVMFlavor, ECCVMRecursiveFlavor>;
+template <typename T> concept IsECCVMRecursiveFlavor = IsAnyOf<T, ECCVMRecursiveFlavor>;
 
 #ifdef STARKNET_GARAGA_FLAVORS
 template <typename T> concept IsFoldingFlavor = IsAnyOf<T, UltraFlavor,
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_bools_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_bools_relation.cpp
index e68c8dd4e3da..10a7db0cec7c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_bools_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_bools_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMBoolsRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMBoolsRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMBoolsRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMBoolsRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMBoolsRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_lookup_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_lookup_relation.cpp
index 410334e7f6ba..03393798f147 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_lookup_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_lookup_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMLookupRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMLookupRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMLookupRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMLookupRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMLookupRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_msm_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_msm_relation.cpp
index 6d2ad2b44fc4..69aba707b3a6 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_msm_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_msm_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMMSMRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMMSMRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMMSMRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMMSMRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMMSMRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_point_table_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_point_table_relation.cpp
index ac1b9b3423d1..b5dff8ae3db3 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_point_table_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_point_table_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMPointTableRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMPointTableRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMPointTableRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMPointTableRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMPointTableRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_relation_consistency.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_relation_consistency.test.cpp
index 6fb8c20f1039..912942f224c7 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_relation_consistency.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_relation_consistency.test.cpp
@@ -18,9 +18,9 @@ class EccRelationsConsistency : public testing::Test {
     template <template <typename> class Relation> static void validate_relation_execution()
     {
         auto builder = UltraCircuitBuilder();
-        using RecursiveFlavor = ECCVMRecursiveFlavor_<UltraCircuitBuilder>;
-        using RecursiveRelation = Relation<typename RecursiveFlavor::FF>;
-        const RelationParameters<typename RecursiveFlavor::FF> parameters;
+        using RecursiveFlavor = ECCVMRecursiveFlavor;
+        using RecursiveRelation = Relation<RecursiveFlavor::FF>;
+        const RelationParameters<RecursiveFlavor::FF> parameters;
         RecursiveFlavor::AllValues input_elements;
         for (auto& element : input_elements.get_all()) {
             element = 4;
@@ -57,4 +57,4 @@ TEST_F(EccRelationsConsistency, RecursiveToNativeConsistency)
     validate_relation_execution<ECCVMWnafRelation>();
     validate_relation_execution<ECCVMBoolsRelation>();
 }
-} // namespace bb
\ No newline at end of file
+} // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_set_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_set_relation.cpp
index a3e74ba87459..bb0e3932b3f4 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_set_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_set_relation.cpp
@@ -11,10 +11,6 @@
 
 namespace bb {
 template class ECCVMSetRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMSetRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_PERMUTATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_PERMUTATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
-
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor);
+DEFINE_SUMCHECK_VERIFIER_PERMUTATION_CLASS(ECCVMSetRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_transcript_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_transcript_relation.cpp
index ac3551010596..a7978d38fba2 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_transcript_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_transcript_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMTranscriptRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMTranscriptRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMTranscriptRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMTranscriptRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMTranscriptRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_wnaf_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_wnaf_relation.cpp
index 53c0f1067e6a..f31cf5926f03 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_wnaf_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/ecc_wnaf_relation.cpp
@@ -11,7 +11,5 @@
 
 namespace bb {
 template class ECCVMWnafRelationImpl<stdlib::bigfield<UltraCircuitBuilder, bb::Bn254FqParams>>;
-template class ECCVMWnafRelationImpl<stdlib::bigfield<MegaCircuitBuilder, bb::Bn254FqParams>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMWnafRelationImpl, ECCVMRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMWnafRelationImpl, ECCVMRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(ECCVMWnafRelationImpl, ECCVMRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_flavor.hpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_flavor.hpp
index d227261a71db..db653b774a02 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_flavor.hpp
@@ -26,9 +26,9 @@
 
 namespace bb {
 
-template <typename BuilderType> class ECCVMRecursiveFlavor_ {
+class ECCVMRecursiveFlavor {
   public:
-    using CircuitBuilder = BuilderType; // determines the arithmetisation of recursive verifier
+    using CircuitBuilder = UltraCircuitBuilder; // determines the arithmetisation of recursive verifier
     using Curve = stdlib::grumpkin<CircuitBuilder>;
     using Commitment = Curve::AffineElement;
     using GroupElement = Curve::Element;
@@ -95,7 +95,8 @@ template <typename BuilderType> class ECCVMRecursiveFlavor_ {
      * resolve that, and split out separate PrecomputedPolynomials/Commitments data for clarity but also for
      * portability of our circuits.
      */
-    class VerificationKey : public StdlibVerificationKey_<BuilderType, ECCVMFlavor::PrecomputedEntities<Commitment>> {
+    class VerificationKey
+        : public StdlibVerificationKey_<CircuitBuilder, ECCVMFlavor::PrecomputedEntities<Commitment>> {
       public:
         VerifierCommitmentKey pcs_verification_key;
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
index 45a387864e21..9ce432627742 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
@@ -12,12 +12,9 @@
 #include "barretenberg/transcript/transcript.hpp"
 
 namespace bb {
-
-template <typename Flavor>
-ECCVMRecursiveVerifier_<Flavor>::ECCVMRecursiveVerifier_(
-    Builder* builder,
-    const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
-    const std::shared_ptr<Transcript>& transcript)
+ECCVMRecursiveVerifier::ECCVMRecursiveVerifier(Builder* builder,
+                                               const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
+                                               const std::shared_ptr<Transcript>& transcript)
     : key(std::make_shared<VerificationKey>(builder, native_verifier_key))
     , builder(builder)
     , transcript(transcript)
@@ -29,9 +26,8 @@ ECCVMRecursiveVerifier_<Flavor>::ECCVMRecursiveVerifier_(
  * @tparam Flavor
  * @param proof Native ECCVM proof
  */
-template <typename Flavor>
-typename ECCVMRecursiveVerifier_<Flavor>::IpaClaimAndProof ECCVMRecursiveVerifier_<Flavor>::verify_proof(
-    const ECCVMProof& proof)
+
+ECCVMRecursiveVerifier::IpaClaimAndProof ECCVMRecursiveVerifier::verify_proof(const ECCVMProof& proof)
 {
     StdlibProof stdlib_proof(*builder, proof);
     return verify_proof(stdlib_proof);
@@ -43,11 +39,9 @@ typename ECCVMRecursiveVerifier_<Flavor>::IpaClaimAndProof ECCVMRecursiveVerifie
  * @tparam Flavor
  * @param proof Stdlib ECCVM proof
  */
-template <typename Flavor>
-typename ECCVMRecursiveVerifier_<Flavor>::IpaClaimAndProof ECCVMRecursiveVerifier_<Flavor>::verify_proof(
-    const StdlibProof& proof)
+ECCVMRecursiveVerifier::IpaClaimAndProof ECCVMRecursiveVerifier::verify_proof(const StdlibProof& proof)
 {
-    using Curve = typename Flavor::Curve;
+    using Curve = Flavor::Curve;
     using Shplemini = ShpleminiVerifier_<Curve>;
     using Shplonk = ShplonkVerifier_<Curve>;
     using OpeningClaim = OpeningClaim<Curve>;
@@ -160,12 +154,10 @@ typename ECCVMRecursiveVerifier_<Flavor>::IpaClaimAndProof ECCVMRecursiveVerifie
  * @param translation_commitments Commitments to  `op`, `Px`, `Py`, `z1`, and `z2`
  * @return Populate `opening_claims`.
  */
-template <typename Flavor>
-void ECCVMRecursiveVerifier_<Flavor>::compute_translation_opening_claims(
-    const std::vector<Commitment>& translation_commitments)
+void ECCVMRecursiveVerifier::compute_translation_opening_claims(const std::vector<Commitment>& translation_commitments)
 {
     // Used to capture the batched evaluation of unmasked `translation_polynomials` while preserving ZK
-    using SmallIPA = SmallSubgroupIPAVerifier<typename Flavor::Curve>;
+    using SmallIPA = SmallSubgroupIPAVerifier<Flavor::Curve>;
 
     // Initialize SmallSubgroupIPA structures
     SmallSubgroupIPACommitments<Commitment> small_ipa_commitments;
@@ -240,6 +232,4 @@ void ECCVMRecursiveVerifier_<Flavor>::compute_translation_opening_claims(
     // NUM_DISABLED_ROWS_IN_SUMCHECK}
     shift_translation_masking_term_eval(evaluation_challenge_x, translation_masking_term_eval);
 };
-
-template class ECCVMRecursiveVerifier_<ECCVMRecursiveFlavor_<UltraCircuitBuilder>>;
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
index c3582350b40c..aee803a1a486 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
@@ -10,19 +10,20 @@
 #include "barretenberg/stdlib/proof/proof.hpp"
 
 namespace bb {
-template <typename Flavor> class ECCVMRecursiveVerifier_ {
-    using FF = typename Flavor::FF;
-    using BF = typename Flavor::BF;
-    using Curve = typename Flavor::Curve;
-    using Commitment = typename Flavor::Commitment;
-    using CommitmentLabels = typename Flavor::CommitmentLabels;
-    using VerificationKey = typename Flavor::VerificationKey;
-    using NativeVerificationKey = typename Flavor::NativeVerificationKey;
-    using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey;
-    using Builder = typename Flavor::CircuitBuilder;
-    using PCS = typename Flavor::PCS;
+class ECCVMRecursiveVerifier {
+    using Flavor = ECCVMRecursiveFlavor;
+    using FF = Flavor::FF;
+    using BF = Flavor::BF;
+    using Curve = Flavor::Curve;
+    using Commitment = Flavor::Commitment;
+    using CommitmentLabels = Flavor::CommitmentLabels;
+    using VerificationKey = Flavor::VerificationKey;
+    using NativeVerificationKey = Flavor::NativeVerificationKey;
+    using VerifierCommitmentKey = Flavor::VerifierCommitmentKey;
+    using Builder = Flavor::CircuitBuilder;
+    using PCS = Flavor::PCS;
     using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
-    using VerifierCommitments = typename Flavor::VerifierCommitments;
+    using VerifierCommitments = Flavor::VerifierCommitments;
     using StdlibPreIpaProof = bb::stdlib::Proof<Builder>;
     using StdlibIpaProof = bb::stdlib::Proof<Builder>;
     using IpaClaimAndProof = std::pair<OpeningClaim<Curve>, StdlibIpaProof>;
@@ -38,9 +39,9 @@ template <typename Flavor> class ECCVMRecursiveVerifier_ {
         {}
     };
 
-    explicit ECCVMRecursiveVerifier_(Builder* builder,
-                                     const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
-                                     const std::shared_ptr<Transcript>& transcript);
+    explicit ECCVMRecursiveVerifier(Builder* builder,
+                                    const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
+                                    const std::shared_ptr<Transcript>& transcript);
 
     [[nodiscard("IPA claim should be accumulated")]] IpaClaimAndProof verify_proof(const ECCVMProof& proof);
     [[nodiscard("IPA claim should be accumulated")]] IpaClaimAndProof verify_proof(const StdlibProof& proof);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
index f928b32fdaa6..17d31bef4c13 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
@@ -15,10 +15,11 @@ namespace {
 auto& engine = bb::numeric::get_debug_randomness();
 }
 namespace bb {
-template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing::Test {
+class ECCVMRecursiveTests : public ::testing::Test {
   public:
-    using InnerFlavor = typename RecursiveFlavor::NativeFlavor;
-    using InnerBuilder = typename InnerFlavor::CircuitBuilder;
+    using RecursiveFlavor = ECCVMRecursiveFlavor;
+    using InnerFlavor = RecursiveFlavor::NativeFlavor;
+    using InnerBuilder = InnerFlavor::CircuitBuilder;
     using InnerProver = ECCVMProver;
     using InnerVerifier = ECCVMVerifier;
     using InnerG1 = InnerFlavor::Commitment;
@@ -28,10 +29,11 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
     using InnerVK = InnerFlavor::VerificationKey;
 
     using Transcript = InnerFlavor::Transcript;
+    using StdlibTranscript = RecursiveFlavor::Transcript;
 
-    using RecursiveVerifier = ECCVMRecursiveVerifier_<RecursiveFlavor>;
+    using RecursiveVerifier = ECCVMRecursiveVerifier;
 
-    using OuterBuilder = typename RecursiveFlavor::CircuitBuilder;
+    using OuterBuilder = RecursiveFlavor::CircuitBuilder;
     using OuterFlavor = std::conditional_t<IsMegaBuilder<OuterBuilder>, MegaFlavor, UltraFlavor>;
     using OuterProver = UltraProver_<OuterFlavor>;
     using OuterVerifier = UltraVerifier_<OuterFlavor>;
@@ -79,15 +81,14 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
     static void test_recursive_verification()
     {
         InnerBuilder builder = generate_circuit(&engine);
-        std::shared_ptr<ECCVMFlavor::Transcript> prover_transcript = std::make_shared<ECCVMFlavor::Transcript>();
+        std::shared_ptr<Transcript> prover_transcript = std::make_shared<Transcript>();
         InnerProver prover(builder, prover_transcript);
         ECCVMProof proof = prover.construct_proof();
-        auto verification_key = std::make_shared<typename InnerFlavor::VerificationKey>(prover.key);
+        auto verification_key = std::make_shared<InnerFlavor::VerificationKey>(prover.key);
 
         info("ECCVM Recursive Verifier");
         OuterBuilder outer_circuit;
-        std::shared_ptr<typename RecursiveFlavor::Transcript> stdlib_verifier_transcript =
-            std::make_shared<typename RecursiveFlavor::Transcript>();
+        std::shared_ptr<StdlibTranscript> stdlib_verifier_transcript = std::make_shared<StdlibTranscript>();
         RecursiveVerifier verifier{ &outer_circuit, verification_key, stdlib_verifier_transcript };
         verifier.transcript->enable_manifest();
         auto [opening_claim, ipa_transcript] = verifier.verify_proof(proof);
@@ -101,7 +102,7 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
         bool result = CircuitChecker::check(outer_circuit);
         EXPECT_TRUE(result);
 
-        std::shared_ptr<ECCVMFlavor::Transcript> verifier_transcript = std::make_shared<ECCVMFlavor::Transcript>();
+        std::shared_ptr<Transcript> verifier_transcript = std::make_shared<Transcript>();
         InnerVerifier native_verifier(verifier_transcript);
         native_verifier.transcript->enable_manifest();
         bool native_result = native_verifier.verify_proof(proof);
@@ -128,7 +129,7 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
         // Construct a full proof from the recursive verifier circuit
         {
             auto proving_key = std::make_shared<OuterDeciderProvingKey>(outer_circuit);
-            auto verification_key = std::make_shared<typename OuterFlavor::VerificationKey>(proving_key->proving_key);
+            auto verification_key = std::make_shared<OuterFlavor::VerificationKey>(proving_key->proving_key);
             OuterProver prover(proving_key, verification_key);
             OuterVerifier verifier(verification_key);
             auto proof = prover.construct_proof();
@@ -145,12 +146,11 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
         std::shared_ptr<Transcript> prover_transcript = std::make_shared<Transcript>();
         InnerProver prover(builder, prover_transcript);
         ECCVMProof proof = prover.construct_proof();
-        auto verification_key = std::make_shared<typename InnerFlavor::VerificationKey>(prover.key);
+        auto verification_key = std::make_shared<InnerFlavor::VerificationKey>(prover.key);
 
         OuterBuilder outer_circuit;
 
-        std::shared_ptr<typename RecursiveFlavor::Transcript> stdlib_verifier_transcript =
-            std::make_shared<typename RecursiveFlavor::Transcript>();
+        std::shared_ptr<StdlibTranscript> stdlib_verifier_transcript = std::make_shared<StdlibTranscript>();
         RecursiveVerifier verifier{ &outer_circuit, verification_key, stdlib_verifier_transcript };
         [[maybe_unused]] auto output = verifier.verify_proof(proof);
         stdlib::recursion::PairingPoints<OuterBuilder>::add_default_to_public_inputs(outer_circuit);
@@ -171,11 +171,10 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
             // Tamper with the proof to be verified
             tamper_with_proof<InnerProver, InnerFlavor>(proof.pre_ipa_proof, static_cast<bool>(idx));
 
-            auto verification_key = std::make_shared<typename InnerFlavor::VerificationKey>(prover.key);
+            auto verification_key = std::make_shared<InnerFlavor::VerificationKey>(prover.key);
 
             OuterBuilder outer_circuit;
-            std::shared_ptr<typename RecursiveFlavor::Transcript> stdlib_verifier_transcript =
-                std::make_shared<typename RecursiveFlavor::Transcript>();
+            std::shared_ptr<StdlibTranscript> stdlib_verifier_transcript = std::make_shared<StdlibTranscript>();
             RecursiveVerifier verifier{ &outer_circuit, verification_key, stdlib_verifier_transcript };
             auto [opening_claim, ipa_proof] = verifier.verify_proof(proof);
             stdlib::recursion::PairingPoints<OuterBuilder>::add_default_to_public_inputs(outer_circuit);
@@ -189,16 +188,15 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
                 EXPECT_TRUE(CircuitChecker::check(outer_circuit));
 
                 // However, IPA recursive verifier must fail, as one of the commitments is incorrect.
-                VerifierCommitmentKey<typename InnerFlavor::Curve> native_pcs_vk(1UL << CONST_ECCVM_LOG_N);
+                VerifierCommitmentKey<InnerFlavor::Curve> native_pcs_vk(1UL << CONST_ECCVM_LOG_N);
                 VerifierCommitmentKey<stdlib::grumpkin<OuterBuilder>> stdlib_pcs_vkey(
                     &outer_circuit, 1UL << CONST_ECCVM_LOG_N, native_pcs_vk);
 
                 // Construct ipa_transcript from proof
-                std::shared_ptr<typename RecursiveFlavor::Transcript> ipa_transcript =
-                    std::make_shared<typename RecursiveFlavor::Transcript>();
+                std::shared_ptr<StdlibTranscript> ipa_transcript = std::make_shared<StdlibTranscript>();
                 ipa_transcript->load_proof(ipa_proof);
-                EXPECT_FALSE(IPA<typename RecursiveFlavor::Curve>::full_verify_recursive(
-                    stdlib_pcs_vkey, opening_claim, ipa_transcript));
+                EXPECT_FALSE(
+                    IPA<RecursiveFlavor::Curve>::full_verify_recursive(stdlib_pcs_vkey, opening_claim, ipa_transcript));
             }
         }
     }
@@ -207,20 +205,19 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
     {
 
         // Retrieves the trace blocks (each consisting of a specific gate) from the recursive verifier circuit
-        auto get_blocks = [](size_t inner_size) -> std::tuple<typename OuterBuilder::ExecutionTrace,
-                                                              std::shared_ptr<typename OuterFlavor::VerificationKey>> {
+        auto get_blocks = [](size_t inner_size)
+            -> std::tuple<OuterBuilder::ExecutionTrace, std::shared_ptr<OuterFlavor::VerificationKey>> {
             auto inner_circuit = generate_circuit(&engine, inner_size);
             std::shared_ptr<Transcript> prover_transcript = std::make_shared<Transcript>();
             InnerProver inner_prover(inner_circuit, prover_transcript);
 
             ECCVMProof inner_proof = inner_prover.construct_proof();
-            auto verification_key = std::make_shared<typename InnerFlavor::VerificationKey>(inner_prover.key);
+            auto verification_key = std::make_shared<InnerFlavor::VerificationKey>(inner_prover.key);
 
             // Create a recursive verification circuit for the proof of the inner circuit
             OuterBuilder outer_circuit;
 
-            std::shared_ptr<typename RecursiveFlavor::Transcript> stdlib_verifier_transcript =
-                std::make_shared<typename RecursiveFlavor::Transcript>();
+            std::shared_ptr<StdlibTranscript> stdlib_verifier_transcript = std::make_shared<StdlibTranscript>();
             RecursiveVerifier verifier{ &outer_circuit, verification_key, stdlib_verifier_transcript };
 
             auto [opening_claim, ipa_transcript] = verifier.verify_proof(inner_proof);
@@ -228,7 +225,7 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
 
             auto outer_proving_key = std::make_shared<OuterDeciderProvingKey>(outer_circuit);
             auto outer_verification_key =
-                std::make_shared<typename OuterFlavor::VerificationKey>(outer_proving_key->proving_key);
+                std::make_shared<OuterFlavor::VerificationKey>(outer_proving_key->proving_key);
 
             return { outer_circuit.blocks, outer_verification_key };
         };
@@ -240,27 +237,24 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
                                                                 { verification_key_20, verification_key_40 });
     };
 };
-using FlavorTypes = testing::Types<ECCVMRecursiveFlavor_<UltraCircuitBuilder>>;
-
-TYPED_TEST_SUITE(ECCVMRecursiveTests, FlavorTypes);
 
-TYPED_TEST(ECCVMRecursiveTests, SingleRecursiveVerification)
+TEST_F(ECCVMRecursiveTests, SingleRecursiveVerification)
 {
-    TestFixture::test_recursive_verification();
+    ECCVMRecursiveTests::test_recursive_verification();
 };
 
-TYPED_TEST(ECCVMRecursiveTests, SingleRecursiveVerificationFailure)
+TEST_F(ECCVMRecursiveTests, SingleRecursiveVerificationFailure)
 {
-    TestFixture::test_recursive_verification_failure();
+    ECCVMRecursiveTests::test_recursive_verification_failure();
 };
 
-TYPED_TEST(ECCVMRecursiveTests, SingleRecursiveVerificationFailureTamperedProof)
+TEST_F(ECCVMRecursiveTests, SingleRecursiveVerificationFailureTamperedProof)
 {
-    TestFixture::test_recursive_verification_failure_tampered_proof();
+    ECCVMRecursiveTests::test_recursive_verification_failure_tampered_proof();
 };
 
-TYPED_TEST(ECCVMRecursiveTests, IndependentVKHash)
+TEST_F(ECCVMRecursiveTests, IndependentVKHash)
 {
-    TestFixture::test_independent_vk_hash();
+    ECCVMRecursiveTests::test_independent_vk_hash();
 };
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
index 5e8a836ff3ec..46e27c2cb57e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
@@ -14,7 +14,6 @@ namespace bb::stdlib::recursion::honk {
 
 struct GoblinRecursiveVerifierOutput {
     using Builder = UltraCircuitBuilder;
-    using ECCVMFlavor = ECCVMRecursiveFlavor_<Builder>;
     using Curve = grumpkin<Builder>;
     using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
     using PairingAccumulator = PairingPoints<Builder>;
@@ -30,13 +29,11 @@ class GoblinRecursiveVerifier {
     using MergeVerifier = goblin::MergeRecursiveVerifier_<Builder>;
     using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
 
-    using TranslatorFlavor = TranslatorRecursiveFlavor_<Builder>;
-    using TranslatorVerifier = TranslatorRecursiveVerifier_<TranslatorFlavor>;
+    using TranslatorFlavor = TranslatorRecursiveFlavor;
+    using TranslatorVerifier = TranslatorRecursiveVerifier;
     using TranslationEvaluations = TranslatorVerifier::TranslationEvaluations;
-    using TranslatorBF = TranslatorFlavor::BF;
 
-    using ECCVMFlavor = ECCVMRecursiveFlavor_<Builder>;
-    using ECCVMVerifier = ECCVMRecursiveVerifier_<ECCVMFlavor>;
+    using ECCVMVerifier = ECCVMRecursiveVerifier;
 
     // ECCVM and Translator verification keys
     using VerificationKey = Goblin::VerificationKey;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
index 147eb20040d0..e510d8133402 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
@@ -35,6 +35,8 @@ class UltraKeccakZKFlavor;
 class UltraRollupFlavor;
 class ECCVMFlavor;
 class TranslatorFlavor;
+class TranslatorRecursiveFlavor;
+class ECCVMRecursiveFlavor;
 
 template <typename BuilderType> class UltraRecursiveFlavor_;
 template <typename BuilderType> class UltraZKRecursiveFlavor_;
@@ -42,8 +44,6 @@ template <typename BuilderType> class UltraKeccakRecursiveFlavor_;
 template <typename BuilderType> class UltraRollupRecursiveFlavor_;
 template <typename BuilderType> class MegaRecursiveFlavor_;
 template <typename BuilderType> class MegaZKRecursiveFlavor_;
-template <typename BuilderType> class ECCVMRecursiveFlavor_;
-template <typename BuilderType> class TranslatorRecursiveFlavor_;
 template <typename BuilderType> class AvmRecursiveFlavor_;
 namespace avm2 {
 template <typename BuilderType> class AvmRecursiveFlavor_;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
index ce2448c8966e..b90243afa267 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
@@ -1,14 +1,12 @@
 #include "barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.hpp"
 #include "barretenberg/circuit_checker/circuit_checker.hpp"
 #include "barretenberg/common/test.hpp"
-#include "barretenberg/flavor/ultra_recursive_flavor.hpp"
 #include "barretenberg/protogalaxy/protogalaxy_prover.hpp"
 #include "barretenberg/protogalaxy/protogalaxy_verifier.hpp"
 #include "barretenberg/protogalaxy/prover_verifier_shared.hpp"
 #include "barretenberg/stdlib/hash/blake3s/blake3s.hpp"
 #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp"
 #include "barretenberg/stdlib/honk_verifier/decider_recursive_verifier.hpp"
-#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
 #include "barretenberg/ultra_honk/decider_keys.hpp"
 #include "barretenberg/ultra_honk/decider_prover.hpp"
 #include "barretenberg/ultra_honk/decider_verifier.hpp"
@@ -18,23 +16,24 @@
 auto& engine = bb::numeric::get_debug_randomness();
 
 namespace bb::stdlib::recursion::honk {
-template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public testing::Test {
+class ProtogalaxyRecursiveTests : public testing::Test {
   public:
     // Define types for the inner circuit, i.e. the circuit whose proof will be recursively verified
-    using InnerFlavor = typename RecursiveFlavor::NativeFlavor;
+    using RecursiveFlavor = MegaRecursiveFlavor_<MegaCircuitBuilder>;
+    using InnerFlavor = RecursiveFlavor::NativeFlavor;
     using InnerProver = UltraProver_<InnerFlavor>;
     using InnerVerifier = UltraVerifier_<InnerFlavor>;
-    using InnerBuilder = typename InnerFlavor::CircuitBuilder;
+    using InnerBuilder = InnerFlavor::CircuitBuilder;
     using InnerDeciderProvingKey = DeciderProvingKey_<InnerFlavor>;
     using InnerDeciderVerificationKey = ::bb::DeciderVerificationKey_<InnerFlavor>;
-    using InnerVerificationKey = typename InnerFlavor::VerificationKey;
+    using InnerVerificationKey = InnerFlavor::VerificationKey;
     using InnerCurve = bn254<InnerBuilder>;
     using Commitment = InnerFlavor::Commitment;
     using FF = InnerFlavor::FF;
 
     // Defines types for the outer circuit, i.e. the circuit of the recursive verifier
-    using OuterBuilder = typename RecursiveFlavor::CircuitBuilder;
-    using OuterFlavor = std::conditional_t<IsMegaBuilder<OuterBuilder>, MegaFlavor, UltraFlavor>;
+    using OuterBuilder = RecursiveFlavor::CircuitBuilder;
+    using OuterFlavor = MegaFlavor;
     using OuterProver = UltraProver_<OuterFlavor>;
     using OuterVerifier = UltraVerifier_<OuterFlavor>;
     using OuterDeciderProvingKey = DeciderProvingKey_<OuterFlavor>;
@@ -499,48 +498,45 @@ template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public tes
     }
 };
 
-using FlavorTypes = testing::Types<MegaRecursiveFlavor_<MegaCircuitBuilder>>;
-TYPED_TEST_SUITE(ProtogalaxyRecursiveTests, FlavorTypes);
-
-TYPED_TEST(ProtogalaxyRecursiveTests, InnerCircuit)
+TEST_F(ProtogalaxyRecursiveTests, InnerCircuit)
 {
-    TestFixture::test_circuit();
+    ProtogalaxyRecursiveTests::test_circuit();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, NewEvaluate)
+TEST_F(ProtogalaxyRecursiveTests, NewEvaluate)
 {
-    TestFixture::test_new_evaluate();
+    ProtogalaxyRecursiveTests::test_new_evaluate();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, RecursiveFoldingTest)
+TEST_F(ProtogalaxyRecursiveTests, RecursiveFoldingTest)
 {
-    TestFixture::test_recursive_folding();
+    ProtogalaxyRecursiveTests::test_recursive_folding();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, RecursiveFoldingTwiceTest)
+TEST_F(ProtogalaxyRecursiveTests, RecursiveFoldingTwiceTest)
 {
-    TestFixture::test_recursive_folding(/* num_verifiers= */ 2);
+    ProtogalaxyRecursiveTests::test_recursive_folding(/* num_verifiers= */ 2);
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, FullProtogalaxyRecursiveTest)
+TEST_F(ProtogalaxyRecursiveTests, FullProtogalaxyRecursiveTest)
 {
 
-    TestFixture::test_full_protogalaxy_recursive();
+    ProtogalaxyRecursiveTests::test_full_protogalaxy_recursive();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, TamperedDeciderProof)
+TEST_F(ProtogalaxyRecursiveTests, TamperedDeciderProof)
 {
-    TestFixture::test_tampered_decider_proof();
+    ProtogalaxyRecursiveTests::test_tampered_decider_proof();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, TamperedAccumulator)
+TEST_F(ProtogalaxyRecursiveTests, TamperedAccumulator)
 {
-    TestFixture::test_tampered_accumulator();
+    ProtogalaxyRecursiveTests::test_tampered_accumulator();
 }
 
-TYPED_TEST(ProtogalaxyRecursiveTests, ConstantVerifierCircuit)
+TEST_F(ProtogalaxyRecursiveTests, ConstantVerifierCircuit)
 {
-    TestFixture::test_constant_pg_verifier_circuit();
+    ProtogalaxyRecursiveTests::test_constant_pg_verifier_circuit();
 }
 
 } // namespace bb::stdlib::recursion::honk
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_mega.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_mega.cpp
deleted file mode 100644
index 8370a3638178..000000000000
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_mega.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// === AUDIT STATUS ===
-// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
-// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
-// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
-// =====================
-
-#include "barretenberg/relations/translator_vm/translator_decomposition_relation_impl.hpp"
-#include "barretenberg/stdlib/primitives/field/field.hpp"
-#include "barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp"
-
-namespace bb {
-template class TranslatorDecompositionRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDecompositionRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
-
-} // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_ultra.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_ultra.cpp
index ac7fefed59ac..5e87a990112f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_ultra.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_decomposition_relation_ultra.cpp
@@ -10,6 +10,5 @@
 
 namespace bb {
 template class TranslatorDecompositionRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDecompositionRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDecompositionRelationImpl, TranslatorRecursiveFlavor);
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_delta_range_constraint_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_delta_range_constraint_relation.cpp
index bbd43f8ed961..18e3f912b57b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_delta_range_constraint_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_delta_range_constraint_relation.cpp
@@ -10,9 +10,6 @@
 
 namespace bb {
 template class TranslatorDeltaRangeConstraintRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
-template class TranslatorDeltaRangeConstraintRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDeltaRangeConstraintRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDeltaRangeConstraintRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorDeltaRangeConstraintRelationImpl, TranslatorRecursiveFlavor);
+
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_extra_relations.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_extra_relations.cpp
index 92177be21270..06ecf17a91d2 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_extra_relations.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_extra_relations.cpp
@@ -12,20 +12,8 @@ namespace bb {
 template class TranslatorOpcodeConstraintRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
 template class TranslatorAccumulatorTransferRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
 template class TranslatorZeroConstraintsRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
-template class TranslatorOpcodeConstraintRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-template class TranslatorAccumulatorTransferRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-template class TranslatorZeroConstraintsRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorOpcodeConstraintRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorOpcodeConstraintRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorAccumulatorTransferRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorAccumulatorTransferRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorZeroConstraintsRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorZeroConstraintsRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorOpcodeConstraintRelationImpl, TranslatorRecursiveFlavor);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorAccumulatorTransferRelationImpl, TranslatorRecursiveFlavor);
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorZeroConstraintsRelationImpl, TranslatorRecursiveFlavor);
 
-} // namespace bb
\ No newline at end of file
+} // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_non_native_field_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_non_native_field_relation.cpp
index b059dc743d6e..b946178c18fe 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_non_native_field_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_non_native_field_relation.cpp
@@ -10,10 +10,6 @@
 
 namespace bb {
 template class TranslatorNonNativeFieldRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
-template class TranslatorNonNativeFieldRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
 
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorNonNativeFieldRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorNonNativeFieldRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
-} // namespace bb
\ No newline at end of file
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorNonNativeFieldRelationImpl, TranslatorRecursiveFlavor);
+} // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_permutation_relation.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_permutation_relation.cpp
index 0e863d887f0b..9d6956a0ca24 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_permutation_relation.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_permutation_relation.cpp
@@ -10,9 +10,5 @@
 
 namespace bb {
 template class TranslatorPermutationRelationImpl<stdlib::field_t<UltraCircuitBuilder>>;
-template class TranslatorPermutationRelationImpl<stdlib::field_t<MegaCircuitBuilder>>;
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorPermutationRelationImpl,
-                                        TranslatorRecursiveFlavor_<UltraCircuitBuilder>);
-DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorPermutationRelationImpl,
-                                        TranslatorRecursiveFlavor_<MegaCircuitBuilder>);
-} // namespace bb
\ No newline at end of file
+DEFINE_SUMCHECK_VERIFIER_RELATION_CLASS(TranslatorPermutationRelationImpl, TranslatorRecursiveFlavor);
+} // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp
index 6723c6641a4e..e95e98fda0af 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp
@@ -28,12 +28,12 @@ namespace bb {
  * sense to instantiate a Verifier with this flavor. We reuse the native flavor to initialise identical  constructions.
  * @tparam BuilderType Determines the arithmetization of the verifier circuit defined based on this flavor.
  */
-template <typename BuilderType> class TranslatorRecursiveFlavor_ {
+class TranslatorRecursiveFlavor {
 
   public:
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/990): Establish whether mini_circuit_size pattern is
     // needed
-    using CircuitBuilder = BuilderType;
+    using CircuitBuilder = UltraCircuitBuilder;
     using Curve = stdlib::bn254<CircuitBuilder>;
     using PCS = KZG<Curve>;
     using GroupElement = Curve::Element;
@@ -105,7 +105,7 @@ template <typename BuilderType> class TranslatorRecursiveFlavor_ {
      * portability of our circuits.
      */
     class VerificationKey
-        : public StdlibVerificationKey_<BuilderType, TranslatorFlavor::PrecomputedEntities<Commitment>> {
+        : public StdlibVerificationKey_<CircuitBuilder, TranslatorFlavor::PrecomputedEntities<Commitment>> {
       public:
         VerificationKey(CircuitBuilder* builder, const std::shared_ptr<NativeVerificationKey>& native_key)
         {
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
index 71c8edc68e0d..c8e9f3dbe726 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
@@ -16,8 +16,7 @@
 
 namespace bb {
 
-template <typename Flavor>
-TranslatorRecursiveVerifier_<Flavor>::TranslatorRecursiveVerifier_(
+TranslatorRecursiveVerifier::TranslatorRecursiveVerifier(
     Builder* builder,
     const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
     const std::shared_ptr<Transcript>& transcript)
@@ -27,10 +26,9 @@ TranslatorRecursiveVerifier_<Flavor>::TranslatorRecursiveVerifier_(
 {}
 
 // Relation params used in sumcheck which is done over FF but the received data is from BF
-template <typename Flavor>
-void TranslatorRecursiveVerifier_<Flavor>::put_translation_data_in_relation_parameters(const BF& evaluation_input_x,
-                                                                                       const BF& batching_challenge_v,
-                                                                                       const BF& accumulated_result)
+void TranslatorRecursiveVerifier::put_translation_data_in_relation_parameters(const BF& evaluation_input_x,
+                                                                              const BF& batching_challenge_v,
+                                                                              const BF& accumulated_result)
 {
 
     const auto compute_four_limbs = [](const BF& in) {
@@ -68,9 +66,9 @@ void TranslatorRecursiveVerifier_<Flavor>::put_translation_data_in_relation_para
  * @param batching_challenge_v Challenge for batching translation polynomial evaluations
  * @return TranslatorRecursiveVerifier_<Flavor>::PairingPoints
  */
-template <typename Flavor>
-TranslatorRecursiveVerifier_<Flavor>::PairingPoints TranslatorRecursiveVerifier_<Flavor>::verify_proof(
-    const HonkProof& proof, const BF& evaluation_input_x, const BF& batching_challenge_v)
+TranslatorRecursiveVerifier::PairingPoints TranslatorRecursiveVerifier::verify_proof(const HonkProof& proof,
+                                                                                     const BF& evaluation_input_x,
+                                                                                     const BF& batching_challenge_v)
 {
     StdlibProof stdlib_proof(*builder, proof);
     return verify_proof(stdlib_proof, evaluation_input_x, batching_challenge_v);
@@ -85,16 +83,16 @@ TranslatorRecursiveVerifier_<Flavor>::PairingPoints TranslatorRecursiveVerifier_
  * @param batching_challenge_v Challenge for batching translation polynomial evaluations
  * @return TranslatorRecursiveVerifier_<Flavor>::PairingPoints
  */
-template <typename Flavor>
-TranslatorRecursiveVerifier_<Flavor>::PairingPoints TranslatorRecursiveVerifier_<Flavor>::verify_proof(
-    const StdlibProof& proof, const BF& evaluation_input_x, const BF& batching_challenge_v)
+TranslatorRecursiveVerifier::PairingPoints TranslatorRecursiveVerifier::verify_proof(const StdlibProof& proof,
+                                                                                     const BF& evaluation_input_x,
+                                                                                     const BF& batching_challenge_v)
 {
     using Sumcheck = ::bb::SumcheckVerifier<Flavor, TranslatorFlavor::CONST_TRANSLATOR_LOG_N>;
-    using PCS = typename Flavor::PCS;
-    using Curve = typename Flavor::Curve;
+    using PCS = Flavor::PCS;
+    using Curve = Flavor::Curve;
     using Shplemini = ::bb::ShpleminiVerifier_<Curve>;
-    using VerifierCommitments = typename Flavor::VerifierCommitments;
-    using CommitmentLabels = typename Flavor::CommitmentLabels;
+    using VerifierCommitments = Flavor::VerifierCommitments;
+    using CommitmentLabels = Flavor::CommitmentLabels;
     using ClaimBatcher = ClaimBatcher_<Curve>;
     using ClaimBatch = ClaimBatcher::Batch;
     using InterleavedBatch = ClaimBatcher::InterleavedBatch;
@@ -176,9 +174,8 @@ TranslatorRecursiveVerifier_<Flavor>::PairingPoints TranslatorRecursiveVerifier_
     return { pairing_points[0], pairing_points[1] };
 }
 
-template <typename Flavor>
-void TranslatorRecursiveVerifier_<Flavor>::verify_translation(
-    const TranslationEvaluations_<BF>& translation_evaluations, const BF& translation_masking_term_eval)
+void TranslatorRecursiveVerifier::verify_translation(const TranslationEvaluations_<BF>& translation_evaluations,
+                                                     const BF& translation_masking_term_eval)
 {
     const auto reconstruct_from_array = [&](const auto& arr) {
         return BF::construct_from_limbs(arr[0], arr[1], arr[2], arr[3]);
@@ -201,8 +198,7 @@ void TranslatorRecursiveVerifier_<Flavor>::verify_translation(
     eccvm_opening.assert_equal(x * accumulated_result);
 }
 
-template <typename Flavor>
-void TranslatorRecursiveVerifier_<Flavor>::verify_consistency_with_final_merge(
+void TranslatorRecursiveVerifier::verify_consistency_with_final_merge(
     const std::array<Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES> merge_commitments)
 {
     // Check the consistency with final merge
@@ -224,6 +220,5 @@ void TranslatorRecursiveVerifier_<Flavor>::verify_consistency_with_final_merge(
         merge_commitment.is_point_at_infinity().assert_equal(translator_commitment.is_point_at_infinity());
     }
 }
-template class TranslatorRecursiveVerifier_<bb::TranslatorRecursiveFlavor_<UltraCircuitBuilder>>;
 
 } // namespace bb
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.hpp
index 4e9ae41f7ed4..661a93cd9f80 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.hpp
@@ -16,21 +16,22 @@
 #include "barretenberg/translator_vm/translator_prover.hpp"
 
 namespace bb {
-template <typename Flavor> class TranslatorRecursiveVerifier_ {
+class TranslatorRecursiveVerifier {
   public:
-    using FF = typename Flavor::FF;
-    using NativeBF = typename Flavor::Curve::BaseFieldNative;
-    using Builder = typename Flavor::CircuitBuilder;
-    using BF = typename stdlib::bigfield<Builder, typename NativeBF::Params>;
-    using Commitment = typename Flavor::Commitment;
-    using GroupElement = typename Flavor::GroupElement;
-    using VerificationKey = typename Flavor::VerificationKey;
-    using NativeVerificationKey = typename Flavor::NativeVerificationKey;
-    using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey;
-    using RelationSeparator = typename Flavor::RelationSeparator;
+    using Flavor = TranslatorRecursiveFlavor;
+    using FF = Flavor::FF;
+    using NativeBF = Flavor::Curve::BaseFieldNative;
+    using Builder = Flavor::CircuitBuilder;
+    using BF = Flavor::BF;
+    using Commitment = Flavor::Commitment;
+    using GroupElement = Flavor::GroupElement;
+    using VerificationKey = Flavor::VerificationKey;
+    using NativeVerificationKey = Flavor::NativeVerificationKey;
+    using VerifierCommitmentKey = Flavor::VerifierCommitmentKey;
+    using RelationSeparator = Flavor::RelationSeparator;
     using PairingPoints = stdlib::recursion::PairingPoints<Builder>;
     using TranslationEvaluations = TranslationEvaluations_<BF>;
-    using Transcript = typename Flavor::Transcript;
+    using Transcript = Flavor::Transcript;
     using RelationParams = ::bb::RelationParameters<FF>;
     using StdlibProof = stdlib::Proof<Builder>;
 
@@ -42,9 +43,9 @@ template <typename Flavor> class TranslatorRecursiveVerifier_ {
 
     RelationParams relation_parameters;
 
-    TranslatorRecursiveVerifier_(Builder* builder,
-                                 const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
-                                 const std::shared_ptr<Transcript>& transcript);
+    TranslatorRecursiveVerifier(Builder* builder,
+                                const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
+                                const std::shared_ptr<Transcript>& transcript);
 
     void put_translation_data_in_relation_parameters(const BF& evaluation_input_x,
                                                      const BF& batching_challenge_v,
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
index 8951546ee485..f598223e04fb 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
@@ -18,10 +18,11 @@ namespace bb {
 // TODO(https://github.com/AztecProtocol/barretenberg/issues/980): Add failing tests after we have a proper shared
 // transcript interface between ECCVM and Translator and we are able to deserialise and serialise the transcript
 // correctly.
-template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::testing::Test {
+class TranslatorRecursiveTests : public ::testing::Test {
   public:
-    using InnerFlavor = typename RecursiveFlavor::NativeFlavor;
-    using InnerBuilder = typename InnerFlavor::CircuitBuilder;
+    using RecursiveFlavor = TranslatorRecursiveFlavor;
+    using InnerFlavor = RecursiveFlavor::NativeFlavor;
+    using InnerBuilder = InnerFlavor::CircuitBuilder;
     using InnerProvingKey = TranslatorProvingKey;
     using InnerProver = TranslatorProver;
     using InnerVerifier = TranslatorVerifier;
@@ -29,15 +30,15 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
     using InnerFF = InnerFlavor::FF;
     using InnerBF = InnerFlavor::BF;
 
-    using RecursiveVerifier = TranslatorRecursiveVerifier_<RecursiveFlavor>;
+    using RecursiveVerifier = TranslatorRecursiveVerifier;
 
-    using OuterBuilder = typename RecursiveFlavor::CircuitBuilder;
+    using OuterBuilder = RecursiveFlavor::CircuitBuilder;
     using OuterFlavor = std::conditional_t<IsMegaBuilder<OuterBuilder>, MegaFlavor, UltraFlavor>;
     using OuterProver = UltraProver_<OuterFlavor>;
     using OuterVerifier = UltraVerifier_<OuterFlavor>;
     using OuterDeciderProvingKey = DeciderProvingKey_<OuterFlavor>;
 
-    using TranslatorBF = typename TranslatorRecursiveFlavor_<OuterBuilder>::BF;
+    using TranslatorBF = TranslatorRecursiveFlavor::BF;
 
     using Transcript = InnerFlavor::Transcript;
 
@@ -62,7 +63,7 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
 
     static void test_recursive_verification()
     {
-        using NativeVerifierCommitmentKey = typename InnerFlavor::VerifierCommitmentKey;
+        using NativeVerifierCommitmentKey = InnerFlavor::VerifierCommitmentKey;
         // Add the same operations to the ECC op queue; the native computation is performed under the hood.
         auto op_queue = create_op_queue(500);
 
@@ -84,9 +85,9 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
 
         // Mock a previous verifier that would in reality be the ECCVM recursive verifier
         stdlib::Proof<OuterBuilder> stdlib_proof(outer_circuit, fake_inital_proof);
-        auto transcript = std::make_shared<typename RecursiveFlavor::Transcript>();
+        auto transcript = std::make_shared<RecursiveFlavor::Transcript>();
         transcript->load_proof(stdlib_proof);
-        [[maybe_unused]] auto _ = transcript->template receive_from_prover<typename RecursiveFlavor::BF>("init");
+        [[maybe_unused]] auto _ = transcript->template receive_from_prover<RecursiveFlavor::BF>("init");
 
         auto verification_key = std::make_shared<typename InnerFlavor::VerificationKey>(prover.key->proving_key);
         RecursiveVerifier verifier{ &outer_circuit, verification_key, transcript };
@@ -125,7 +126,7 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
 
         {
             auto proving_key = std::make_shared<OuterDeciderProvingKey>(outer_circuit);
-            auto verification_key = std::make_shared<typename OuterFlavor::VerificationKey>(proving_key->proving_key);
+            auto verification_key = std::make_shared<OuterFlavor::VerificationKey>(proving_key->proving_key);
             OuterProver prover(proving_key, verification_key);
             OuterVerifier verifier(verification_key);
             auto proof = prover.construct_proof();
@@ -139,8 +140,8 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
     {
 
         // Retrieves the trace blocks (each consisting of a specific gate) from the recursive verifier circuit
-        auto get_blocks = [](size_t num_ops) -> std::tuple<typename OuterBuilder::ExecutionTrace,
-                                                           std::shared_ptr<typename OuterFlavor::VerificationKey>> {
+        auto get_blocks = [](size_t num_ops)
+            -> std::tuple<OuterBuilder::ExecutionTrace, std::shared_ptr<OuterFlavor::VerificationKey>> {
             auto op_queue = create_op_queue(num_ops);
 
             auto prover_transcript = std::make_shared<Transcript>();
@@ -192,21 +193,13 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
     };
 };
 
-using FlavorTypes = testing::Types<TranslatorRecursiveFlavor_<UltraCircuitBuilder>>;
-
-TYPED_TEST_SUITE(TranslatorRecursiveTests, FlavorTypes);
-
-TYPED_TEST(TranslatorRecursiveTests, SingleRecursiveVerification)
+TEST_F(TranslatorRecursiveTests, SingleRecursiveVerification)
 {
-    TestFixture::test_recursive_verification();
+    TranslatorRecursiveTests::test_recursive_verification();
 };
 
-TYPED_TEST(TranslatorRecursiveTests, IndependentVKHash)
+TEST_F(TranslatorRecursiveTests, IndependentVKHash)
 {
-    if constexpr (std::is_same_v<TypeParam, TranslatorRecursiveFlavor_<UltraCircuitBuilder>>) {
-        TestFixture::test_independent_vk_hash();
-    } else {
-        GTEST_SKIP() << "Not built for this parameter";
-    }
+    TranslatorRecursiveTests::test_independent_vk_hash();
 };
 } // namespace bb