From 8829f7c2baf316baaeadefa9040369f282bf08a3 Mon Sep 17 00:00:00 2001
From: Rumata888 <isennovskiy@gmail.com>
Date: Mon, 31 Jul 2023 16:48:03 +0000
Subject: [PATCH] fix: Fixing fuzzing build after composer splitting

---
 .../barretenberg/acir_tests/run_acir_tests.sh |   4 +-
 circuits/cpp/barretenberg/cpp/bootstrap.sh    |  13 +-
 .../cpp/barretenberg/cpp/scripts/run_tests    |   1 +
 .../cpp/src/barretenberg/common/fuzzer.hpp    |   8 +-
 .../cpp/src/barretenberg/common/serialize.hpp |   3 +-
 .../cpp/src/barretenberg/common/streams.hpp   |   3 +-
 .../dsl/acir_format/acir_format.hpp           |   4 +-
 .../dsl/acir_format/block_constraint.test.cpp |   2 +-
 .../dsl/acir_format/ecdsa_secp256k1.test.cpp  |   2 +-
 .../dsl/acir_format/ecdsa_secp256r1.test.cpp  |   2 +-
 .../acir_format/recursion_constraint.test.cpp |   2 +-
 .../dsl/acir_proofs/acir_composer.cpp         |  12 +-
 .../dsl/acir_proofs/acir_composer.hpp         |  16 +-
 .../ecc/curves/grumpkin/grumpkin.hpp          |   2 +-
 .../barretenberg/examples/simple/simple.cpp   |   2 +-
 .../barretenberg/examples/simple/simple.hpp   |   2 +-
 .../examples/simple/simple.test.cpp           |   2 +-
 .../grumpkin_srs_gen/CMakeLists.txt           |  24 +-
 .../grumpkin_srs_gen/grumpkin_srs_gen.cpp     |   4 +-
 .../honk/composer/standard_composer.hpp       |  19 +-
 .../honk/composer/standard_composer.test.cpp  | 195 ++---
 .../honk/composer/ultra_composer.hpp          |   9 +-
 .../honk/composer/ultra_composer.test.cpp     |   9 +-
 .../barretenberg/honk/flavor/goblin_ultra.hpp |  14 +-
 .../src/barretenberg/honk/flavor/standard.hpp |  14 +-
 .../honk/flavor/standard_grumpkin.hpp         |  16 +-
 .../src/barretenberg/honk/flavor/ultra.hpp    |  17 +-
 .../honk/flavor/ultra_grumpkin.hpp            |  19 +-
 .../barretenberg/honk/pcs/commitment_key.hpp  |  61 +-
 .../honk/pcs/commitment_key.test.hpp          |  26 +-
 .../honk/pcs/gemini/gemini.test.cpp           |   3 +-
 .../cpp/src/barretenberg/honk/pcs/ipa/ipa.hpp |  18 +-
 .../barretenberg/honk/pcs/ipa/ipa.test.cpp    |  93 +++
 .../barretenberg/honk/pcs/kzg/kzg.test.cpp    |   2 +-
 .../honk/pcs/shplonk/shplonk.test.cpp         |   5 +-
 .../honk/pcs/shplonk/shplonk_single.hpp       |   8 +-
 .../honk/proof_system/composer_lib.hpp        |   2 +-
 .../honk/proof_system/ultra_verifier.cpp      |   2 +-
 .../honk/proof_system/verifier.cpp            |   2 +-
 .../relations/relation_correctness.test.cpp   |   3 +-
 .../sumcheck/relations/relation_types.hpp     |  20 +-
 .../honk/sumcheck/sumcheck.test.cpp           |   3 +-
 .../honk/sumcheck/sumcheck_round.hpp          |   5 +-
 .../honk/transcript/transcript.test.cpp       |   8 +-
 .../proofs/compute_circuit_data.hpp           |   4 +-
 .../join_split/compute_circuit_data.cpp       |   3 +-
 .../join_split/compute_circuit_data.hpp       |   3 +-
 .../proofs/join_split/join_split.cpp          |   5 +-
 .../proofs/join_split/join_split.hpp          |   5 +-
 .../proofs/join_split/join_split.test.cpp     |   5 +-
 .../join_split/join_split_js_parity.test.cpp  |   5 +-
 .../plonk/composer/composer_lib.cpp           |   3 +-
 .../plonk/composer/composer_lib.hpp           |  15 +-
 .../plonk/composer/standard_composer.cpp      |   3 +-
 .../plonk/composer/standard_composer.hpp      |  11 +-
 .../plonk/composer/standard_composer.test.cpp |  28 +-
 .../plonk/composer/turbo_composer.hpp         |  10 +-
 .../plonk/composer/turbo_composer.test.cpp    | 131 ++--
 .../plonk/composer/ultra_composer.hpp         |   7 +-
 .../plonk/composer/ultra_composer.test.cpp    |   9 +-
 .../src/barretenberg/plonk/flavor/flavor.hpp  |   9 +
 .../commitment_scheme.test.cpp                |   6 +-
 .../proving_key/proving_key.test.cpp          |   4 +-
 .../verification_key/verification_key.cpp     |   4 +-
 .../verification_key/verification_key.hpp     |   7 +-
 .../proof_system/verifier/verifier.test.cpp   |   2 +-
 .../polynomials/evaluation_domain.cpp         |  12 +-
 .../polynomials/evaluation_domain.hpp         |  42 +-
 .../polynomial_arithmetic.test.cpp            |   1 +
 .../arithmetization/arithmetization.hpp       |   7 +
 .../arithmetization/gate_data.hpp             |  20 +-
 .../circuit_builder/circuit_builder_base.cpp  |   1 +
 .../circuit_builder/circuit_builder_base.hpp  |   7 +-
 .../goblin_translator_circuit_builder.hpp     | 699 ++++++++++++++++++
 ...goblin_translator_circuit_builder.test.cpp | 432 +++++++++++
 .../standard_circuit_builder.cpp              |  27 +-
 .../standard_circuit_builder.hpp              |  14 +-
 .../standard_circuit_builder.test.cpp         |  67 +-
 .../circuit_builder/turbo_circuit_builder.cpp |  44 +-
 .../circuit_builder/turbo_circuit_builder.hpp |  33 +-
 .../turbo_circuit_builder.test.cpp            |  95 ++-
 .../circuit_builder/ultra_circuit_builder.cpp |  19 +-
 .../circuit_builder/ultra_circuit_builder.hpp |  33 +-
 .../ultra_circuit_builder.test.cpp            |  12 +-
 .../proof_system/composer/composer_lib.hpp    |  10 +-
 .../composer/composer_lib.test.cpp            |   2 +-
 .../proof_system/composer/permutation_lib.hpp |  11 +-
 .../composer/permutation_lib.test.cpp         |   3 +-
 .../serialize/msgpack_impl/concepts.hpp       |  24 +-
 .../serialize/msgpack_impl/func_traits.hpp    |   7 +-
 .../serialize/msgpack_impl/schema_impl.hpp    |  14 +-
 .../solidity_helpers/CMakeLists.txt           |  22 +-
 .../srs/factories/crs_factory.hpp             |  48 +-
 .../srs/factories/file_crs_factory.cpp        |  58 +-
 .../srs/factories/file_crs_factory.hpp        |  76 +-
 .../srs/factories/mem_crs_factory.cpp         |  17 +-
 .../srs/factories/mem_crs_factory.hpp         |   9 +-
 .../srs/factories/mem_crs_factory.test.cpp    |   7 +-
 .../cpp/src/barretenberg/srs/global_crs.cpp   |  25 +-
 .../cpp/src/barretenberg/srs/global_crs.hpp   |   8 +-
 .../benchmarks/external/external.bench.cpp    |  23 +-
 .../hash/benchmarks/sha256/sha256.bench.cpp   |  14 +-
 .../stdlib/hash/pedersen/pedersen.cpp         |  49 +-
 .../stdlib/hash/pedersen/pedersen_gates.hpp   |   7 +-
 .../stdlib/hash/pedersen/pedersen_plookup.cpp |  12 +-
 .../primitives/bigfield/bigfield.fuzzer.hpp   |  20 +-
 .../primitives/bit_array/bit_array.fuzzer.hpp |  13 +-
 .../stdlib/primitives/bool/bool.cpp           |  59 +-
 .../stdlib/primitives/bool/bool.fuzzer.hpp    |   4 +-
 .../byte_array/byte_array.fuzzer.hpp          |   4 +-
 .../circuit_builders/circuit_builders_fwd.hpp |   2 +
 .../stdlib/primitives/field/field.cpp         | 150 ++--
 .../stdlib/primitives/field/field.fuzzer.hpp  | 126 ++--
 .../stdlib/primitives/field/field.test.cpp    |  34 +-
 .../stdlib/primitives/group/group.hpp         |  28 +-
 .../primitives/safe_uint/safe_uint.fuzzer.hpp |   5 +-
 .../stdlib/primitives/uint/arithmetic.cpp     |  41 +-
 .../stdlib/primitives/uint/logic.cpp          |  68 +-
 .../primitives/uint/plookup/arithmetic.cpp    |  57 +-
 .../stdlib/primitives/uint/plookup/uint.hpp   |   1 +
 .../stdlib/primitives/uint/uint.cpp           |  56 +-
 .../stdlib/primitives/uint/uint.fuzzer.hpp    |   4 +-
 .../stdlib/primitives/uint/uint.test.cpp      |  27 +-
 .../verification_key/verification_key.hpp     |   2 +-
 .../verification_key.test.cpp                 |   4 +-
 125 files changed, 2548 insertions(+), 1128 deletions(-)
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.hpp
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.test.cpp

diff --git a/circuits/cpp/barretenberg/acir_tests/run_acir_tests.sh b/circuits/cpp/barretenberg/acir_tests/run_acir_tests.sh
index 6531a28b6bd8..2767f2ec909c 100755
--- a/circuits/cpp/barretenberg/acir_tests/run_acir_tests.sh
+++ b/circuits/cpp/barretenberg/acir_tests/run_acir_tests.sh
@@ -18,10 +18,10 @@ if [ ! -d acir_tests ]; then
     git clone -b $BRANCH --filter=blob:none --no-checkout https://github.com/noir-lang/noir.git
     cd noir
     git sparse-checkout init --cone
-    git sparse-checkout set crates/nargo_cli/tests/test_data_ssa_refactor
+    git sparse-checkout set crates/nargo_cli/tests/test_data
     git checkout
     cd ..
-    mv noir/crates/nargo_cli/tests/test_data_ssa_refactor acir_tests
+    mv noir/crates/nargo_cli/tests/test_data acir_tests
     rm -rf noir
   fi
 fi
diff --git a/circuits/cpp/barretenberg/cpp/bootstrap.sh b/circuits/cpp/barretenberg/cpp/bootstrap.sh
index 0b81033372d1..f81477ff7388 100755
--- a/circuits/cpp/barretenberg/cpp/bootstrap.sh
+++ b/circuits/cpp/barretenberg/cpp/bootstrap.sh
@@ -8,10 +8,8 @@ rm -rf ./build-wasm
 # Install formatting git hook.
 HOOKS_DIR=$(git rev-parse --git-path hooks)
 # The pre-commit script will live in a barretenberg-specific hooks directory
-# That may be just in the top level of this repository,
-# or may be in a .git/modules/barretenberg subdirectory when this is actually a submodule
-# Either way, running `git rev-parse --show-toplevel` from the hooks directory gives the path to barretenberg
-echo "cd \$(git rev-parse --show-toplevel)/cpp && ./format.sh staged" > $HOOKS_DIR/pre-commit
+# Find it based on the current working directory.
+echo "cd $(pwd)/cpp && ./format.sh staged" > $HOOKS_DIR/pre-commit
 chmod +x $HOOKS_DIR/pre-commit
 
 # Determine system.
@@ -50,6 +48,13 @@ echo "#################################"
 cmake --preset $PRESET -DCMAKE_BUILD_TYPE=RelWithAssert
 cmake --build --preset $PRESET ${@/#/--target }
 
+cd ./build
+# The Grumpkin SRS is generated manually at the moment, only up to a large enough size for tests
+# If tests require more points, the parameter can be increased here.
+cmake --build . --parallel --target grumpkin_srs_gen
+./bin/grumpkin_srs_gen 8192
+echo "Generated Grumpkin SRS successfully"
+
 # Install wasi-sdk.
 ./scripts/install-wasi-sdk.sh
 
diff --git a/circuits/cpp/barretenberg/cpp/scripts/run_tests b/circuits/cpp/barretenberg/cpp/scripts/run_tests
index 7459879b2c12..409379f4e015 100755
--- a/circuits/cpp/barretenberg/cpp/scripts/run_tests
+++ b/circuits/cpp/barretenberg/cpp/scripts/run_tests
@@ -25,4 +25,5 @@ docker run --rm -t $IMAGE_URI /bin/sh -c "\
   cd /usr/src/barretenberg/cpp/srs_db; \
   ./download_ignition.sh $NUM_TRANSCRIPTS; \
   cd /usr/src/barretenberg/cpp/build; \
+  ./bin/grumpkin_srs_gen 1048576; \
   for BIN in $TESTS; do ./bin/\$BIN $@; done"
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
index 079ae269f7fc..1a2fcda97c4c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include "barretenberg/plonk/composer/standard_composer.hpp"
-#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.hpp"
+#include "barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.hpp"
 #include <concepts>
 
 #define PARENS ()
@@ -590,9 +590,9 @@ template <template <typename> class Fuzzer, uint64_t Composers>
 constexpr void RunWithComposers(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
 {
     if (Composers & 1) {
-        RunWithComposer<Fuzzer, plonk::StandardPlonkComposer>(Data, Size, VarianceRNG);
+        RunWithComposer<Fuzzer, proof_system::StandardCircuitConstructor>(Data, Size, VarianceRNG);
     }
     if (Composers & 2) {
-        RunWithComposer<Fuzzer, plonk::TurboPlonkComposer>(Data, Size, VarianceRNG);
+        RunWithComposer<Fuzzer, proof_system::TurboCircuitConstructor>(Data, Size, VarianceRNG);
     }
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/serialize.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/serialize.hpp
index 08e1db78bf07..ea20decbf9f1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/serialize.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/serialize.hpp
@@ -44,8 +44,7 @@
 __extension__ using uint128_t = unsigned __int128;
 #endif
 
-template <typename T>
-concept IntegralOrEnum = std::integral<T> || std::is_enum_v<T>;
+template <typename T> concept IntegralOrEnum = std::integral<T> || std::is_enum_v<T>;
 
 namespace serialize {
 // Forward declare derived msgpack methods
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/streams.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/streams.hpp
index 1426b07e9813..9ea5273e3a79 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/streams.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/streams.hpp
@@ -30,8 +30,7 @@ template <std::integral T, typename A> inline std::ostream& operator<<(std::ostr
 }
 
 template <typename T, typename A>
-    requires(!std::integral<T>)
-inline std::ostream& operator<<(std::ostream& os, std::vector<T, A> const& arr)
+requires(!std::integral<T>) inline std::ostream& operator<<(std::ostream& os, std::vector<T, A> const& arr)
 {
     os << "[\n";
     for (auto element : arr) {
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
index ad4b89132a4e..0889bd2b4e26 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp
@@ -40,7 +40,9 @@ struct acir_format {
     // A standard plonk arithmetic constraint, as defined in the poly_triple struct, consists of selector values
     // for q_M,q_L,q_R,q_O,q_C and indices of three variables taking the role of left, right and output wire
     // This could be a large vector so use slab allocator, we don't expect the blackbox implementations to be so large.
-    std::vector<poly_triple, ContainerSlabAllocator<poly_triple>> constraints;
+    std::vector<poly_triple_<curve::BN254::ScalarField>,
+                ContainerSlabAllocator<poly_triple_<curve::BN254::ScalarField>>>
+        constraints;
     std::vector<BlockConstraint> block_constraints;
 
     // For serialization, update with any new fields
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
index d24eaf631877..1704d5a84229 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp
@@ -1,7 +1,7 @@
-#include "block_constraint.hpp"
 #include "acir_format.hpp"
 #include "barretenberg/plonk/proof_system/types/proof.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "block_constraint.hpp"
 
 #include <gtest/gtest.h>
 #include <vector>
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
index a26894dd0c73..d36d4f3a2fbc 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp
@@ -1,8 +1,8 @@
-#include "ecdsa_secp256k1.hpp"
 #include "acir_format.hpp"
 #include "barretenberg/crypto/ecdsa/ecdsa.hpp"
 #include "barretenberg/plonk/proof_system/types/proof.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "ecdsa_secp256k1.hpp"
 
 #include <gtest/gtest.h>
 #include <vector>
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp
index affb7e25c75f..5ad181cc24cb 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp
@@ -1,8 +1,8 @@
-#include "ecdsa_secp256r1.hpp"
 #include "acir_format.hpp"
 #include "barretenberg/crypto/ecdsa/ecdsa.hpp"
 #include "barretenberg/plonk/proof_system/types/proof.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "ecdsa_secp256r1.hpp"
 
 #include <gtest/gtest.h>
 #include <vector>
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
index 8ea6c938f53e..8508e993e754 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp
@@ -1,7 +1,7 @@
-#include "recursion_constraint.hpp"
 #include "acir_format.hpp"
 #include "barretenberg/plonk/proof_system/types/proof.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
+#include "recursion_constraint.hpp"
 
 #include <gtest/gtest.h>
 #include <vector>
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
index 159b8f3b4528..29463a06db7f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.cpp
@@ -31,8 +31,9 @@ void AcirComposer::create_circuit(acir_format::acir_format& constraint_system)
     size_hint_ = circuit_subgroup_size_;
 }
 
-void AcirComposer::init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
-                                    acir_format::acir_format& constraint_system)
+void AcirComposer::init_proving_key(
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+    acir_format::acir_format& constraint_system)
 {
     vinfo("building circuit... ", size_hint_);
     builder_ = acir_format::Builder(size_hint_);
@@ -52,7 +53,7 @@ void AcirComposer::init_proving_key(std::shared_ptr<barretenberg::srs::factories
 }
 
 std::vector<uint8_t> AcirComposer::create_proof(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
     acir_format::acir_format& constraint_system,
     acir_format::WitnessVector& witness,
     bool is_recursive)
@@ -107,8 +108,9 @@ std::shared_ptr<proof_system::plonk::verification_key> AcirComposer::init_verifi
     return verification_key_;
 }
 
-void AcirComposer::load_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
-                                         proof_system::plonk::verification_key_data&& data)
+void AcirComposer::load_verification_key(
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+    proof_system::plonk::verification_key_data&& data)
 {
     verification_key_ =
         std::make_shared<proof_system::plonk::verification_key>(std::move(data), crs_factory->get_verifier_crs());
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
index 3b25c26f2dc9..71f91093d5e6 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/dsl/acir_proofs/acir_composer.hpp
@@ -13,16 +13,18 @@ class AcirComposer {
 
     void create_circuit(acir_format::acir_format& constraint_system);
 
-    void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
+    void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
                           acir_format::acir_format& constraint_system);
 
-    std::vector<uint8_t> create_proof(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
-                                      acir_format::acir_format& constraint_system,
-                                      acir_format::WitnessVector& witness,
-                                      bool is_recursive);
+    std::vector<uint8_t> create_proof(
+        std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+        acir_format::acir_format& constraint_system,
+        acir_format::WitnessVector& witness,
+        bool is_recursive);
 
-    void load_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory,
-                               proof_system::plonk::verification_key_data&& data);
+    void load_verification_key(
+        std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+        proof_system::plonk::verification_key_data&& data);
 
     std::shared_ptr<proof_system::plonk::verification_key> init_verification_key();
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/ecc/curves/grumpkin/grumpkin.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/ecc/curves/grumpkin/grumpkin.hpp
index cd575a16d608..fc799acce556 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/ecc/curves/grumpkin/grumpkin.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/ecc/curves/grumpkin/grumpkin.hpp
@@ -22,7 +22,7 @@ struct GrumpkinG1Params {
     };
     static constexpr barretenberg::fr a{ 0UL, 0UL, 0UL, 0UL };
 
-    // generator point = (x, y) = (1, sqrt(-15))
+    // generator point = (x, y) = (1, sqrt(-16)), sqrt(-16) = 4i
     static constexpr barretenberg::fr one_x = barretenberg::fr::one();
     static constexpr barretenberg::fr one_y{
         0x11b2dff1448c41d8UL, 0x23d3446f21c77dc3UL, 0xaa7b8cf435dfafbbUL, 0x14b34cf69dc25d68UL
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.cpp
index a477ccb00a6a..19af6aa0d691 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.cpp
@@ -20,7 +20,7 @@ void build_circuit(Builder& builder)
 }
 
 BuilderComposerPtrs create_builder_and_composer(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory)
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory)
 {
     // WARNING: Size hint is essential to perform 512k circuits!
     auto builder = std::make_unique<Builder>(CIRCUIT_SIZE);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.hpp
index 8915a3f8283a..0932708bf216 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.hpp
@@ -13,7 +13,7 @@ struct BuilderComposerPtrs {
 };
 
 BuilderComposerPtrs create_builder_and_composer(
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory);
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory);
 
 proof create_proof(BuilderComposerPtrs pair);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.test.cpp
index 16399f08d4ee..a43c3de45033 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/examples/simple/simple.test.cpp
@@ -8,7 +8,7 @@ namespace examples::simple {
 TEST(examples_simple, create_proof)
 {
     auto srs_path = std::filesystem::absolute("../srs_db/ignition");
-    auto crs_factory = std::make_shared<barretenberg::srs::factories::FileCrsFactory>(srs_path);
+    auto crs_factory = std::make_shared<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>(srs_path);
     auto ptrs = create_builder_and_composer(crs_factory);
     auto proof = create_proof(ptrs);
     bool valid = verify_proof(ptrs, proof);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
index ab74222c7001..2c1b2c9cb937 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
@@ -1,12 +1,14 @@
-add_executable(
-    grumpkin_srs_gen
-    grumpkin_srs_gen.cpp
-)
+if (!FUZZING)
+    add_executable(
+        grumpkin_srs_gen
+        grumpkin_srs_gen.cpp
+    )
 
-target_link_libraries(
-    grumpkin_srs_gen
-    PRIVATE
-    srs
-    ecc
-    crypto_sha256
-)
\ No newline at end of file
+    target_link_libraries(
+        grumpkin_srs_gen
+        PRIVATE
+        srs
+        ecc
+        crypto_sha256
+    )
+endif()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/grumpkin_srs_gen.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/grumpkin_srs_gen.cpp
index 4f5ac394431d..a04606b383ae 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/grumpkin_srs_gen.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/grumpkin_srs_gen.cpp
@@ -11,7 +11,9 @@ const std::string protocol_name = "BARRETENBERG_GRUMPKIN_IPA_CRS";
 /**
  * @brief Generates a monomial basis Grumpkin SRS.
  *
- * @details We only provide functionality create a single transcript file.
+ * @details We only provide functionality to create a single transcript file.
+ * ! Note that, unlike the bn254 SRS, the first element of the Grumpkin SRS will not be equal to point one defined in
+ * grumpkin.hpp as this function finds Grumpkin points in an arbitrary order.
  *
  */
 int main(int argc, char** argv)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
index 7119fb86b695..8bf37eae502f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
@@ -26,7 +26,7 @@ template <StandardFlavor Flavor> class StandardComposer_ {
     std::shared_ptr<VerificationKey> verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<srs::factories::CrsFactory> crs_factory_;
+    std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory_;
 
     // The commitment key is passed to the prover but also used herein to compute the verfication key commitments
     std::shared_ptr<PCSCommitmentKey> commitment_key;
@@ -37,15 +37,22 @@ template <StandardFlavor Flavor> class StandardComposer_ {
 
     bool computed_witness = false;
     // TODO(Luke): use make_shared
+    // TODO(#637): design the crs factory better
     StandardComposer_()
-        : StandardComposer_(
-              std::shared_ptr<srs::factories::CrsFactory>(new srs::factories::FileCrsFactory("../srs_db/ignition")))
-    {}
-    StandardComposer_(std::shared_ptr<srs::factories::CrsFactory> crs_factory)
+    {
+        if constexpr (IsGrumpkinFlavor<Flavor>) {
+            crs_factory_ = barretenberg::srs::get_grumpkin_crs_factory();
+
+        } else {
+            crs_factory_ = barretenberg::srs::get_crs_factory();
+        }
+    }
+
+    StandardComposer_(std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
 
-    StandardComposer_(std::unique_ptr<srs::factories::CrsFactory>&& crs_factory)
+    StandardComposer_(std::unique_ptr<srs::factories::CrsFactory<typename Flavor::Curve>>&& crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
     StandardComposer_(std::shared_ptr<ProvingKey> p_key, std::shared_ptr<VerificationKey> v_key)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
index 3f3043d09dd8..21872ce863fd 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
@@ -15,13 +15,30 @@
 
 using namespace proof_system::honk;
 
+#define TYPE_ALIASES                                                                                                   \
+    using Flavor = TypeParam;                                                                                          \
+    using FF = typename Flavor::FF;                                                                                    \
+    using CircuitBuilder = StandardCircuitBuilder_<FF>;                                                                \
+    using Composer = StandardComposer_<Flavor>;
+
 namespace test_standard_honk_composer {
 
-class StandardHonkComposerTests : public ::testing::Test {
+template <typename Flavor> class StandardHonkComposerTests : public ::testing::Test {
   protected:
-    static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); }
+    // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test.
+    virtual void SetUp()
+    {
+        if constexpr (IsGrumpkinFlavor<Flavor>) {
+            barretenberg::srs::init_grumpkin_crs_factory("../srs_db/grumpkin");
+        } else {
+            barretenberg::srs::init_crs_factory("../srs_db/ignition");
+        }
+    };
 };
 
+using FlavorTypes = ::testing::Types<flavor::Standard, flavor::StandardGrumpkin>;
+TYPED_TEST_SUITE(StandardHonkComposerTests, FlavorTypes);
+
 /**
  * @brief The goal of this test is to check that the sigma permutation vectors for honk are generated correctly.
  *
@@ -30,9 +47,10 @@ class StandardHonkComposerTests : public ::testing::Test {
  * 2) That if the permutation argument is computed with witness values, the values from the identity permutation and
  * sigma permutation are equal
  */
-TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
+TYPED_TEST(StandardHonkComposerTests, SigmaIDCorrectness)
 {
-    auto test_permutation = [](StandardCircuitBuilder& circuit_constructor, StandardComposer& composer) {
+    TYPE_ALIASES
+    auto test_permutation = [](CircuitBuilder& circuit_constructor, Composer& composer) {
         auto prover = composer.create_prover(circuit_constructor);
         auto proving_key = prover.key;
 
@@ -43,11 +61,11 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
         auto num_gates = circuit_constructor.get_num_gates();
 
         // Using the same random beta and gamma as in the permutation argument
-        barretenberg::fr beta = barretenberg::fr::random_element();
-        barretenberg::fr gamma = barretenberg::fr::random_element();
+        FF beta = FF::random_element();
+        FF gamma = FF::random_element();
 
-        barretenberg::fr left = barretenberg::fr::one();
-        barretenberg::fr right = barretenberg::fr::one();
+        FF left = FF::one();
+        FF right = FF::one();
 
         // Let's check that indices are the same and nothing is lost, first
         size_t wire_idx = 0;
@@ -60,7 +78,7 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
             // and fix the cycle by adding the extra terms
             if (wire_idx == 0) {
                 for (size_t i = 0; i < num_public_inputs; ++i) {
-                    EXPECT_EQ(sigma_polynomial[i], -fr(i + 1));
+                    EXPECT_EQ(sigma_polynomial[i], -FF(i + 1));
                     left *= (gamma - (i + 1));
                     right *= (gamma + (n + i));
                 }
@@ -70,13 +88,13 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
 
         EXPECT_EQ(left, right);
 
-        left = barretenberg::fr::one();
-        right = barretenberg::fr::one();
+        left = FF::one();
+        right = FF::one();
 
         auto permutation_polynomials = proving_key->get_sigma_polynomials();
         auto id_polynomials = proving_key->get_id_polynomials();
         auto wire_polynomials = proving_key->get_wires();
-        for (size_t j = 0; j < StandardComposer::NUM_WIRES; ++j) {
+        for (size_t j = 0; j < Composer::NUM_WIRES; ++j) {
             std::string index = std::to_string(j + 1);
             const auto& permutation_polynomial = permutation_polynomials[j];
             const auto& witness_polynomial = wire_polynomials[j];
@@ -103,7 +121,7 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
         }
 
         // test correctness of the public input delta
-        auto delta = proof_system::honk::compute_public_input_delta<flavor::Standard>(public_inputs, beta, gamma, n);
+        auto delta = proof_system::honk::compute_public_input_delta<Flavor>(public_inputs, beta, gamma, n);
         EXPECT_EQ(left / right, delta);
 
         for (size_t i = 0; i < num_public_inputs; ++i) {
@@ -113,29 +131,29 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
         EXPECT_EQ(left, right);
     };
 
-    auto circuit_constructor = StandardCircuitBuilder();
-    fr a = fr::one();
+    auto circuit_constructor = CircuitBuilder();
+    FF a = FF::one();
     uint32_t a_idx = circuit_constructor.add_variable(a);
-    fr b = fr::one();
-    fr c = a + b;
+    FF b = FF::one();
+    FF c = a + b;
     uint32_t b_idx = circuit_constructor.add_variable(b);
     uint32_t c_idx = circuit_constructor.add_variable(c);
-    fr d = a + c;
+    FF d = a + c;
     uint32_t d_idx = circuit_constructor.add_public_variable(d);
 
     uint32_t e_idx = circuit_constructor.put_constant_variable(d);
     circuit_constructor.assert_equal(e_idx, d_idx, "");
 
-    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
-    circuit_constructor.create_add_gate({ d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
-    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
-    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
-    circuit_constructor.create_add_gate({ b_idx, a_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
+    circuit_constructor.create_add_gate({ d_idx, c_idx, a_idx, FF::one(), FF::neg_one(), FF::neg_one(), FF::zero() });
+    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
+    circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
+    circuit_constructor.create_add_gate({ b_idx, a_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
     for (size_t i = 0; i < 30; ++i) {
-        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
     }
 
-    auto composer = StandardComposer();
+    auto composer = Composer();
     test_permutation(circuit_constructor, composer);
 }
 
@@ -143,38 +161,40 @@ TEST_F(StandardHonkComposerTests, SigmaIDCorrectness)
  * @brief Check the correctness of lagrange polynomials generated during proving key computation
  *
  */
-TEST_F(StandardHonkComposerTests, LagrangeCorrectness)
+TYPED_TEST(StandardHonkComposerTests, LagrangeCorrectness)
 {
+    TYPE_ALIASES
+    using Polynomial = typename Flavor::Polynomial;
     // Create a dummy circuit with a few gates
-    auto circuit_constructor = StandardCircuitBuilder();
-    fr a = fr::one();
+    auto circuit_constructor = CircuitBuilder();
+    FF a = FF::one();
     uint32_t a_idx = circuit_constructor.add_variable(a);
-    fr b = fr::one();
-    fr c = a + b;
-    fr d = a + c;
+    FF b = FF::one();
+    FF c = a + b;
+    FF d = a + c;
     uint32_t b_idx = circuit_constructor.add_variable(b);
     uint32_t c_idx = circuit_constructor.add_variable(c);
     uint32_t d_idx = circuit_constructor.add_variable(d);
     for (size_t i = 0; i < 16; i++) {
-        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
         circuit_constructor.create_add_gate(
-            { d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+            { d_idx, c_idx, a_idx, FF::one(), FF::neg_one(), FF::neg_one(), FF::zero() });
     }
 
     // Generate proving key
-    auto composer = StandardComposer();
+    auto composer = Composer();
     auto prover = composer.create_prover(circuit_constructor);
     auto proving_key = prover.key;
 
     // Generate a random polynomial
-    barretenberg::polynomial random_polynomial = barretenberg::polynomial(proving_key->circuit_size);
+    Polynomial random_polynomial = Polynomial(proving_key->circuit_size);
     for (size_t i = 0; i < proving_key->circuit_size; i++) {
-        random_polynomial[i] = barretenberg::fr::random_element();
+        random_polynomial[i] = FF::random_element();
     }
     // Compute inner product of random polynomial and the first lagrange polynomial
 
-    barretenberg::polynomial first_lagrange_polynomial = proving_key->lagrange_first;
-    barretenberg::fr first_product(0);
+    Polynomial first_lagrange_polynomial = proving_key->lagrange_first;
+    FF first_product(0);
     for (size_t i = 0; i < proving_key->circuit_size; i++) {
         first_product += random_polynomial[i] * first_lagrange_polynomial[i];
     }
@@ -182,7 +202,7 @@ TEST_F(StandardHonkComposerTests, LagrangeCorrectness)
 
     // Compute inner product of random polynomial and the last lagrange polynomial
     auto last_lagrange_polynomial = proving_key->lagrange_last;
-    barretenberg::fr last_product(0);
+    FF last_product(0);
     for (size_t i = 0; i < proving_key->circuit_size; i++) {
         last_product += random_polynomial[i] * last_lagrange_polynomial[i];
     }
@@ -197,26 +217,27 @@ TEST_F(StandardHonkComposerTests, LagrangeCorrectness)
  * merged.
  * In this test we create two almost identical circuits. They differ because one
  */
-TEST_F(StandardHonkComposerTests, AssertEquals)
+TYPED_TEST(StandardHonkComposerTests, AssertEquals)
 {
+    TYPE_ALIASES
 
     /**
      * @brief A function that creates a simple circuit with repeated gates, leading to large permutation cycles
      *
      */
     auto create_simple_circuit = [](auto& circuit_constructor) {
-        fr a = fr::one();
+        FF a = FF::one();
         uint32_t a_idx = circuit_constructor.add_variable(a);
-        fr b = fr::one();
-        fr c = a + b;
+        FF b = FF::one();
+        FF c = a + b;
         uint32_t b_idx = circuit_constructor.add_variable(b);
         uint32_t c_idx = circuit_constructor.add_variable(c);
 
         for (size_t i = 0; i < 10; i++) {
             circuit_constructor.create_add_gate(
-                { a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+                { a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
             circuit_constructor.create_add_gate(
-                { b_idx, a_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+                { b_idx, a_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
         }
         return std::make_tuple(a_idx, b_idx);
     };
@@ -256,7 +277,8 @@ TEST_F(StandardHonkComposerTests, AssertEquals)
             size_t cycle_length = 1;
             visited_indices[i] = true;
 
-            // Jump through the cycle untill we reach the start or the permutation length exceeds the possible maximum
+            // Jump through the cycle untill we reach the start or the permutation length exceeds the possible
+            // maximum
             while ((next_element != starting_element) && cycle_length < (permutation_length + 1)) {
                 // Update cycle length and visited index infromation
                 cycle_length++;
@@ -280,8 +302,8 @@ TEST_F(StandardHonkComposerTests, AssertEquals)
     };
 
     // Get 2 circuits
-    auto circuit_constructor_no_assert_equal = StandardCircuitBuilder();
-    auto circuit_constructor_with_assert_equal = StandardCircuitBuilder();
+    auto circuit_constructor_no_assert_equal = CircuitBuilder();
+    auto circuit_constructor_with_assert_equal = CircuitBuilder();
 
     // Construct circuits
     create_simple_circuit(circuit_constructor_no_assert_equal);
@@ -293,47 +315,49 @@ TEST_F(StandardHonkComposerTests, AssertEquals)
                                                        "Equality asssertion in standard honk composer test");
 
     // Check that the maximum cycle in the one, where we used assert_equal, is twice as long
-    auto composer_no_assert_equal = StandardComposer();
-    auto composer_with_assert_equal = StandardComposer();
+    auto composer_no_assert_equal = Composer();
+    auto composer_with_assert_equal = Composer();
     EXPECT_EQ(get_maximum_cycle(circuit_constructor_with_assert_equal, composer_with_assert_equal),
               get_maximum_cycle(circuit_constructor_no_assert_equal, composer_no_assert_equal) * 2);
 }
 
-TEST_F(StandardHonkComposerTests, VerificationKeyCreation)
+TYPED_TEST(StandardHonkComposerTests, VerificationKeyCreation)
 {
+    TYPE_ALIASES
 
     // Create a composer and a dummy circuit with a few gates
-    auto circuit_constructor = StandardCircuitBuilder();
-    fr a = fr::one();
+    auto circuit_constructor = CircuitBuilder();
+    FF a = FF::one();
     uint32_t a_idx = circuit_constructor.add_variable(a);
-    fr b = fr::one();
-    fr c = a + b;
-    fr d = a + c;
+    FF b = FF::one();
+    FF c = a + b;
+    FF d = a + c;
     uint32_t b_idx = circuit_constructor.add_variable(b);
     uint32_t c_idx = circuit_constructor.add_variable(c);
     uint32_t d_idx = circuit_constructor.add_variable(d);
     for (size_t i = 0; i < 16; i++) {
-        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+        circuit_constructor.create_add_gate({ a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
         circuit_constructor.create_add_gate(
-            { d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+            { d_idx, c_idx, a_idx, FF::one(), FF::neg_one(), FF::neg_one(), FF::zero() });
     }
 
-    auto composer = StandardComposer();
+    auto composer = Composer();
     composer.create_prover(circuit_constructor);
     auto verification_key = composer.compute_verification_key(circuit_constructor);
-    // There is nothing we can really check apart from the fact that constraint selectors and permutation selectors were
-    // committed to, we simply check that the verification key now contains the appropriate number of constraint and
-    // permutation selector commitments. This method should work with any future arithemtization.
+    // There is nothing we can really check apart from the fact that constraint selectors and permutation selectors
+    // were committed to, we simply check that the verification key now contains the appropriate number of
+    // constraint and permutation selector commitments. This method should work with any future arithemtization.
     EXPECT_EQ(verification_key->size(), circuit_constructor.selectors.size() + composer.NUM_WIRES * 2 + 2);
 }
 
-TEST_F(StandardHonkComposerTests, BaseCase)
+TYPED_TEST(StandardHonkComposerTests, BaseCase)
 {
-    auto circuit_constructor = StandardCircuitBuilder();
-    fr a = 1;
+    TYPE_ALIASES
+    auto circuit_constructor = CircuitBuilder();
+    FF a = 1;
     circuit_constructor.add_variable(a);
 
-    auto composer = StandardComposer();
+    auto composer = Composer();
     auto prover = composer.create_prover(circuit_constructor);
     auto proof = prover.construct_proof();
     auto verifier = composer.create_verifier(circuit_constructor);
@@ -341,10 +365,11 @@ TEST_F(StandardHonkComposerTests, BaseCase)
     ASSERT_TRUE(verified);
 }
 
-TEST_F(StandardHonkComposerTests, TwoGates)
+TYPED_TEST(StandardHonkComposerTests, TwoGates)
 {
+    TYPE_ALIASES
     auto run_test = [](bool expect_verified) {
-        auto circuit_constructor = StandardCircuitBuilder();
+        auto circuit_constructor = CircuitBuilder();
         // 1 + 1 - 2 = 0
         uint32_t w_l_1_idx;
         if (expect_verified) {
@@ -362,7 +387,7 @@ TEST_F(StandardHonkComposerTests, TwoGates)
         uint32_t w_o_2_idx = circuit_constructor.add_variable(4);
         circuit_constructor.create_mul_gate({ w_l_2_idx, w_r_2_idx, w_o_2_idx, 1, -1, 0 });
 
-        auto composer = StandardComposer();
+        auto composer = Composer();
         auto prover = composer.create_prover(circuit_constructor);
         auto proof = prover.construct_proof();
 
@@ -376,16 +401,17 @@ TEST_F(StandardHonkComposerTests, TwoGates)
     run_test(/* expect_verified=*/false);
 }
 
-TEST_F(StandardHonkComposerTests, SumcheckEvaluations)
+TYPED_TEST(StandardHonkComposerTests, SumcheckEvaluations)
 {
+    TYPE_ALIASES
     auto run_test = [](bool expected_result) {
-        auto circuit_constructor = StandardCircuitBuilder();
-        fr a = fr::one();
+        auto circuit_constructor = CircuitBuilder();
+        FF a = FF::one();
         // Construct a small but non-trivial circuit
         uint32_t a_idx = circuit_constructor.add_public_variable(a);
-        fr b = fr::one();
-        fr c = a + b;
-        fr d = a + c;
+        FF b = FF::one();
+        FF c = a + b;
+        FF d = a + c;
 
         if (expected_result == false) {
             d += 1;
@@ -396,12 +422,12 @@ TEST_F(StandardHonkComposerTests, SumcheckEvaluations)
         uint32_t d_idx = circuit_constructor.add_variable(d);
         for (size_t i = 0; i < 16; i++) {
             circuit_constructor.create_add_gate(
-                { a_idx, b_idx, c_idx, fr::one(), fr::one(), fr::neg_one(), fr::zero() });
+                { a_idx, b_idx, c_idx, FF::one(), FF::one(), FF::neg_one(), FF::zero() });
             circuit_constructor.create_add_gate(
-                { d_idx, c_idx, a_idx, fr::one(), fr::neg_one(), fr::neg_one(), fr::zero() });
+                { d_idx, c_idx, a_idx, FF::one(), FF::neg_one(), FF::neg_one(), FF::zero() });
         }
 
-        auto composer = StandardComposer();
+        auto composer = Composer();
         auto prover = composer.create_prover(circuit_constructor);
         auto proof = prover.construct_proof();
         auto verifier = composer.create_verifier(circuit_constructor);
@@ -411,17 +437,4 @@ TEST_F(StandardHonkComposerTests, SumcheckEvaluations)
     run_test(/*expected_result=*/true);
     run_test(/*expected_result=*/false);
 }
-TEST(StandardGrumpkinHonkComposer, BaseCase)
-{
-    auto circuit_constructor = StandardCircuitBuilder();
-    fr a = 1;
-    circuit_constructor.add_variable(a);
-
-    auto composer = StandardGrumpkinComposer();
-    auto prover = composer.create_prover(circuit_constructor);
-    auto proof = prover.construct_proof();
-    auto verifier = composer.create_verifier(circuit_constructor);
-    bool verified = verifier.verify_proof(proof);
-    ASSERT_TRUE(verified);
-}
 } // namespace test_standard_honk_composer
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.hpp
index c58cffec6ff7..dd1c9542828c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.hpp
@@ -31,7 +31,7 @@ template <UltraFlavor Flavor> class UltraComposer_ {
     std::shared_ptr<VerificationKey> verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<srs::factories::CrsFactory> crs_factory_;
+    std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory_;
 
     // The commitment key is passed to the prover but also used herein to compute the verfication key commitments
     std::shared_ptr<PCSCommitmentKey> commitment_key;
@@ -46,10 +46,9 @@ template <UltraFlavor Flavor> class UltraComposer_ {
     size_t num_public_inputs = 0;
     size_t num_ecc_op_gates = 0;
 
-    UltraComposer_()
-        : crs_factory_(barretenberg::srs::get_crs_factory()){};
+    UltraComposer_() { crs_factory_ = barretenberg::srs::get_crs_factory(); }
 
-    explicit UltraComposer_(std::shared_ptr<srs::factories::CrsFactory> crs_factory)
+    explicit UltraComposer_(std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
 
@@ -84,6 +83,8 @@ template <UltraFlavor Flavor> class UltraComposer_ {
     };
 };
 extern template class UltraComposer_<honk::flavor::Ultra>;
+// TODO: the UltraGrumpkin flavor still works on BN254 because plookup needs to be templated to be able to construct
+// Grumpkin circuits.
 extern template class UltraComposer_<honk::flavor::UltraGrumpkin>;
 extern template class UltraComposer_<honk::flavor::GoblinUltra>;
 // TODO(#532): this pattern is weird; is this not instantiating the templates?
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
index 776711387227..9cc1b3b088fe 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
@@ -274,8 +274,7 @@ TEST_F(UltraHonkComposerTests, test_elliptic_gate)
     uint32_t x3 = circuit_constructor.add_variable(p3.x);
     uint32_t y3 = circuit_constructor.add_variable(p3.y);
 
-    ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, 1, 1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, 1, 1 });
 
     grumpkin::fq beta = grumpkin::fq::cube_root_of_unity();
     affine_element p2_endo = p2;
@@ -283,15 +282,13 @@ TEST_F(UltraHonkComposerTests, test_elliptic_gate)
     p3 = affine_element(element(p1) + element(p2_endo));
     x3 = circuit_constructor.add_variable(p3.x);
     y3 = circuit_constructor.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta, 1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta, 1 });
 
     p2_endo.x *= beta;
     p3 = affine_element(element(p1) - element(p2_endo));
     x3 = circuit_constructor.add_variable(p3.x);
     y3 = circuit_constructor.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 });
 
     auto composer = UltraComposer();
     prove_and_verify(circuit_constructor, composer, /*expected_result=*/true);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
index b46613675d6b..8036f0541589 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
@@ -29,15 +29,15 @@ namespace proof_system::honk::flavor {
 class GoblinUltra {
   public:
     using CircuitBuilder = UltraCircuitBuilder;
-    using FF = barretenberg::fr;
-    using Polynomial = barretenberg::Polynomial<FF>;
-    using PolynomialHandle = std::span<FF>;
-    using G1 = barretenberg::g1;
-    using GroupElement = G1::element;
-    using Commitment = G1::affine_element;
-    using CommitmentHandle = G1::affine_element;
     using PCSParams = pcs::kzg::Params;
     using PCS = pcs::kzg::KZG<PCSParams>;
+    using Curve = PCSParams::Curve;
+    using GroupElement = Curve::Element;
+    using Commitment = Curve::AffineElement;
+    using CommitmentHandle = Curve::AffineElement;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
+    using PolynomialHandle = std::span<FF>;
 
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
index 9fc599cf051a..d7e5411603f4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
@@ -32,15 +32,15 @@ namespace proof_system::honk::flavor {
 class Standard {
   public:
     using CircuitBuilder = StandardCircuitBuilder;
-    using FF = barretenberg::fr;
-    using Polynomial = barretenberg::Polynomial<FF>;
-    using PolynomialHandle = std::span<FF>;
-    using G1 = barretenberg::g1;
-    using GroupElement = G1::element;
-    using Commitment = G1::affine_element;
-    using CommitmentHandle = G1::affine_element;
     using PCSParams = pcs::kzg::Params;
     using PCS = pcs::kzg::KZG<PCSParams>;
+    using Curve = PCSParams::Curve;
+    using GroupElement = Curve::Element;
+    using Commitment = Curve::AffineElement;
+    using CommitmentHandle = Curve::AffineElement;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
+    using PolynomialHandle = std::span<FF>;
 
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
index 9a7ecc19df0a..400e49bb55c6 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
@@ -23,16 +23,16 @@ class StandardGrumpkin {
     // TODO(Mara): At the moment this class is a duplicate of the Standard flavor with a different PCS for testing
     // purposes. This will be changed to Grumpkin once generating Honk proofs over Grumpkin has been enabled.
   public:
-    using CircuitBuilder = StandardCircuitBuilder;
-    using FF = barretenberg::fr;
-    using Polynomial = barretenberg::Polynomial<FF>;
-    using PolynomialHandle = std::span<FF>;
-    using G1 = barretenberg::g1;
-    using GroupElement = G1::element;
-    using Commitment = G1::affine_element;
-    using CommitmentHandle = G1::affine_element;
+    using CircuitBuilder = StandardGrumpkinCircuitBuilder;
     using PCSParams = pcs::ipa::Params;
     using PCS = pcs::ipa::IPA<PCSParams>;
+    using Curve = PCSParams::Curve;
+    using GroupElement = Curve::Element;
+    using Commitment = Curve::AffineElement;
+    using CommitmentHandle = Curve::AffineElement;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
+    using PolynomialHandle = std::span<FF>;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
     // need containers of this size to hold related data, so we choose a name more agnostic than `NUM_POLYNOMIALS`
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
index 7691c8a666b9..a87550f8146f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
@@ -28,18 +28,15 @@ namespace proof_system::honk::flavor {
 class Ultra {
   public:
     using CircuitBuilder = UltraCircuitBuilder;
-    using FF = barretenberg::fr;
-    using Polynomial = barretenberg::Polynomial<FF>;
-    using PolynomialHandle = std::span<FF>;
-    using G1 = barretenberg::g1;
-    using GroupElement = G1::element;
-    using Commitment = G1::affine_element;
-    using CommitmentHandle = G1::affine_element;
-    // UltraHonk will be run with KZG by default but temporarily we set the commitment to IPA to
-    // be able to do e2e tests with this pcs as well
-    // TODO: instantiate this with both IPA and KZG when the templating work is finished
     using PCSParams = pcs::kzg::Params;
     using PCS = pcs::kzg::KZG<PCSParams>;
+    using Curve = PCSParams::Curve;
+    using GroupElement = Curve::Element;
+    using Commitment = Curve::AffineElement;
+    using CommitmentHandle = Curve::AffineElement;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
+    using PolynomialHandle = std::span<FF>;
 
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
index 3ac884b4a5b1..c949a4cb3439 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
@@ -2,6 +2,7 @@
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/commitment_key.hpp"
 #include "barretenberg/honk/pcs/ipa/ipa.hpp"
+#include "barretenberg/honk/pcs/kzg/kzg.hpp"
 #include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
 #include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
 #include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
@@ -25,19 +26,19 @@
 namespace proof_system::honk::flavor {
 
 class UltraGrumpkin {
-    // TODO(Mara): At the moment this class is a duplicate of the Standard flavor with a different PCS for testing
-    // purposes. This will be changed to Grumpkin once generating Honk proofs over Grumpkin has been enabled.
+    // TODO(#636): At the moment this class is a duplicate of the Ultra flavor with a different PCS for testing
+    // purposes. This can be changed to Grumpkin and IPA once UltraCircuitBuilder also works on Grumpkin.
   public:
     using CircuitBuilder = UltraCircuitBuilder;
-    using FF = barretenberg::fr;
+    using PCSParams = pcs::kzg::Params;
+    using PCS = pcs::kzg::KZG<PCSParams>;
+    using Curve = PCSParams::Curve;
+    using GroupElement = Curve::Element;
+    using Commitment = Curve::AffineElement;
+    using CommitmentHandle = Curve::AffineElement;
+    using FF = Curve::ScalarField;
     using Polynomial = barretenberg::Polynomial<FF>;
     using PolynomialHandle = std::span<FF>;
-    using G1 = barretenberg::g1;
-    using GroupElement = G1::element;
-    using Commitment = G1::affine_element;
-    using CommitmentHandle = G1::affine_element;
-    using PCSParams = pcs::ipa::Params;
-    using PCS = pcs::ipa::IPA<PCSParams>;
 
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // The number of multivariate polynomials on which a sumcheck prover sumcheck operates (including shifts). We often
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.hpp
index e1856554bdcd..02046f1c98d4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.hpp
@@ -9,6 +9,7 @@
 
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/bn254/pairing.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/ecc/scalar_multiplication/scalar_multiplication.hpp"
 #include "barretenberg/numeric/bitop/pow.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
@@ -25,9 +26,10 @@ namespace proof_system::honk::pcs {
 namespace kzg {
 
 struct Params {
-    using Fr = typename barretenberg::g1::Fr;
-    using Commitment = typename barretenberg::g1::affine_element;
-    using GroupElement = barretenberg::g1::element;
+    using Curve = curve::BN254;
+    using Fr = typename Curve::ScalarField;
+    using Commitment = typename Curve::AffineElement;
+    using GroupElement = typename Curve::Element;
 
     using Polynomial = barretenberg::Polynomial<Fr>;
 
@@ -52,7 +54,8 @@ struct Params {
          * @param path
          *
          */
-        CommitmentKey(const size_t num_points, std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+        CommitmentKey(const size_t num_points,
+                      std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
             : pippenger_runtime_state(num_points)
             , srs(crs_factory->get_prover_crs(num_points))
         {}
@@ -60,9 +63,9 @@ struct Params {
         // Note: This constructor is used only by Plonk; For Honk the CommitmentKey is solely responsible for extracting
         // the srs.
         CommitmentKey(const size_t num_points,
-                      std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> prover_srs)
+                      std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> prover_crs)
             : pippenger_runtime_state(num_points)
-            , srs(prover_srs)
+            , srs(prover_crs)
         {}
 
         /**
@@ -75,12 +78,12 @@ struct Params {
         {
             const size_t degree = polynomial.size();
             ASSERT(degree <= srs->get_monomial_size());
-            return barretenberg::scalar_multiplication::pippenger_unsafe<curve::BN254>(
+            return barretenberg::scalar_multiplication::pippenger_unsafe<Curve>(
                 const_cast<Fr*>(polynomial.data()), srs->get_monomial_points(), degree, pippenger_runtime_state);
         };
 
-        barretenberg::scalar_multiplication::pippenger_runtime_state<curve::BN254> pippenger_runtime_state;
-        std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> srs;
+        barretenberg::scalar_multiplication::pippenger_runtime_state<Curve> pippenger_runtime_state;
+        std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> srs;
     };
 
     class VerificationKey {
@@ -92,11 +95,11 @@ struct Params {
          * @brief Construct a new Kate Verification Key object from existing SRS
          *
          * @param num_points
-         * @param verifier_srs verifier G2 point
+         * @paramsrs verifier G2 point
          */
         VerificationKey([[maybe_unused]] size_t num_points,
-                        std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
-            : verifier_srs(crs_factory->get_verifier_crs())
+                        std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
+            : srs(crs_factory->get_verifier_crs())
         {}
 
         /**
@@ -110,14 +113,13 @@ struct Params {
         {
             Commitment pairing_points[2]{ p0, p1 };
             // The final pairing check of step 12.
-            // TODO(Adrian): try to template parametrise the pairing + fq12 output :/
-            barretenberg::fq12 result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
-                pairing_points, verifier_srs->get_precomputed_g2_lines(), 2);
+            Curve::TargetField result = barretenberg::pairing::reduced_ate_pairing_batch_precomputed(
+                pairing_points, srs->get_precomputed_g2_lines(), 2);
 
-            return (result == barretenberg::fq12::one());
+            return (result == Curve::TargetField::one());
         }
 
-        std::shared_ptr<barretenberg::srs::factories::VerifierCrs> verifier_srs;
+        std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> srs;
     };
 };
 
@@ -186,9 +188,10 @@ template <typename G> struct Params {
 namespace ipa {
 
 struct Params {
-    using Fr = typename barretenberg::g1::Fr;
-    using Commitment = typename barretenberg::g1::affine_element;
-    using GroupElement = barretenberg::g1::element;
+    using Curve = curve::Grumpkin;
+    using Fr = typename Curve::ScalarField;
+    using Commitment = typename Curve::AffineElement;
+    using GroupElement = typename Curve::Element;
 
     using Polynomial = barretenberg::Polynomial<Fr>;
 
@@ -207,7 +210,8 @@ struct Params {
          * @param path
          *
          */
-        CommitmentKey(const size_t num_points, std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+        CommitmentKey(const size_t num_points,
+                      std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
             : pippenger_runtime_state(num_points)
             , srs(crs_factory->get_prover_crs(num_points))
         {}
@@ -222,12 +226,12 @@ struct Params {
         {
             const size_t degree = polynomial.size();
             ASSERT(degree <= srs->get_monomial_size());
-            return barretenberg::scalar_multiplication::pippenger_unsafe<curve::BN254>(
+            return barretenberg::scalar_multiplication::pippenger_unsafe<Curve>(
                 const_cast<Fr*>(polynomial.data()), srs->get_monomial_points(), degree, pippenger_runtime_state);
         };
 
-        barretenberg::scalar_multiplication::pippenger_runtime_state<curve::BN254> pippenger_runtime_state;
-        std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> srs;
+        barretenberg::scalar_multiplication::pippenger_runtime_state<Curve> pippenger_runtime_state;
+        std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> srs;
     };
 
     class VerificationKey {
@@ -241,13 +245,14 @@ struct Params {
          * @param num_points specifies the length of the SRS
          * @param path is the location to the SRS file
          */
-        VerificationKey(size_t num_points, std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+        VerificationKey(size_t num_points, std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
             : pippenger_runtime_state(num_points)
-            , srs(crs_factory->get_prover_crs(num_points))
+            , srs(crs_factory->get_verifier_crs(num_points))
+
         {}
 
-        barretenberg::scalar_multiplication::pippenger_runtime_state<curve::BN254> pippenger_runtime_state;
-        std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> srs;
+        barretenberg::scalar_multiplication::pippenger_runtime_state<Curve> pippenger_runtime_state;
+        std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> srs;
     };
 };
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.test.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.test.hpp
index a833187b588d..4f27faff9d6d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.test.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/commitment_key.test.hpp
@@ -23,17 +23,17 @@ template <class CK> inline std::shared_ptr<CK> CreateCommitmentKey();
 
 template <> inline std::shared_ptr<kzg::Params::CommitmentKey> CreateCommitmentKey<kzg::Params::CommitmentKey>()
 {
-    constexpr size_t n = 128;
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory(
-        new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition"));
+    constexpr size_t n = 4096;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<kzg::Params::Curve>> crs_factory(
+        new barretenberg::srs::factories::FileCrsFactory<kzg::Params::Curve>("../srs_db/ignition", 4096));
     return std::make_shared<kzg::Params::CommitmentKey>(n, crs_factory);
 }
 // For IPA
 template <> inline std::shared_ptr<ipa::Params::CommitmentKey> CreateCommitmentKey<ipa::Params::CommitmentKey>()
 {
-    constexpr size_t n = 128;
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory(
-        new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition"));
+    constexpr size_t n = 4096;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<ipa::Params::Curve>> crs_factory(
+        new barretenberg::srs::factories::FileCrsFactory<ipa::Params::Curve>("../srs_db/grumpkin", 4096));
     return std::make_shared<ipa::Params::CommitmentKey>(n, crs_factory);
 }
 
@@ -47,17 +47,17 @@ template <class VK> inline std::shared_ptr<VK> CreateVerificationKey();
 
 template <> inline std::shared_ptr<kzg::Params::VerificationKey> CreateVerificationKey<kzg::Params::VerificationKey>()
 {
-    constexpr size_t n = 128;
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory(
-        new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition"));
+    constexpr size_t n = 4096;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<kzg::Params::Curve>> crs_factory(
+        new barretenberg::srs::factories::FileCrsFactory<kzg::Params::Curve>("../srs_db/ignition", 4096));
     return std::make_shared<kzg::Params::VerificationKey>(n, crs_factory);
 }
 // For IPA
 template <> inline std::shared_ptr<ipa::Params::VerificationKey> CreateVerificationKey<ipa::Params::VerificationKey>()
 {
-    constexpr size_t n = 128;
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory(
-        new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition"));
+    constexpr size_t n = 4096;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<ipa::Params::Curve>> crs_factory(
+        new barretenberg::srs::factories::FileCrsFactory<ipa::Params::Curve>("../srs_db/grumpkin", 4096));
     return std::make_shared<ipa::Params::VerificationKey>(n, crs_factory);
 }
 template <typename VK> inline std::shared_ptr<VK> CreateVerificationKey()
@@ -72,7 +72,6 @@ template <typename Params> class CommitmentTest : public ::testing::Test {
     using Fr = typename Params::Fr;
     using Commitment = typename Params::Commitment;
     using Polynomial = typename Params::Polynomial;
-    using Transcript = transcript::StandardTranscript;
 
   public:
     CommitmentTest()
@@ -127,6 +126,7 @@ template <typename Params> class CommitmentTest : public ::testing::Test {
         Fr y_expected = witness.evaluate(x);
         EXPECT_EQ(y, y_expected) << "OpeningClaim: evaluations mismatch";
         Commitment commitment_expected = commit(witness);
+        // found it
         EXPECT_EQ(commitment, commitment_expected) << "OpeningClaim: commitment mismatch";
     }
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.test.cpp
index 69a28eb0324f..e5791a080490 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/gemini/gemini.test.cpp
@@ -100,7 +100,8 @@ template <class Params> class GeminiTest : public CommitmentTest<Params> {
     }
 };
 
-TYPED_TEST_SUITE(GeminiTest, CommitmentSchemeParams);
+using ParamsTypes = ::testing::Types<kzg::Params, ipa::Params>;
+TYPED_TEST_SUITE(GeminiTest, ParamsTypes);
 
 TYPED_TEST(GeminiTest, Single)
 {
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.hpp
index 25cc01431e3d..4bc02e0f4a2a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.hpp
@@ -15,8 +15,8 @@
  *
  */
 namespace proof_system::honk::pcs::ipa {
-
 template <typename Params> class IPA {
+    using Curve = typename Params::Curve;
     using Fr = typename Params::Fr;
     using GroupElement = typename Params::GroupElement;
     using Commitment = typename Params::Commitment;
@@ -86,15 +86,14 @@ template <typename Params> class IPA {
             // L_i = < a_vec_lo, G_vec_hi > + inner_prod_L * aux_generator
             L_elements[i] =
                 // TODO(#473)
-                barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<curve::BN254>(
+                barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
                     &a_vec[0], &G_vec_local[round_size], round_size, ck->pippenger_runtime_state);
             L_elements[i] += aux_generator * inner_prod_L;
 
             // R_i = < a_vec_hi, G_vec_lo > + inner_prod_R * aux_generator
             // TODO(#473)
-            R_elements[i] =
-                barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<curve::BN254>(
-                    &a_vec[round_size], &G_vec_local[0], round_size, ck->pippenger_runtime_state);
+            R_elements[i] = barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
+                &a_vec[round_size], &G_vec_local[0], round_size, ck->pippenger_runtime_state);
             R_elements[i] += aux_generator * inner_prod_R;
 
             std::string index = std::to_string(i);
@@ -168,9 +167,8 @@ template <typename Params> class IPA {
             msm_scalars[2 * i + 1] = round_challenges_inv[i].sqr();
         }
         // TODO(#473)
-        GroupElement LR_sums =
-            barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<curve::BN254>(
-                &msm_scalars[0], &msm_elements[0], pippenger_size, vk->pippenger_runtime_state);
+        GroupElement LR_sums = barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
+            &msm_scalars[0], &msm_elements[0], pippenger_size, vk->pippenger_runtime_state);
         GroupElement C_zero = C_prime + LR_sums;
 
         /**
@@ -213,7 +211,7 @@ template <typename Params> class IPA {
             G_vec_local[i >> 1] = srs_elements[i];
         }
         // TODO(#473)
-        auto G_zero = barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<curve::BN254>(
+        auto G_zero = barretenberg::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
             &s_vec[0], &G_vec_local[0], poly_degree, vk->pippenger_runtime_state);
 
         auto a_zero = transcript.template receive_from_prover<Fr>("IPA:a_0");
@@ -224,4 +222,4 @@ template <typename Params> class IPA {
     }
 };
 
-} // namespace proof_system::honk::pcs::ipa
+} // namespace proof_system::honk::pcs::ipa
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.test.cpp
index f5fb23df682d..2b5873743892 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/ipa/ipa.test.cpp
@@ -1,3 +1,5 @@
+#include "../gemini/gemini.hpp"
+#include "../shplonk/shplonk_single.hpp"
 #include "barretenberg/common/mem.hpp"
 #include "barretenberg/ecc/curves/bn254/fq12.hpp"
 #include "barretenberg/ecc/curves/types.hpp"
@@ -78,4 +80,95 @@ TEST_F(IPATest, Open)
 
     EXPECT_EQ(prover_transcript.get_manifest(), verifier_transcript.get_manifest());
 }
+
+TEST_F(IPATest, GeminiShplonkIPAWithShift)
+{
+    using IPA = IPA<Params>;
+    using Shplonk = shplonk::SingleBatchOpeningScheme<Params>;
+    using Gemini = gemini::MultilinearReductionScheme<Params>;
+
+    const size_t n = 8;
+    const size_t log_n = 3;
+
+    Fr rho = Fr::random_element();
+
+    // Generate multilinear polynomials, their commitments (genuine and mocked) and evaluations (genuine) at a random
+    // point.
+    const auto mle_opening_point = this->random_evaluation_point(log_n); // sometimes denoted 'u'
+    auto poly1 = this->random_polynomial(n);
+    auto poly2 = this->random_polynomial(n);
+    poly2[0] = Fr::zero(); // this property is required of polynomials whose shift is used
+
+    GroupElement commitment1 = this->commit(poly1);
+    GroupElement commitment2 = this->commit(poly2);
+
+    auto eval1 = poly1.evaluate_mle(mle_opening_point);
+    auto eval2 = poly2.evaluate_mle(mle_opening_point);
+    auto eval2_shift = poly2.evaluate_mle(mle_opening_point, true);
+
+    std::vector<Fr> multilinear_evaluations = { eval1, eval2, eval2_shift };
+
+    std::vector<Fr> rhos = Gemini::powers_of_rho(rho, multilinear_evaluations.size());
+
+    Fr batched_evaluation = Fr::zero();
+    for (size_t i = 0; i < rhos.size(); ++i) {
+        batched_evaluation += multilinear_evaluations[i] * rhos[i];
+    }
+
+    Polynomial batched_unshifted(n);
+    Polynomial batched_to_be_shifted(n);
+    batched_unshifted.add_scaled(poly1, rhos[0]);
+    batched_unshifted.add_scaled(poly2, rhos[1]);
+    batched_to_be_shifted.add_scaled(poly2, rhos[2]);
+
+    GroupElement batched_commitment_unshifted = GroupElement::zero();
+    GroupElement batched_commitment_to_be_shifted = GroupElement::zero();
+    batched_commitment_unshifted = commitment1 * rhos[0] + commitment2 * rhos[1];
+    batched_commitment_to_be_shifted = commitment2 * rhos[2];
+
+    auto prover_transcript = ProverTranscript<Fr>::init_empty();
+
+    auto fold_polynomials = Gemini::compute_fold_polynomials(
+        mle_opening_point, std::move(batched_unshifted), std::move(batched_to_be_shifted));
+
+    for (size_t l = 0; l < log_n - 1; ++l) {
+        std::string label = "FOLD_" + std::to_string(l + 1);
+        auto commitment = this->ck()->commit(fold_polynomials[l + 2]);
+        prover_transcript.send_to_verifier(label, commitment);
+    }
+
+    const Fr r_challenge = prover_transcript.get_challenge("Gemini:r");
+
+    const auto [gemini_opening_pairs, gemini_witnesses] =
+        Gemini::compute_fold_polynomial_evaluations(mle_opening_point, std::move(fold_polynomials), r_challenge);
+
+    for (size_t l = 0; l < log_n; ++l) {
+        std::string label = "Gemini:a_" + std::to_string(l);
+        const auto& evaluation = gemini_opening_pairs[l + 1].evaluation;
+        prover_transcript.send_to_verifier(label, evaluation);
+    }
+
+    const Fr nu_challenge = prover_transcript.get_challenge("Shplonk:nu");
+    auto batched_quotient_Q = Shplonk::compute_batched_quotient(gemini_opening_pairs, gemini_witnesses, nu_challenge);
+    prover_transcript.send_to_verifier("Shplonk:Q", this->ck()->commit(batched_quotient_Q));
+
+    const Fr z_challenge = prover_transcript.get_challenge("Shplonk:z");
+    const auto [shplonk_opening_pair, shplonk_witness] = Shplonk::compute_partially_evaluated_batched_quotient(
+        gemini_opening_pairs, gemini_witnesses, std::move(batched_quotient_Q), nu_challenge, z_challenge);
+
+    IPA::compute_opening_proof(this->ck(), shplonk_opening_pair, shplonk_witness, prover_transcript);
+
+    auto verifier_transcript = VerifierTranscript<Fr>::init_empty(prover_transcript);
+
+    auto gemini_verifier_claim = Gemini::reduce_verify(mle_opening_point,
+                                                       batched_evaluation,
+                                                       batched_commitment_unshifted,
+                                                       batched_commitment_to_be_shifted,
+                                                       verifier_transcript);
+
+    const auto shplonk_verifier_claim = Shplonk::reduce_verify(this->vk(), gemini_verifier_claim, verifier_transcript);
+    bool verified = IPA::verify(this->vk(), shplonk_verifier_claim, verifier_transcript);
+
+    EXPECT_EQ(verified, true);
+}
 } // namespace proof_system::honk::pcs::ipa
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/kzg/kzg.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/kzg/kzg.test.cpp
index 8c5dfe57a917..0659402ec774 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/kzg/kzg.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/kzg/kzg.test.cpp
@@ -163,7 +163,7 @@ TYPED_TEST(KZGTest, GeminiShplonkKzgWithShift)
                                                        verifier_transcript);
 
     // Shplonk verifier claim: commitment [Q] - [Q_z], opening point (z_challenge, 0)
-    const auto shplonk_verifier_claim = Shplonk::reduce_verify(gemini_verifier_claim, verifier_transcript);
+    const auto shplonk_verifier_claim = Shplonk::reduce_verify(this->vk(), gemini_verifier_claim, verifier_transcript);
 
     // KZG verifier:
     // aggregates inputs [Q] - [Q_z] and [W] into an 'accumulator' (can perform pairing check on result)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk.test.cpp
index 9763018e6a2b..6e171403a636 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk.test.cpp
@@ -13,7 +13,8 @@
 namespace proof_system::honk::pcs::shplonk {
 template <class Params> class ShplonkTest : public CommitmentTest<Params> {};
 
-TYPED_TEST_SUITE(ShplonkTest, CommitmentSchemeParams);
+using ParamsTypes = ::testing::Types<kzg::Params, ipa::Params>;
+TYPED_TEST_SUITE(ShplonkTest, ParamsTypes);
 
 // Test of Shplonk prover/verifier for two polynomials of different size, each opened at a single (different) point
 TYPED_TEST(ShplonkTest, ShplonkSimple)
@@ -64,7 +65,7 @@ TYPED_TEST(ShplonkTest, ShplonkSimple)
     auto verifier_transcript = VerifierTranscript<Fr>::init_empty(prover_transcript);
 
     // Execute the shplonk verifier functionality
-    const auto verifier_claim = Shplonk::reduce_verify(opening_claims, verifier_transcript);
+    const auto verifier_claim = Shplonk::reduce_verify(this->vk(), opening_claims, verifier_transcript);
 
     this->verify_opening_claim(verifier_claim, shplonk_prover_witness);
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk_single.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk_single.hpp
index 262362eef9ee..524c5d3bc2c0 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk_single.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/pcs/shplonk/shplonk_single.hpp
@@ -20,6 +20,7 @@ template <typename Params> class SingleBatchOpeningScheme {
     using GroupElement = typename Params::GroupElement;
     using Commitment = typename Params::Commitment;
     using Polynomial = barretenberg::Polynomial<Fr>;
+    using VK = typename Params::VerificationKey;
 
   public:
     /**
@@ -123,7 +124,8 @@ template <typename Params> class SingleBatchOpeningScheme {
      * @param transcript
      * @return OpeningClaim
      */
-    static OpeningClaim<Params> reduce_verify(std::span<const OpeningClaim<Params>> claims,
+    static OpeningClaim<Params> reduce_verify(std::shared_ptr<VK> vk,
+                                              std::span<const OpeningClaim<Params>> claims,
                                               VerifierTranscript<Fr>& transcript)
     {
         const size_t num_claims = claims.size();
@@ -169,7 +171,9 @@ template <typename Params> class SingleBatchOpeningScheme {
             current_nu *= nu;
         }
         // [G] += G₀⋅[1] = [G] + (∑ⱼ ρʲ ⋅ vⱼ / ( r − xⱼ ))⋅[1]
-        G_commitment += GroupElement::one() * G_commitment_constant;
+
+        //  GroupElement sort_of_one{ x, y };
+        G_commitment += vk->srs->get_first_g1() * G_commitment_constant;
 
         // Return opening pair (z, 0) and commitment [G]
         return { { z_challenge, Fr::zero() }, G_commitment };
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/composer_lib.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/composer_lib.hpp
index d62b223ccf5c..dca4f4851397 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/composer_lib.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/composer_lib.hpp
@@ -19,7 +19,7 @@ namespace proof_system::honk {
 template <typename Flavor>
 std::shared_ptr<typename Flavor::VerificationKey> compute_verification_key_common(
     std::shared_ptr<typename Flavor::ProvingKey> const& proving_key,
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& vrs)
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<typename Flavor::Curve>> const& vrs)
 {
     auto verification_key = std::make_shared<typename Flavor::VerificationKey>(
         proving_key->circuit_size, proving_key->num_public_inputs, vrs);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
index 7fbdcd932dd9..aea17570f63c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
@@ -165,7 +165,7 @@ template <typename Flavor> bool UltraVerifier_<Flavor>::verify_proof(const plonk
                                               transcript);
 
     // Produce a Shplonk claim: commitment [Q] - [Q_z], evaluation zero (at random challenge z)
-    auto shplonk_claim = Shplonk::reduce_verify(gemini_claim, transcript);
+    auto shplonk_claim = Shplonk::reduce_verify(pcs_verification_key, gemini_claim, transcript);
 
     // // Verify the Shplonk claim with KZG or IPA
     return PCS::verify(pcs_verification_key, shplonk_claim, transcript);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
index a109f02ca1e2..0e559c2b4691 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
@@ -160,7 +160,7 @@ template <typename Flavor> bool StandardVerifier_<Flavor>::verify_proof(const pl
                                               transcript);
 
     // Produce a Shplonk claim: commitment [Q] - [Q_z], evaluation zero (at random challenge z)
-    auto shplonk_claim = Shplonk::reduce_verify(gemini_claim, transcript);
+    auto shplonk_claim = Shplonk::reduce_verify(pcs_verification_key, gemini_claim, transcript);
 
     // Verify the Shplonk claim with KZG or IPA
     return PCS::verify(pcs_verification_key, shplonk_claim, transcript);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
index 09243e548166..f88bb12de1ee 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
@@ -185,8 +185,7 @@ template <typename Flavor> void create_some_elliptic_curve_addition_gates(auto&
     uint32_t x3 = circuit_builder.add_variable(p3.x);
     uint32_t y3 = circuit_builder.add_variable(p3.y);
 
-    ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, beta_scalar, -1 };
-    circuit_builder.create_ecc_add_gate(gate);
+    circuit_builder.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta_scalar, -1 });
 }
 
 template <typename Flavor> void create_some_ecc_op_queue_gates(auto& circuit_builder)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp
index a4842eef7c55..e66cc8f9800e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp
@@ -6,8 +6,10 @@
 #include "relation_parameters.hpp"
 
 namespace proof_system::honk::sumcheck {
-template <typename T>
-concept HasSubrelationLinearlyIndependentMember = requires(T) { T::Relation::SUBRELATION_LINEARLY_INDEPENDENT; };
+template <typename T> concept HasSubrelationLinearlyIndependentMember = requires(T)
+{
+    T::Relation::SUBRELATION_LINEARLY_INDEPENDENT;
+};
 /**
  * @brief The templates defined herein facilitate sharing the relation arithmetic between the prover and the verifier.
  *
@@ -34,9 +36,9 @@ concept HasSubrelationLinearlyIndependentMember = requires(T) { T::Relation::SUB
  * @return requires
  */
 template <typename FF, typename AccumulatorTypes, typename T>
-    requires std::is_same<std::span<FF>, T>::value
-inline typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorViews>::type get_view(const T& input,
-                                                                                                  const size_t index)
+requires std::is_same<std::span<FF>, T>::value inline
+    typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorViews>::type
+    get_view(const T& input, const size_t index)
 {
     return input[index];
 }
@@ -110,8 +112,8 @@ template <typename FF, template <typename> typename RelationBase> class Relation
      * @tparam size_t
      */
     template <size_t>
-    static constexpr bool is_subrelation_linearly_independent()
-        requires(!HasSubrelationLinearlyIndependentMember<Relation>)
+    static constexpr bool is_subrelation_linearly_independent() requires(
+        !HasSubrelationLinearlyIndependentMember<Relation>)
     {
         return true;
     }
@@ -122,8 +124,8 @@ template <typename FF, template <typename> typename RelationBase> class Relation
      * @tparam size_t
      */
     template <size_t subrelation_index>
-    static constexpr bool is_subrelation_linearly_independent()
-        requires(HasSubrelationLinearlyIndependentMember<Relation>)
+    static constexpr bool is_subrelation_linearly_independent() requires(
+        HasSubrelationLinearlyIndependentMember<Relation>)
     {
         return std::get<subrelation_index>(Relation::SUBRELATION_LINEARLY_INDEPENDENT);
     }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
index cb1670b710c0..0f1e95454ca6 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
@@ -570,8 +570,7 @@ TEST_F(SumcheckTests, RealCircuitUltra)
     uint32_t x3 = circuit_constructor.add_variable(p3.x);
     uint32_t y3 = circuit_constructor.add_variable(p3.y);
 
-    ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, beta_scalar, -1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta_scalar, -1 });
 
     // Add some RAM gates
     uint32_t ram_values[8]{
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
index 5324e21360ae..cee41dc00547 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
@@ -481,9 +481,8 @@ template <typename Flavor> class SumcheckRound {
     template <typename... T>
     static constexpr void add_tuples(std::tuple<T...>& tuple_1, const std::tuple<T...>& tuple_2)
     {
-        [&]<std::size_t... I>(std::index_sequence<I...>) {
-            ((std::get<I>(tuple_1) += std::get<I>(tuple_2)), ...);
-        }(std::make_index_sequence<sizeof...(T)>{});
+        [&]<std::size_t... I>(std::index_sequence<I...>) { ((std::get<I>(tuple_1) += std::get<I>(tuple_2)), ...); }
+        (std::make_index_sequence<sizeof...(T)>{});
     }
 
     /**
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
index f3c46576f528..3821d5d6505e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
@@ -124,8 +124,8 @@ TYPED_TEST(TranscriptTests, ProverManifestConsistency)
 {
     using Flavor = TypeParam;
     // Construct a simple circuit of size n = 8 (i.e. the minimum circuit size)
-    fr a = 1;
-    auto circuit_constructor = proof_system::StandardCircuitBuilder();
+    typename Flavor::FF a = 1;
+    auto circuit_constructor = typename Flavor::CircuitBuilder();
     circuit_constructor.add_variable(a);
     circuit_constructor.add_public_variable(a);
 
@@ -152,8 +152,8 @@ TYPED_TEST(TranscriptTests, VerifierManifestConsistency)
 {
     using Flavor = TypeParam;
     // Construct a simple circuit of size n = 8 (i.e. the minimum circuit size)
-    auto circuit_constructor = proof_system::StandardCircuitBuilder();
-    fr a = 1;
+    typename Flavor::FF a = 1;
+    auto circuit_constructor = typename Flavor::CircuitBuilder();
     circuit_constructor.add_variable(a);
     circuit_constructor.add_public_variable(a);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/compute_circuit_data.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/compute_circuit_data.hpp
index e73a1be11eb4..b4fa332c9a71 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/compute_circuit_data.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/compute_circuit_data.hpp
@@ -21,7 +21,7 @@ struct circuit_data {
         : num_gates(0)
     {}
 
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> srs;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> srs;
     std::shared_ptr<plonk::proving_key> proving_key;
     std::shared_ptr<plonk::verification_key> verification_key;
     size_t num_gates;
@@ -40,7 +40,7 @@ inline bool exists(std::string const& path)
 template <typename Composer, typename F>
 circuit_data get_circuit_data(std::string const& name,
                               std::string const& path_name,
-                              std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& srs,
+                              std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& srs,
                               std::string const& key_path,
                               bool compute,
                               bool save,
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
index c81913eaefa6..6f0d1f952c8d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.cpp
@@ -59,7 +59,8 @@ join_split_tx noop_tx()
     return tx;
 }
 
-circuit_data get_circuit_data(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& srs, bool mock)
+circuit_data get_circuit_data(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& srs,
+                              bool mock)
 {
     std::cerr << "Getting join-split circuit data..." << std::endl;
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.hpp
index 4f467f2f1657..459fc36a9dd5 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/compute_circuit_data.hpp
@@ -10,7 +10,8 @@ join_split_tx noop_tx();
 
 using circuit_data = proofs::circuit_data;
 
-circuit_data get_circuit_data(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& srs, bool mock = false);
+circuit_data get_circuit_data(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& srs,
+                              bool mock = false);
 
 } // namespace join_split
 } // namespace proofs
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
index 3bb2bc4a1799..1da1caee45fe 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.cpp
@@ -14,7 +14,8 @@ using namespace proof_system::plonk::stdlib::merkle_tree;
 static std::shared_ptr<plonk::proving_key> proving_key;
 static std::shared_ptr<plonk::verification_key> verification_key;
 
-void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory, bool mock)
+void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+                      bool mock)
 {
     if (proving_key) {
         return;
@@ -42,7 +43,7 @@ void release_proving_key()
     proving_key.reset();
 }
 
-void init_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory)
+void init_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory)
 {
     if (!proving_key) {
         std::abort();
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
index 91e83de2e9c3..1d4a1dd5fa7a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.hpp
@@ -7,11 +7,12 @@ namespace join_split_example {
 namespace proofs {
 namespace join_split {
 
-void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory, bool mock);
+void init_proving_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory,
+                      bool mock);
 
 void release_proving_key();
 
-void init_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory> const& crs_factory);
+void init_verification_key(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> const& crs_factory);
 
 Prover new_join_split_prover(join_split_tx const& tx, bool mock);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
index c24012a91bde..1377ebf10555 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split.test.cpp
@@ -43,9 +43,10 @@ class join_split_tests : public ::testing::Test {
     static constexpr size_t ACCOUNT_INDEX = 14;
     static void SetUpTestCase()
     {
-        auto null_crs_factory = std::make_shared<barretenberg::srs::factories::CrsFactory>();
+        auto null_crs_factory = std::make_shared<barretenberg::srs::factories::CrsFactory<curve::BN254>>();
         init_proving_key(null_crs_factory, false);
-        auto crs_factory = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+        auto crs_factory =
+            std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
         init_verification_key(std::move(crs_factory));
         info("vk hash: ", get_verification_key()->sha256_hash());
     }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_js_parity.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_js_parity.test.cpp
index 3407d319496b..f23bceef85f2 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_js_parity.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/join_split_example/proofs/join_split/join_split_js_parity.test.cpp
@@ -25,9 +25,10 @@ class join_split_js_parity_tests : public ::testing::Test {
   protected:
     static void SetUpTestCase()
     {
-        auto null_crs_factory = std::make_shared<barretenberg::srs::factories::CrsFactory>();
+        auto null_crs_factory = std::make_shared<barretenberg::srs::factories::CrsFactory<curve::BN254>>();
         init_proving_key(null_crs_factory, false);
-        auto crs_factory = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+        auto crs_factory =
+            std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
         init_verification_key(std::move(crs_factory));
         info("vk hash: ", get_verification_key()->sha256_hash());
     }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.cpp
index 73bc15311c2e..caeb3dcd796d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.cpp
@@ -44,7 +44,8 @@ void compute_monomial_and_coset_selector_forms(plonk::proving_key* circuit_provi
  */
 std::shared_ptr<plonk::verification_key> compute_verification_key_common(
     std::shared_ptr<plonk::proving_key> const& proving_key,
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& vrs)
+    // Here too
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& vrs)
 {
     auto circuit_verification_key = std::make_shared<plonk::verification_key>(
         proving_key->circuit_size, proving_key->num_public_inputs, vrs, proving_key->circuit_type);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.hpp
index d24ca45279e6..9b079013dfdd 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/composer_lib.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/proving_key.hpp"
 #include "barretenberg/plonk/proof_system/verification_key/verification_key.hpp"
 
@@ -20,11 +21,12 @@ struct SelectorProperties {
  * in that case.
  * @return std::shared_ptr<typename Flavor::ProvingKey>
  */
-std::shared_ptr<plonk::proving_key> initialize_proving_key(const auto& circuit_constructor,
-                                                           barretenberg::srs::factories::CrsFactory* crs_factory,
-                                                           const size_t minimum_circuit_size,
-                                                           const size_t num_randomized_gates,
-                                                           CircuitType circuit_type)
+std::shared_ptr<plonk::proving_key> initialize_proving_key(
+    const auto& circuit_constructor,
+    barretenberg::srs::factories::CrsFactory<curve::BN254>* crs_factory,
+    const size_t minimum_circuit_size,
+    const size_t num_randomized_gates,
+    CircuitType circuit_type)
 {
     const size_t num_gates = circuit_constructor.num_gates;
 
@@ -77,6 +79,7 @@ void compute_monomial_and_coset_selector_forms(plonk::proving_key* key,
  */
 std::shared_ptr<plonk::verification_key> compute_verification_key_common(
     std::shared_ptr<plonk::proving_key> const& proving_key,
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& vrs);
+    // silencing for now but need to figure out where to extract type of VerifierCrs from :-/
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& vrs);
 
 } // namespace proof_system::plonk
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp
index 97439bf7983b..66a3f6790aae 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.cpp
@@ -37,7 +37,8 @@ void StandardComposer::compute_witness(const CircuitBuilder& circuit_constructor
 
     const size_t subgroup_size = circuit_constructor.get_circuit_subgroup_size(num_constraints + NUM_RESERVED_GATES);
 
-    auto wire_polynomial_evaluations = construct_wire_polynomials_base<Flavor>(circuit_constructor, subgroup_size);
+    auto wire_polynomial_evaluations =
+        construct_wire_polynomials_base<StandardComposer::Flavor>(circuit_constructor, subgroup_size);
 
     for (size_t j = 0; j < program_width; ++j) {
         std::string index = std::to_string(j + 1);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
index b96679a7ab5e..b954a49d67df 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.hpp
@@ -15,6 +15,7 @@ namespace proof_system::plonk {
 class StandardComposer {
   public:
     using Flavor = plonk::flavor::Standard;
+
     using CircuitBuilder = StandardCircuitBuilder;
 
     static constexpr std::string_view NAME_STRING = "StandardPlonk";
@@ -24,19 +25,19 @@ class StandardComposer {
     std::shared_ptr<plonk::verification_key> circuit_verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory_;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory_;
 
     bool computed_witness = false;
 
     StandardComposer()
-        : StandardComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory>(
-              new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition")))
+        : StandardComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>>(
+              new barretenberg::srs::factories::FileCrsFactory<curve::BN254>("../srs_db/ignition")))
     {}
-    StandardComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+    StandardComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
 
-    StandardComposer(std::unique_ptr<barretenberg::srs::factories::CrsFactory>&& crs_factory)
+    StandardComposer(std::unique_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>>&& crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
     StandardComposer(std::shared_ptr<plonk::proving_key> p_key, std::shared_ptr<plonk::verification_key> v_key)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
index 54f95ffa78a6..26c8ffc7c961 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/standard_composer.test.cpp
@@ -40,7 +40,7 @@ TEST(standard_plonk_composer, composer_from_serialized_keys)
     auto pk_data = from_buffer<plonk::proving_key_data>(pk_buf);
     auto vk_data = from_buffer<plonk::verification_key_data>(vk_buf);
 
-    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto proving_key =
         std::make_shared<plonk::proving_key>(std::move(pk_data), crs->get_prover_crs(pk_data.circuit_size + 1));
     auto verification_key = std::make_shared<plonk::verification_key>(std::move(vk_data), crs->get_verifier_crs());
@@ -282,8 +282,7 @@ TEST(standard_plonk_composer, and_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
-            builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
+        auto accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
         // builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
@@ -354,8 +353,7 @@ TEST(standard_plonk_composer, xor_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
-            builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
+        auto accumulators = builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
             uint32_t left_expected = (left_value >> (30U - (2 * j)));
@@ -422,17 +420,15 @@ TEST(standard_plonk_composer, big_add_gate_with_bit_extract)
         uint32_t input = engine.get_random_uint32();
         uint32_t output = input + (quad_value > 1 ? 1 : 0);
 
-        add_quad gate{ builder.add_variable(uint256_t(input)),
-                       builder.add_variable(uint256_t(output)),
-                       right_idx,
-                       left_idx,
-                       fr(6),
-                       -fr(6),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-
-        builder.create_big_add_gate_with_bit_extraction(gate);
+        builder.create_big_add_gate_with_bit_extraction({ builder.add_variable(uint256_t(input)),
+                                                          builder.add_variable(uint256_t(output)),
+                                                          right_idx,
+                                                          left_idx,
+                                                          fr(6),
+                                                          -fr(6),
+                                                          fr::zero(),
+                                                          fr::zero(),
+                                                          fr::zero() });
     };
 
     generate_constraints(0);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
index b9b64ea0b2e6..8f124c3787d7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.hpp
@@ -22,18 +22,18 @@ class TurboComposer {
     std::shared_ptr<plonk::verification_key> circuit_verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory_;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory_;
 
     bool computed_witness = false;
     TurboComposer()
-        : TurboComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory>(
-              new barretenberg::srs::factories::FileCrsFactory("../srs_db/ignition")))
+        : TurboComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>>(
+              new barretenberg::srs::factories::FileCrsFactory<curve::BN254>("../srs_db/ignition")))
     {}
 
-    TurboComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+    TurboComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
-    TurboComposer(std::unique_ptr<barretenberg::srs::factories::CrsFactory>&& crs_factory)
+    TurboComposer(std::unique_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>>&& crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
     TurboComposer(std::shared_ptr<plonk::proving_key> p_key, std::shared_ptr<plonk::verification_key> v_key)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
index 3c280bafc0b6..f57a7a4a1c83 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/turbo_composer.test.cpp
@@ -44,7 +44,7 @@ TEST(turbo_plonk_composer, composer_from_serialized_keys)
     auto pk_data = from_buffer<plonk::proving_key_data>(pk_buf);
     auto vk_data = from_buffer<plonk::verification_key_data>(vk_buf);
 
-    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto proving_key =
         std::make_shared<plonk::proving_key>(std::move(pk_data), crs->get_prover_crs(pk_data.circuit_size + 1));
     auto verification_key = std::make_shared<plonk::verification_key>(std::move(vk_data), crs->get_verifier_crs());
@@ -278,17 +278,12 @@ TEST(turbo_plonk_composer, small_scalar_multipliers)
     }
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
-
     auto builder = TurboCircuitBuilder();
     auto composer = TurboComposer();
 
     fr x_alpha = accumulator_offset;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<barretenberg::fr> round_quad;
         round_quad.d = builder.add_variable(accumulator_transcript[i]);
         round_quad.a = builder.add_variable(multiplication_transcript[i].x);
         round_quad.b = builder.add_variable(multiplication_transcript[i].y);
@@ -306,20 +301,23 @@ TEST(turbo_plonk_composer, small_scalar_multipliers)
         if (i > 0) {
             builder.create_fixed_group_add_gate(round_quad);
         } else {
-            builder.create_fixed_group_add_gate_with_init(round_quad, init_quad);
+            builder.create_fixed_group_add_gate_with_init(round_quad,
+                                                          { origin_points[0].x,
+                                                            (origin_points[0].x - origin_points[1].x),
+                                                            origin_points[0].y,
+                                                            (origin_points[0].y - origin_points[1].y) });
         }
     }
 
-    add_quad add_quad{ builder.add_variable(multiplication_transcript[num_quads].x),
-                       builder.add_variable(multiplication_transcript[num_quads].y),
-                       builder.add_variable(x_alpha),
-                       builder.add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-    builder.create_big_add_gate(add_quad);
+    builder.create_big_add_gate({ builder.add_variable(multiplication_transcript[num_quads].x),
+                                  builder.add_variable(multiplication_transcript[num_quads].y),
+                                  builder.add_variable(x_alpha),
+                                  builder.add_variable(accumulator_transcript[num_quads]),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero() });
 
     grumpkin::g1::element expected_point =
         grumpkin::g1::element(generator * scalar_multiplier.to_montgomery_form()).normalize();
@@ -409,17 +407,12 @@ TEST(turbo_plonk_composer, large_scalar_multipliers)
     }
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
-
     auto builder = TurboCircuitBuilder();
     auto composer = TurboComposer();
 
     fr x_alpha = accumulator_offset;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<barretenberg::fr> round_quad;
         round_quad.d = builder.add_variable(accumulator_transcript[i]);
         round_quad.a = builder.add_variable(multiplication_transcript[i].x);
         round_quad.b = builder.add_variable(multiplication_transcript[i].y);
@@ -437,20 +430,23 @@ TEST(turbo_plonk_composer, large_scalar_multipliers)
         if (i > 0) {
             builder.create_fixed_group_add_gate(round_quad);
         } else {
-            builder.create_fixed_group_add_gate_with_init(round_quad, init_quad);
+            builder.create_fixed_group_add_gate_with_init(round_quad,
+                                                          { origin_points[0].x,
+                                                            (origin_points[0].x - origin_points[1].x),
+                                                            origin_points[0].y,
+                                                            (origin_points[0].y - origin_points[1].y) });
         }
     }
 
-    add_quad add_quad{ builder.add_variable(multiplication_transcript[num_quads].x),
-                       builder.add_variable(multiplication_transcript[num_quads].y),
-                       builder.add_variable(x_alpha),
-                       builder.add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-    builder.create_big_add_gate(add_quad);
+    builder.create_big_add_gate({ builder.add_variable(multiplication_transcript[num_quads].x),
+                                  builder.add_variable(multiplication_transcript[num_quads].y),
+                                  builder.add_variable(x_alpha),
+                                  builder.add_variable(accumulator_transcript[num_quads]),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero() });
 
     grumpkin::g1::element expected_point =
         grumpkin::g1::element(generator * scalar_multiplier.to_montgomery_form()).normalize();
@@ -561,7 +557,7 @@ TEST(turbo_plonk_composer, and_constraint_failure)
     uint32_t right_witness_index = builder.add_variable(right_witness_value);
 
     // 4 && 5 is 4, so 3 bits are needed, but we only constrain 2
-    accumulator_triple accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 2);
+    auto accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 2);
 
     auto prover = composer.create_prover(builder);
 
@@ -597,8 +593,7 @@ TEST(turbo_plonk_composer, and_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
-            builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
+        auto accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
         // builder.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
@@ -668,7 +663,7 @@ TEST(turbo_plonk_composer, xor_constraint_failure)
     uint32_t right_witness_index = builder.add_variable(right_witness_value);
 
     // 4 && 1 is 5, so 3 bits are needed, but we only constrain 2
-    accumulator_triple accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 2);
+    auto accumulators = builder.create_and_constraint(left_witness_index, right_witness_index, 2);
 
     auto prover = composer.create_prover(builder);
 
@@ -704,8 +699,7 @@ TEST(turbo_plonk_composer, xor_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
-            builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
+        auto accumulators = builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
             uint32_t left_expected = (left_value >> (30U - (2 * j)));
@@ -772,17 +766,15 @@ TEST(turbo_plonk_composer, big_add_gate_with_bit_extract)
         uint32_t input = engine.get_random_uint32();
         uint32_t output = input + (quad_value > 1 ? 1 : 0);
 
-        add_quad gate{ builder.add_variable(uint256_t(input)),
-                       builder.add_variable(uint256_t(output)),
-                       right_idx,
-                       left_idx,
-                       fr(6),
-                       -fr(6),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-
-        builder.create_big_add_gate_with_bit_extraction(gate);
+        builder.create_big_add_gate_with_bit_extraction({ builder.add_variable(uint256_t(input)),
+                                                          builder.add_variable(uint256_t(output)),
+                                                          right_idx,
+                                                          left_idx,
+                                                          fr(6),
+                                                          -fr(6),
+                                                          fr::zero(),
+                                                          fr::zero(),
+                                                          fr::zero() });
     };
 
     generate_constraints(0);
@@ -1059,17 +1051,12 @@ TEST(turbo_plonk_composer, test_check_circuit_fixed_group)
     }
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
-
     auto builder = TurboCircuitBuilder();
     auto composer = TurboComposer();
 
     fr x_alpha = accumulator_offset;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<barretenberg::fr> round_quad;
         round_quad.d = builder.add_variable(accumulator_transcript[i]);
         round_quad.a = builder.add_variable(multiplication_transcript[i].x);
         round_quad.b = builder.add_variable(multiplication_transcript[i].y);
@@ -1087,20 +1074,23 @@ TEST(turbo_plonk_composer, test_check_circuit_fixed_group)
         if (i > 0) {
             builder.create_fixed_group_add_gate(round_quad);
         } else {
-            builder.create_fixed_group_add_gate_with_init(round_quad, init_quad);
+            builder.create_fixed_group_add_gate_with_init(round_quad,
+                                                          { origin_points[0].x,
+                                                            (origin_points[0].x - origin_points[1].x),
+                                                            origin_points[0].y,
+                                                            (origin_points[0].y - origin_points[1].y) });
         }
     }
 
-    add_quad add_quad{ builder.add_variable(multiplication_transcript[num_quads].x),
-                       builder.add_variable(multiplication_transcript[num_quads].y),
-                       builder.add_variable(x_alpha),
-                       builder.add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-    builder.create_big_add_gate(add_quad);
+    builder.create_big_add_gate({ builder.add_variable(multiplication_transcript[num_quads].x),
+                                  builder.add_variable(multiplication_transcript[num_quads].y),
+                                  builder.add_variable(x_alpha),
+                                  builder.add_variable(accumulator_transcript[num_quads]),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero(),
+                                  fr::zero() });
 
     grumpkin::g1::element expected_point =
         grumpkin::g1::element(generator * scalar_multiplier.to_montgomery_form()).normalize();
@@ -1166,8 +1156,7 @@ TEST(turbo_plonk_composer, test_check_circuit_xor)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
-            builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
+        auto accumulators = builder.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
     }
 
     uint32_t zero_idx = builder.add_variable(fr::zero());
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
index eace805e7152..1f71e1e2e9b9 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.hpp
@@ -17,6 +17,7 @@ class UltraComposer {
   public:
     using Flavor = flavor::Ultra;
     using CircuitBuilder = UltraCircuitBuilder;
+    using Curve = Flavor::Curve;
 
     static constexpr std::string_view NAME_STRING = "UltraPlonk";
     static constexpr CircuitType type = CircuitType::ULTRA;
@@ -26,7 +27,7 @@ class UltraComposer {
     std::shared_ptr<plonk::verification_key> circuit_verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory_;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory_;
 
     bool computed_witness = false;
 
@@ -40,9 +41,9 @@ class UltraComposer {
         : UltraComposer("../srs_db/ignition"){};
 
     UltraComposer(std::string const& crs_path)
-        : UltraComposer(std::make_unique<barretenberg::srs::factories::FileCrsFactory>(crs_path)){};
+        : UltraComposer(std::make_unique<barretenberg::srs::factories::FileCrsFactory<Curve>>(crs_path)){};
 
-    explicit UltraComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory)
+    explicit UltraComposer(std::shared_ptr<barretenberg::srs::factories::CrsFactory<Curve>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
index 21132e39d543..99b3b8232d3c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/composer/ultra_composer.test.cpp
@@ -186,8 +186,7 @@ TYPED_TEST(ultra_plonk_composer, test_elliptic_gate)
     uint32_t x3 = builder.add_variable(p3.x);
     uint32_t y3 = builder.add_variable(p3.y);
 
-    ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, 1, 1 };
-    builder.create_ecc_add_gate(gate);
+    builder.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, 1, 1 });
 
     grumpkin::fq beta = grumpkin::fq::cube_root_of_unity();
     affine_element p2_endo = p2;
@@ -195,15 +194,13 @@ TYPED_TEST(ultra_plonk_composer, test_elliptic_gate)
     p3 = affine_element(element(p1) + element(p2_endo));
     x3 = builder.add_variable(p3.x);
     y3 = builder.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta, 1 };
-    builder.create_ecc_add_gate(gate);
+    builder.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta, 1 });
 
     p2_endo.x *= beta;
     p3 = affine_element(element(p1) - element(p2_endo));
     x3 = builder.add_variable(p3.x);
     y3 = builder.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
-    builder.create_ecc_add_gate(gate);
+    builder.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 });
 
     TestFixture::prove_and_verify(builder, composer, /*expected_result=*/true);
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/flavor/flavor.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/flavor/flavor.hpp
index 95fdc135281f..87e22689d45f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/flavor/flavor.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/flavor/flavor.hpp
@@ -10,6 +10,9 @@ class Standard {
   public:
     using CircuitBuilder = proof_system::StandardCircuitBuilder;
     using ProvingKey = plonk::proving_key;
+    using Curve = curve::BN254;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // Whether or not the first row of the execution trace is reserved for 0s to enable shifts
     static constexpr bool has_zero_row = false;
@@ -19,6 +22,9 @@ class Turbo {
   public:
     using CircuitBuilder = proof_system::TurboCircuitBuilder;
     using ProvingKey = plonk::proving_key;
+    using Curve = curve::BN254;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // Whether or not the first row of the execution trace is reserved for 0s to enable shifts
     static constexpr bool has_zero_row = false;
@@ -28,6 +34,9 @@ class Ultra {
   public:
     using CircuitBuilder = proof_system::UltraCircuitBuilder;
     using ProvingKey = plonk::proving_key;
+    using Curve = curve::BN254;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
     // Whether or not the first row of the execution trace is reserved for 0s to enable shifts
     static constexpr bool has_zero_row = false;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/commitment_scheme.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/commitment_scheme.test.cpp
index 95606da3804c..e874cb7b5e94 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/commitment_scheme.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/commitment_scheme/commitment_scheme.test.cpp
@@ -35,9 +35,9 @@ TEST(commitment_scheme, kate_open)
     transcript::StandardTranscript inp_tx = transcript::StandardTranscript(transcript::Manifest());
     plonk::KateCommitmentScheme<turbo_settings> newKate;
 
-    // std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory = (new
+    // std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory = (new
     // FileReferenceStringFactory("../srs_db/ignition"));
-    auto file_crs = std::make_shared<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto file_crs = std::make_shared<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto crs = file_crs->get_prover_crs(n);
     auto circuit_proving_key = std::make_shared<proving_key>(n, 0, crs, CircuitType::STANDARD);
     work_queue queue(circuit_proving_key.get(), &inp_tx);
@@ -94,7 +94,7 @@ TEST(commitment_scheme, kate_batch_open)
     transcript::StandardTranscript inp_tx = transcript::StandardTranscript(transcript::Manifest());
     plonk::KateCommitmentScheme<turbo_settings> newKate;
 
-    auto file_crs = std::make_shared<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto file_crs = std::make_shared<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto crs = file_crs->get_prover_crs(n);
     auto circuit_proving_key = std::make_shared<proving_key>(n, 0, crs, CircuitType::STANDARD);
     work_queue queue(circuit_proving_key.get(), &inp_tx);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.test.cpp
index 53a1166b36bb..a44e2b532995 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.test.cpp
@@ -26,7 +26,7 @@ TEST(proving_key, proving_key_from_serialized_key)
     plonk::proving_key& p_key = *composer.compute_proving_key(builder);
     auto pk_buf = to_buffer(p_key);
     auto pk_data = from_buffer<plonk::proving_key_data>(pk_buf);
-    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto proving_key =
         std::make_shared<plonk::proving_key>(std::move(pk_data), crs->get_prover_crs(pk_data.circuit_size + 1));
 
@@ -63,7 +63,7 @@ TEST(proving_key, proving_key_from_serialized_key_ultra)
     plonk::proving_key& p_key = *composer.compute_proving_key(builder);
     auto pk_buf = to_buffer(p_key);
     auto pk_data = from_buffer<plonk::proving_key_data>(pk_buf);
-    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto proving_key =
         std::make_shared<plonk::proving_key>(std::move(pk_data), crs->get_prover_crs(pk_data.circuit_size + 1));
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
index 0de60f52fbb0..42914ddd11c1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.cpp
@@ -87,7 +87,7 @@ barretenberg::fr verification_key_data::compress_native(const size_t hash_index)
 
 verification_key::verification_key(const size_t num_gates,
                                    const size_t num_inputs,
-                                   std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& crs,
+                                   std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& crs,
                                    CircuitType circuit_type_)
     : circuit_type(circuit_type_)
     , circuit_size(num_gates)
@@ -99,7 +99,7 @@ verification_key::verification_key(const size_t num_gates,
 {}
 
 verification_key::verification_key(verification_key_data&& data,
-                                   std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& crs)
+                                   std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& crs)
     : circuit_type(static_cast<CircuitType>(data.circuit_type))
     , circuit_size(data.circuit_size)
     , log_circuit_size(numeric::get_msb(data.circuit_size))
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index a9ca0331dd03..96ed0f68cafb 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include "barretenberg/common/streams.hpp"
 #include "barretenberg/crypto/sha256/sha256.hpp"
+#include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/plonk/proof_system/types/polynomial_manifest.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
@@ -70,10 +71,10 @@ struct verification_key {
     // default constructor needed for msgpack unpack
     verification_key() = default;
     verification_key(verification_key_data&& data,
-                     std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& crs);
+                     std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& crs);
     verification_key(const size_t num_gates,
                      const size_t num_inputs,
-                     std::shared_ptr<barretenberg::srs::factories::VerifierCrs> const& crs,
+                     std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> const& crs,
                      CircuitType circuit_type);
 
     verification_key(const verification_key& other);
@@ -103,7 +104,7 @@ struct verification_key {
 
     barretenberg::evaluation_domain domain;
 
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> reference_string;
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> reference_string;
 
     std::map<std::string, barretenberg::g1::affine_element> commitments;
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.test.cpp
index fcf4cfc93a02..dd923130f833 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/plonk/proof_system/verifier/verifier.test.cpp
@@ -41,7 +41,7 @@ plonk::Verifier generate_verifier(std::shared_ptr<proving_key> circuit_proving_k
                                                            state));
     }
 
-    auto crs = std::make_shared<barretenberg::srs::factories::FileVerifierCrs>("../srs_db/ignition");
+    auto crs = std::make_shared<barretenberg::srs::factories::FileVerifierCrs<curve::BN254>>("../srs_db/ignition");
     std::shared_ptr<verification_key> circuit_verification_key =
         std::make_shared<verification_key>(circuit_proving_key->circuit_size,
                                            circuit_proving_key->num_public_inputs,
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.cpp
index 8a6ed0e55473..2bd2f040d5b7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.cpp
@@ -5,6 +5,7 @@
 #include "barretenberg/common/thread.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/numeric/bitop/get_msb.hpp"
+#include "barretenberg/proof_system/types/circuit_type.hpp"
 #include <memory.h>
 #include <memory>
 
@@ -57,8 +58,6 @@ EvaluationDomain<Fr>::EvaluationDomain(const size_t domain_size, const size_t ta
     , log2_thread_size(static_cast<size_t>(numeric::get_msb(thread_size)))
     , log2_num_threads(static_cast<size_t>(numeric::get_msb(num_threads)))
     , generator_size(target_generator_size ? target_generator_size : domain_size)
-    , root(Fr::get_root_of_unity(log2_size))
-    , root_inverse(root.invert())
     , domain(Fr{ size, 0, 0, 0 }.to_montgomery_form())
     , domain_inverse(domain.invert())
     , generator(Fr::coset_generator(0))
@@ -66,6 +65,15 @@ EvaluationDomain<Fr>::EvaluationDomain(const size_t domain_size, const size_t ta
     , four_inverse(Fr(4).invert())
     , roots(nullptr)
 {
+    // Grumpkin does not have many roots of unity and, given these are not used for Honk, we set it to one.
+    if (proof_system::IsAnyOf<Fr, grumpkin::fr>) {
+        root = Fr::one();
+    } else {
+        root = Fr::get_root_of_unity(log2_size);
+    }
+
+    root_inverse = root.invert();
+
     ASSERT((1UL << log2_size) == size || (size == 0));
     ASSERT((1UL << log2_thread_size) == thread_size || (size == 0));
     ASSERT((1UL << log2_num_threads) == num_threads || (size == 0));
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.hpp
index 7e69a80ee2fb..3726455677d1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/evaluation_domain.hpp
@@ -5,7 +5,7 @@
 
 namespace barretenberg {
 
-template <typename Fr> class EvaluationDomain {
+template <typename FF> class EvaluationDomain {
   public:
     EvaluationDomain()
         : size(0)
@@ -15,13 +15,13 @@ template <typename Fr> class EvaluationDomain {
         , log2_thread_size(0)
         , log2_num_threads(0)
         , generator_size(0)
-        , root(fr::zero())
-        , root_inverse(fr::zero())
-        , domain(fr::zero())
-        , domain_inverse(fr::zero())
-        , generator(fr::zero())
-        , generator_inverse(fr::zero())
-        , four_inverse(fr::zero())
+        , root(FF::zero())
+        , root_inverse(FF::zero())
+        , domain(FF::zero())
+        , domain_inverse(FF::zero())
+        , generator(FF::zero())
+        , generator_inverse(FF::zero())
+        , four_inverse(FF::zero())
         , roots(nullptr){};
 
     EvaluationDomain(const size_t domain_size, const size_t target_generator_size = 0);
@@ -36,8 +36,8 @@ template <typename Fr> class EvaluationDomain {
     void compute_lookup_table();
     void compute_generator_table(const size_t target_generator_size);
 
-    const std::vector<Fr*>& get_round_roots() const { return round_roots; };
-    const std::vector<Fr*>& get_inverse_round_roots() const { return inverse_round_roots; }
+    const std::vector<FF*>& get_round_roots() const { return round_roots; };
+    const std::vector<FF*>& get_inverse_round_roots() const { return inverse_round_roots; }
 
     size_t size;        // n, always a power of 2
     size_t num_threads; // num_threads * thread_size = size
@@ -47,28 +47,28 @@ template <typename Fr> class EvaluationDomain {
     size_t log2_num_threads;
     size_t generator_size;
 
-    Fr root;           // omega; the nth root of unity
-    Fr root_inverse;   // omega^{-1}
-    Fr domain;         // n; same as size
-    Fr domain_inverse; // n^{-1}
-    Fr generator;
-    Fr generator_inverse;
-    Fr four_inverse;
+    FF root;           // omega; the nth root of unity
+    FF root_inverse;   // omega^{-1}
+    FF domain;         // n; same as size
+    FF domain_inverse; // n^{-1}
+    FF generator;
+    FF generator_inverse;
+    FF four_inverse;
 
   private:
-    std::vector<Fr*> round_roots; // An entry for each of the log(n) rounds: each entry is a pointer to
+    std::vector<FF*> round_roots; // An entry for each of the log(n) rounds: each entry is a pointer to
                                   // the subset of the roots of unity required for that fft round.
                                   // E.g. round_roots[0] = [1, ω^(n/2 - 1)],
                                   //      round_roots[1] = [1, ω^(n/4 - 1), ω^(n/2 - 1), ω^(3n/4 - 1)]
                                   //      ...
-    std::vector<Fr*> inverse_round_roots;
+    std::vector<FF*> inverse_round_roots;
 
-    std::shared_ptr<Fr[]> roots;
+    std::shared_ptr<FF[]> roots;
 };
 
 // tell the compiler we will take care of instantiating these in the .cpp file
 extern template class EvaluationDomain<barretenberg::fr>;
-extern template class EvaluationDomain<grumpkin::fr>;
+// extern template class EvaluationDomain<grumpkin::fr>;
 // add alias for compatibility
 using evaluation_domain = EvaluationDomain<barretenberg::fr>;
 } // namespace barretenberg
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial_arithmetic.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial_arithmetic.test.cpp
index 7193a38937df..644144fc9f75 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial_arithmetic.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial_arithmetic.test.cpp
@@ -9,6 +9,7 @@
 #include <utility>
 
 using namespace barretenberg;
+// TODO(#635): This tests should be typed to run on both barretenberg::fr and grumpkin::fr.
 
 TEST(polynomials, evaluation_domain)
 {
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/arithmetization.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/arithmetization.hpp
index ed1dcfcc27d0..671ab2e43044 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/arithmetization.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/arithmetization.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include <array>
 #include <barretenberg/common/slab_allocator.hpp>
 #include <cstddef>
@@ -173,4 +174,10 @@ template <typename _FF> class Ultra : public Arithmetization</*NUM_WIRES =*/4, /
         // ~Selectors() = default;
     };
 };
+class GoblinTranslator : public Arithmetization</*NUM_WIRES =*/78, /*num_selectors =*/0> {
+  public:
+    // Dirty hack
+    using Selectors = bool;
+    using FF = curve::BN254::ScalarField;
+};
 } // namespace arithmetization
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/gate_data.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/gate_data.hpp
index ba60a0dd0ea7..dbdd25061d58 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/gate_data.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/arithmetization/gate_data.hpp
@@ -16,7 +16,6 @@ template <typename FF> struct add_triple_ {
     FF c_scaling;
     FF const_scaling;
 };
-using add_triple = add_triple_<barretenberg::fr>;
 
 template <typename FF> struct add_quad_ {
     uint32_t a;
@@ -29,8 +28,6 @@ template <typename FF> struct add_quad_ {
     FF d_scaling;
     FF const_scaling;
 };
-using add_quad = add_quad_<barretenberg::fr>;
-
 template <typename FF> struct mul_quad_ {
     uint32_t a;
     uint32_t b;
@@ -43,8 +40,6 @@ template <typename FF> struct mul_quad_ {
     FF d_scaling;
     FF const_scaling;
 };
-using mul_quad = mul_quad_<barretenberg::fr>;
-
 template <typename FF> struct mul_triple_ {
     uint32_t a;
     uint32_t b;
@@ -53,8 +48,6 @@ template <typename FF> struct mul_triple_ {
     FF c_scaling;
     FF const_scaling;
 };
-using mul_triple = mul_triple_<barretenberg::fr>;
-
 template <typename FF> struct poly_triple_ {
     uint32_t a;
     uint32_t b;
@@ -67,9 +60,7 @@ template <typename FF> struct poly_triple_ {
 
     friend bool operator==(poly_triple_<FF> const& lhs, poly_triple_<FF> const& rhs) = default;
 };
-
 using poly_triple = poly_triple_<barretenberg::fr>;
-
 struct ecc_op_tuple {
     uint32_t op;
     uint32_t x_lo;
@@ -80,7 +71,7 @@ struct ecc_op_tuple {
     uint32_t z_hi;
 };
 
-template <typename B> inline void read(B& buf, poly_triple& constraint)
+template <typename B, typename FF> inline void read(B& buf, poly_triple_<FF>& constraint)
 {
     using serialize::read;
     read(buf, constraint.a);
@@ -92,7 +83,7 @@ template <typename B> inline void read(B& buf, poly_triple& constraint)
     read(buf, constraint.q_o);
     read(buf, constraint.q_c);
 }
-template <typename B> inline void write(B& buf, poly_triple const& constraint)
+template <typename B, typename FF> inline void write(B& buf, poly_triple_<FF> const& constraint)
 {
     using serialize::write;
     write(buf, constraint.a);
@@ -115,23 +106,17 @@ template <typename FF> struct fixed_group_add_quad_ {
     FF q_y_1;
     FF q_y_2;
 };
-using fixed_group_add_quad = fixed_group_add_quad_<barretenberg::fr>;
-
 template <typename FF> struct fixed_group_init_quad_ {
     FF q_x_1;
     FF q_x_2;
     FF q_y_1;
     FF q_y_2;
 };
-using fixed_group_init_quad = fixed_group_init_quad_<barretenberg::fr>;
-
 template <typename FF> struct accumulator_triple_ {
     std::vector<uint32_t> left;
     std::vector<uint32_t> right;
     std::vector<uint32_t> out;
 };
-using accumulator_triple = accumulator_triple_<barretenberg::fr>;
-
 template <typename FF> struct ecc_add_gate_ {
     uint32_t x1;
     uint32_t y1;
@@ -142,5 +127,4 @@ template <typename FF> struct ecc_add_gate_ {
     FF endomorphism_coefficient;
     FF sign_coefficient;
 };
-using ecc_add_gate = ecc_add_gate_<barretenberg::fr>;
 } // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.cpp
index 1cce2aabb728..a50396869ebf 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.cpp
@@ -46,5 +46,6 @@ void CircuitBuilderBase<Arithmetization>::assert_equal(const uint32_t a_variable
 template class CircuitBuilderBase<arithmetization::Standard<barretenberg::fr>>;
 template class CircuitBuilderBase<arithmetization::Standard<grumpkin::fr>>;
 template class CircuitBuilderBase<arithmetization::Ultra<barretenberg::fr>>;
+template class CircuitBuilderBase<arithmetization::GoblinTranslator>;
 template class CircuitBuilderBase<arithmetization::Turbo<barretenberg::fr>>;
 } // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp
index b0b591da58d1..4e5e29510d6b 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp
@@ -61,8 +61,11 @@ template <typename Arithmetization> class CircuitBuilderBase {
         prev_var_index.reserve(size_hint * 3);
         real_variable_index.reserve(size_hint * 3);
         real_variable_tags.reserve(size_hint * 3);
-        for (auto& p : selectors) {
-            p.reserve(size_hint);
+        // We set selectors type to bool, when we don't actually use them
+        if constexpr (!std::is_same<typename Arithmetization::Selectors, bool>::value) {
+            for (auto& p : selectors) {
+                p.reserve(size_hint);
+            }
         }
     }
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.hpp
new file mode 100644
index 000000000000..49edf02b275e
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.hpp
@@ -0,0 +1,699 @@
+#pragma once
+/**
+ * @file goblin_translator_builder.hpp
+ * @author @Rumata888
+ * @brief Circuit Logic generation for Goblin Plonk translator (checks equivalence of Queues/Transcripts for ECCVM and
+ * Recursive Circuits)
+ *
+ * @copyright Copyright (c) 2023
+ *
+ */
+#include "barretenberg/ecc/curves/bn254/fq.hpp"
+#include "barretenberg/proof_system/arithmetization/arithmetization.hpp"
+#include "circuit_builder_base.hpp"
+#include <array>
+#include <cstddef>
+namespace proof_system {
+class GoblinTranslatorCircuitBuilder : CircuitBuilderBase<arithmetization::GoblinTranslator> {
+    // We don't need templating for Goblin
+    using Fr = barretenberg::fr;
+    using Fq = barretenberg::fq;
+
+  public:
+    /**
+     * We won't need these standard gates that are defined as virtual in circuit builder base
+     *
+     */
+    void create_add_gate(const add_triple_<Fr>&) override{};
+    void create_mul_gate(const mul_triple_<Fr>&) override{};
+    void create_bool_gate(const uint32_t) override{};
+    void create_poly_gate(const poly_triple_<Fr>&) override{};
+    [[nodiscard]] size_t get_num_constant_gates() const override { return 0; };
+
+    /**
+     * @brief There are so many wires that naming them has no sense, it is easier to access them with enums
+     *
+     */
+    enum WireIds : size_t {
+        OP, // The first 4 wires contain the standard values from the EccQueue wire
+        X_LO_Y_HI,
+        X_HI_Z_1,
+        Y_LO_Z_2,
+        P_X_LOW_LIMBS,                    // P.xₗₒ split into 2 68 bit limbs
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_0, // Low limbs split further into smaller chunks for range constraints
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_1,
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_2,
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_3,
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_4,
+        P_X_LOW_LIMBS_RANGE_CONSTRAINT_TAIL,
+        P_X_HIGH_LIMBS,                    // P.xₕᵢ split into 2 68 bit limbs
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_0, // High limbs split into chunks for range constraints
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_1,
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_2,
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_3,
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_4,
+        P_X_HIGH_LIMBS_RANGE_CONSTRAINT_TAIL,
+        P_Y_LOW_LIMBS,                    // P.yₗₒ split into 2 68 bit limbs
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_0, // Low limbs split into chunks for range constraints
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_1,
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_2,
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_3,
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_4,
+        P_Y_LOW_LIMBS_RANGE_CONSTRAINT_TAIL,
+        P_Y_HIGH_LIMBS,                    // P.yₕᵢ split into 2 68 bit limbs
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_0, // High limbs split into chunks for range constraints
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_1,
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_2,
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_3,
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_4,
+        P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_TAIL,
+        Z_LO_LIMBS,                    // Low limbs of z_1 and z_2
+        Z_LO_LIMBS_RANGE_CONSTRAINT_0, // Range constraints for low limbs of z_1 and z_2
+        Z_LO_LIMBS_RANGE_CONSTRAINT_1,
+        Z_LO_LIMBS_RANGE_CONSTRAINT_2,
+        Z_LO_LIMBS_RANGE_CONSTRAINT_3,
+        Z_LO_LIMBS_RANGE_CONSTRAINT_4,
+        Z_LO_LIMBS_RANGE_CONSTRAINT_TAIL,
+        Z_HI_LIMBS,                    // Hi Limbs of z_1 and z_2
+        Z_HI_LIMBS_RANGE_CONSTRAINT_0, // Range constraints for high limbs of z_1 and z_2
+        Z_HI_LIMBS_RANGE_CONSTRAINT_1,
+        Z_HI_LIMBS_RANGE_CONSTRAINT_2,
+        Z_HI_LIMBS_RANGE_CONSTRAINT_3,
+        Z_HI_LIMBS_RANGE_CONSTRAINT_4,
+        Z_HI_LIMBS_RANGE_CONSTRAINT_TAIL,
+        ACCUMULATORS_BINARY_LIMBS_0, // Contain 68-bit limbs of current and previous accumulator (previous at higher
+                                     // indices because of the nuances of KZG commitment)
+        ACCUMULATORS_BINARY_LIMBS_1,
+        ACCUMULATORS_BINARY_LIMBS_2,
+        ACCUMULATORS_BINARY_LIMBS_3,
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_0, // Range constraints for the current accumulator limbs (no need to redo
+                                                 // previous accumulator)
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_1,
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_2,
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_3,
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_4,
+        ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_TAIL,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_0,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_1,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_2,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_3,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_4,
+        ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_TAIL,
+        QUOTIENT_LO_BINARY_LIMBS, // Quotient limbs
+        QUOTIENT_HI_BINARY_LIMBS,
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_0, // Range constraints for quotient
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_1,
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_2,
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_3,
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_4,
+        QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_TAIL,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_0,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_1,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_2,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_3,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_4,
+        QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_TAIL,
+        RELATION_WIDE_LIMBS, // Limbs for checking the correctness of  mod 2²⁷² relations. TODO(kesha): add range
+                             // constraints
+
+    };
+    static constexpr size_t MAX_OPERAND = 3;
+    static constexpr size_t NUM_LIMB_BITS = 68;
+    static constexpr size_t NUM_Z_LIMBS = 2;
+    static constexpr size_t MICRO_LIMB_BITS = 12;
+    static constexpr size_t LEFTOVER_CHUNK_BITS = 8;
+    static constexpr size_t NUM_MICRO_LIMBS = 6;
+    static constexpr size_t NUM_BINARY_LIMBS = 4;
+    static constexpr size_t WIDE_RELATION_LIMB_BITS = 72;
+    static constexpr auto MICRO_SHIFT = uint256_t(1) << MICRO_LIMB_BITS;
+    static constexpr auto MAXIMUM_LEFTOVER_LIMB_SIZE = (uint256_t(1) << LEFTOVER_CHUNK_BITS) - 1;
+    static constexpr size_t NUM_LAST_LIMB_BITS = Fq::modulus.get_msb() + 1 - 3 * NUM_LIMB_BITS;
+    static constexpr auto MAX_LOW_WIDE_LIMB_SIZE = (uint256_t(1) << (NUM_LIMB_BITS * 2)) - 1;
+    static constexpr auto MAX_HIGH_WIDE_LIMB_SIZE = (uint256_t(1) << (NUM_LIMB_BITS + NUM_LAST_LIMB_BITS)) - 1;
+    static constexpr auto SHIFT_1 = uint256_t(1) << NUM_LIMB_BITS;
+    static constexpr auto SHIFT_2 = uint256_t(1) << (NUM_LIMB_BITS << 1);
+    static constexpr auto SHIFT_2_INVERSE = Fr(SHIFT_2).invert();
+    static constexpr uint512_t MODULUS_U512 = uint512_t(Fq::modulus);
+    static constexpr uint512_t BINARY_BASIS_MODULUS = uint512_t(1) << (NUM_LIMB_BITS << 2);
+    static constexpr uint512_t NEGATIVE_PRIME_MODULUS = BINARY_BASIS_MODULUS - MODULUS_U512;
+    static constexpr std::array<Fr, 5> NEGATIVE_MODULUS_LIMBS = {
+        Fr(NEGATIVE_PRIME_MODULUS.slice(0, NUM_LIMB_BITS).lo),
+        Fr(NEGATIVE_PRIME_MODULUS.slice(NUM_LIMB_BITS, NUM_LIMB_BITS * 2).lo),
+        Fr(NEGATIVE_PRIME_MODULUS.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 3).lo),
+        Fr(NEGATIVE_PRIME_MODULUS.slice(NUM_LIMB_BITS * 3, NUM_LIMB_BITS * 4).lo),
+        -Fr(Fq::modulus)
+    };
+    static constexpr std::string_view NAME_STRING = "GoblinTranslatorArithmetization";
+    // TODO(kesha): fix size hints
+    GoblinTranslatorCircuitBuilder()
+        : CircuitBuilderBase({}, 0)
+    {
+        // We'll have to shift all wires, so we need the starting element to be zero
+        for (auto& wire : wires) {
+            wire.push_back(0);
+        }
+    };
+    GoblinTranslatorCircuitBuilder(const GoblinTranslatorCircuitBuilder& other) = delete;
+    GoblinTranslatorCircuitBuilder(GoblinTranslatorCircuitBuilder&& other) noexcept
+        : CircuitBuilderBase(std::move(other)){};
+    GoblinTranslatorCircuitBuilder& operator=(const GoblinTranslatorCircuitBuilder& other) = delete;
+    GoblinTranslatorCircuitBuilder& operator=(GoblinTranslatorCircuitBuilder&& other) noexcept
+    {
+        CircuitBuilderBase::operator=(std::move(other));
+        return *this;
+    };
+    ~GoblinTranslatorCircuitBuilder() override = default;
+
+    /**
+     * @brief The accumulation input structure contains all the necessary values to initalize an accumulation gate as
+     * well as additional values for checking its correctness
+     *
+     * @details For example, we don't really nead the prime limbs, but they serve to check the correctness of over
+     * values. We also don't need the values of x's and v's limbs during circuit construction, since they are added to
+     * relations directly, but this allows us to check correctness of the computed accumulator
+     */
+    struct AccumulationInput {
+        // Members necessary for the gate creation
+        Fr op_code; // Operator
+        Fr P_x_lo;
+        Fr P_x_hi;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> P_x_limbs;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_BINARY_LIMBS> P_x_microlimbs;
+        Fr P_y_lo;
+        Fr P_y_hi;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> P_y_limbs;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_BINARY_LIMBS> P_y_microlimbs;
+
+        Fr z_1;
+        std::array<Fr, NUM_Z_LIMBS> z_1_limbs;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_Z_LIMBS> z_1_microlimbs;
+        Fr z_2;
+        std::array<Fr, NUM_Z_LIMBS> z_2_limbs;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_Z_LIMBS> z_2_microlimbs;
+
+        std::array<Fr, NUM_BINARY_LIMBS + 1> previous_accumulator;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> current_accumulator;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_BINARY_LIMBS> current_accumulator_microlimbs;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> quotient_binary_limbs;
+        std::array<std::array<Fr, NUM_MICRO_LIMBS>, NUM_BINARY_LIMBS> quotient_microlimbs;
+        std::array<Fr, 2> relation_wide_limbs;
+
+        // Additional
+        std::array<Fr, NUM_BINARY_LIMBS + 1> x_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_squared_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_cubed_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_quarted_limbs = { 0 };
+    };
+    struct RelationInputs {
+        std::array<Fr, NUM_BINARY_LIMBS + 1> x_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_squared_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_cubed_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS + 1> v_quarted_limbs = { 0 };
+    };
+
+    /**
+     * @brief Create bigfield representations of x and powers of v
+     *
+     * @param x The point at which the polynomials are being evaluated
+     * @param v The batching challenge
+     * @return RelationInputs
+     */
+    static RelationInputs compute_relation_inputs_limbs(Fq x, Fq v)
+    {
+        /**
+         * @brief A small function to transform a native element Fq into its bigfield representation  in Fr scalars
+         *
+         */
+        auto base_element_to_bigfield = [](Fq& original) {
+            uint256_t original_uint = original;
+            return std::array<Fr, 5>({ Fr(original_uint.slice(0, NUM_LIMB_BITS)),
+                                       Fr(original_uint.slice(NUM_LIMB_BITS, 2 * NUM_LIMB_BITS)),
+                                       Fr(original_uint.slice(2 * NUM_LIMB_BITS, 3 * NUM_LIMB_BITS)),
+                                       Fr(original_uint.slice(3 * NUM_LIMB_BITS, 4 * NUM_LIMB_BITS)),
+                                       Fr(original_uint) });
+        };
+        Fq v_squared;
+        Fq v_cubed;
+        Fq v_quarted;
+        v_squared = v * v;
+        v_cubed = v_squared * v;
+        v_quarted = v_cubed * v;
+        RelationInputs result;
+        result.x_limbs = base_element_to_bigfield(x);
+        result.v_limbs = base_element_to_bigfield(v);
+        result.v_squared_limbs = base_element_to_bigfield(v_squared);
+        result.v_cubed_limbs = base_element_to_bigfield(v_cubed);
+        result.v_quarted_limbs = base_element_to_bigfield(v_quarted);
+        return result;
+    }
+
+    /**
+     * @brief Create a single accumulation gate
+     *
+     * @param acc_step
+     */
+    void create_accumulation_gate(const AccumulationInput acc_step)
+    {
+        // The first wires OpQueue/Transcript wires
+        ASSERT(uint256_t(acc_step.op_code) <= MAX_OPERAND);
+        auto& op_wire = std::get<WireIds::OP>(wires);
+        op_wire.push_back(add_variable(acc_step.op_code));
+        op_wire.push_back(zero_idx);
+
+        /**
+         * @brief Insert two values into the same wire sequentially
+         *
+         */
+        auto insert_pair_into_wire = [this](WireIds wire_index, Fr first, Fr second) {
+            auto& current_wire = wires[wire_index];
+            current_wire.push_back(add_variable(first));
+            current_wire.push_back(add_variable(second));
+        };
+
+        // Check and insert P_x_lo and P_y_hi into wire 1
+        ASSERT(uint256_t(acc_step.P_x_lo) <= MAX_LOW_WIDE_LIMB_SIZE);
+        ASSERT(uint256_t(acc_step.P_y_hi) <= MAX_HIGH_WIDE_LIMB_SIZE);
+        insert_pair_into_wire(WireIds::X_LO_Y_HI, acc_step.P_x_lo, acc_step.P_y_hi);
+
+        // Check and insert P_x_hi and z_1 into wire 2
+        ASSERT(uint256_t(acc_step.P_x_hi) <= MAX_HIGH_WIDE_LIMB_SIZE);
+        ASSERT(uint256_t(acc_step.z_1) <= MAX_LOW_WIDE_LIMB_SIZE);
+        insert_pair_into_wire(WireIds::X_HI_Z_1, acc_step.P_x_hi, acc_step.z_1);
+
+        // Check and insert P_y_lo and z_2 into wire 3
+        ASSERT(uint256_t(acc_step.P_y_lo) <= MAX_LOW_WIDE_LIMB_SIZE);
+        ASSERT(uint256_t(acc_step.z_2) <= MAX_LOW_WIDE_LIMB_SIZE);
+        insert_pair_into_wire(WireIds::Y_LO_Z_2, acc_step.P_y_lo, acc_step.z_2);
+
+        // Check decomposition of values from the Queue into limbs used in bigfield evaluations
+        ASSERT(acc_step.P_x_lo == (acc_step.P_x_limbs[0] + acc_step.P_x_limbs[1] * SHIFT_1));
+        ASSERT(acc_step.P_x_hi == (acc_step.P_x_limbs[2] + acc_step.P_x_limbs[3] * SHIFT_1));
+        ASSERT(acc_step.P_y_lo == (acc_step.P_y_limbs[0] + acc_step.P_y_limbs[1] * SHIFT_1));
+        ASSERT(acc_step.P_y_hi == (acc_step.P_y_limbs[2] + acc_step.P_y_limbs[3] * SHIFT_1));
+        ASSERT(acc_step.z_1 == (acc_step.z_1_limbs[0] + acc_step.z_1_limbs[1] * SHIFT_1));
+        ASSERT(acc_step.z_2 == (acc_step.z_2_limbs[0] + acc_step.z_2_limbs[1] * SHIFT_1));
+
+        /**
+         * @brief Check correctness of limbs values
+         *
+         */
+        auto check_binary_limbs_maximum_values = []<size_t total_limbs>(const std::array<Fr, total_limbs>& limbs) {
+            if constexpr (total_limbs == (NUM_BINARY_LIMBS + 1)) {
+                for (size_t i = 0; i < NUM_BINARY_LIMBS - 1; i++) {
+                    ASSERT(uint256_t(limbs[i]) < SHIFT_1);
+                }
+                ASSERT(uint256_t(limbs[NUM_BINARY_LIMBS - 1]) < (uint256_t(1) << NUM_LAST_LIMB_BITS));
+            } else {
+                for (size_t i = 0; i < total_limbs; i++) {
+                    ASSERT(uint256_t(limbs[i]) < SHIFT_1);
+                }
+            }
+        };
+        /**
+         * @brief Check correctness of values for range constraint limbs
+         *
+         */
+        auto check_micro_limbs_maximum_values =
+            []<size_t binary_limb_count, size_t micro_limb_count>(
+                const std::array<std::array<Fr, micro_limb_count>, binary_limb_count>& limbs) {
+                for (size_t i = 0; i < binary_limb_count; i++) {
+                    for (size_t j = 0; j < micro_limb_count; j++) {
+                        ASSERT(uint256_t(limbs[i][j]) < MICRO_SHIFT);
+                    }
+                }
+            };
+
+        // Check limb values are in range
+        check_binary_limbs_maximum_values(acc_step.P_x_limbs);
+        check_binary_limbs_maximum_values(acc_step.P_y_limbs);
+        check_binary_limbs_maximum_values(acc_step.z_1_limbs);
+        check_binary_limbs_maximum_values(acc_step.z_2_limbs);
+        check_binary_limbs_maximum_values(acc_step.previous_accumulator);
+        check_binary_limbs_maximum_values(acc_step.current_accumulator);
+        check_binary_limbs_maximum_values(acc_step.quotient_binary_limbs);
+
+        // Insert limbs used in bigfield evaluations
+        insert_pair_into_wire(P_X_LOW_LIMBS, acc_step.P_x_limbs[0], acc_step.P_x_limbs[1]);
+        insert_pair_into_wire(P_X_HIGH_LIMBS, acc_step.P_x_limbs[2], acc_step.P_x_limbs[3]);
+        insert_pair_into_wire(P_Y_LOW_LIMBS, acc_step.P_y_limbs[0], acc_step.P_y_limbs[1]);
+        insert_pair_into_wire(P_Y_HIGH_LIMBS, acc_step.P_y_limbs[2], acc_step.P_y_limbs[3]);
+        insert_pair_into_wire(Z_LO_LIMBS, acc_step.z_1_limbs[0], acc_step.z_2_limbs[0]);
+        insert_pair_into_wire(Z_HI_LIMBS, acc_step.z_1_limbs[1], acc_step.z_2_limbs[1]);
+        insert_pair_into_wire(
+            QUOTIENT_LO_BINARY_LIMBS, acc_step.quotient_binary_limbs[0], acc_step.quotient_binary_limbs[1]);
+        insert_pair_into_wire(
+            QUOTIENT_HI_BINARY_LIMBS, acc_step.quotient_binary_limbs[2], acc_step.quotient_binary_limbs[3]);
+        insert_pair_into_wire(RELATION_WIDE_LIMBS, acc_step.relation_wide_limbs[0], acc_step.relation_wide_limbs[1]);
+
+        // Check limbs used in range constraints are in range
+        check_micro_limbs_maximum_values(acc_step.P_x_microlimbs);
+        check_micro_limbs_maximum_values(acc_step.P_y_microlimbs);
+        check_micro_limbs_maximum_values(acc_step.z_1_microlimbs);
+        check_micro_limbs_maximum_values(acc_step.z_2_microlimbs);
+        check_micro_limbs_maximum_values(acc_step.current_accumulator_microlimbs);
+
+        // Check that relation limbs are in range
+        ASSERT(uint256_t(acc_step.relation_wide_limbs[0]).get_msb() < WIDE_RELATION_LIMB_BITS);
+        ASSERT(uint256_t(acc_step.relation_wide_limbs[1]).get_msb() < WIDE_RELATION_LIMB_BITS);
+
+        /**
+         * @brief Put several values in sequential wires
+         *
+         */
+        auto lay_limbs_in_row = [this]<size_t array_size>(std::array<Fr, array_size> input,
+                                                          WireIds starting_wire,
+                                                          size_t number_of_elements) {
+            ASSERT(number_of_elements <= array_size);
+            for (size_t i = 0; i < number_of_elements; i++) {
+                wires[starting_wire + i].push_back(add_variable(input[i]));
+            }
+        };
+        lay_limbs_in_row(acc_step.P_x_microlimbs[0], P_X_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_x_microlimbs[1], P_X_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_x_microlimbs[2], P_X_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_x_microlimbs[3], P_X_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_y_microlimbs[0], P_Y_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_y_microlimbs[1], P_Y_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_y_microlimbs[2], P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.P_y_microlimbs[3], P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.z_1_microlimbs[0], Z_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.z_2_microlimbs[0], Z_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.z_1_microlimbs[1], Z_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.z_2_microlimbs[1], Z_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.current_accumulator, ACCUMULATORS_BINARY_LIMBS_0, NUM_BINARY_LIMBS);
+        lay_limbs_in_row(acc_step.previous_accumulator, ACCUMULATORS_BINARY_LIMBS_0, NUM_BINARY_LIMBS);
+        lay_limbs_in_row(
+            acc_step.current_accumulator_microlimbs[0], ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(
+            acc_step.current_accumulator_microlimbs[1], ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(
+            acc_step.current_accumulator_microlimbs[2], ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(
+            acc_step.current_accumulator_microlimbs[3], ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.quotient_microlimbs[0], QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.quotient_microlimbs[1], QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.quotient_microlimbs[2], QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS);
+        lay_limbs_in_row(acc_step.quotient_microlimbs[3], QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS);
+
+        num_gates += 2;
+    }
+
+    /**
+     * @brief Check the witness satisifies the circuit
+     *
+     * @details Does one gate for now
+     *
+     * @param x
+     * @param v
+     * @return true
+     * @return false
+     */
+    bool check_circuit(Fq x, Fq v)
+    {
+        // Compute the limbs of x and powers of v (these go into the relation)
+        RelationInputs relation_inputs = compute_relation_inputs_limbs(x, v);
+
+        // Get the wires
+        auto& op_wire = std::get<OP>(wires);
+        auto& x_lo_y_hi_wire = std::get<X_LO_Y_HI>(wires);
+        auto& x_hi_z_1_wire = std::get<X_HI_Z_1>(wires);
+        auto& y_lo_z_2_wire = std::get<Y_LO_Z_2>(wires);
+        auto& p_x_0_p_x_1_wire = std::get<P_X_LOW_LIMBS>(wires);
+        auto& p_x_2_p_x_3_wire = std::get<P_X_HIGH_LIMBS>(wires);
+        auto& p_y_0_p_y_1_wire = std::get<P_Y_LOW_LIMBS>(wires);
+        auto& p_y_2_p_y_3_wire = std::get<P_Y_HIGH_LIMBS>(wires);
+        auto& z_lo_wire = std::get<Z_LO_LIMBS>(wires);
+        auto& z_hi_wire = std::get<Z_HI_LIMBS>(wires);
+        auto& accumulators_binary_limbs_0_wire = std::get<ACCUMULATORS_BINARY_LIMBS_0>(wires);
+        auto& accumulators_binary_limbs_1_wire = std::get<ACCUMULATORS_BINARY_LIMBS_1>(wires);
+        auto& accumulators_binary_limbs_2_wire = std::get<ACCUMULATORS_BINARY_LIMBS_2>(wires);
+        auto& accumulators_binary_limbs_3_wire = std::get<ACCUMULATORS_BINARY_LIMBS_3>(wires);
+        auto& quotient_low_binary_limbs = std::get<QUOTIENT_LO_BINARY_LIMBS>(wires);
+        auto& quotient_high_binary_limbs = std::get<QUOTIENT_HI_BINARY_LIMBS>(wires);
+        auto& relation_wide_limbs_wire = std::get<RELATION_WIDE_LIMBS>(wires);
+
+        /**
+         * @brief Get elements at the same index from several sequential wires and put them into a vector
+         *
+         */
+        auto get_sequential_micro_chunks = [this](size_t gate_index, WireIds starting_wire_index, size_t chunk_count) {
+            std::vector<Fr> chunks;
+            for (size_t i = starting_wire_index; i < starting_wire_index + chunk_count; i++) {
+                chunks.push_back(get_variable(wires[i][gate_index]));
+            }
+            return chunks;
+        };
+
+        /**
+         * @brief Reconstruct the value of one regular limb used in relation computation from micro chunks used to
+         * create range constraints
+         *
+         */
+        auto accumulate_limb_from_micro_chunks = [](const std::vector<Fr>& chunks) {
+            Fr mini_accumulator(0);
+            for (auto it = chunks.end(); it != chunks.begin();) {
+                --it;
+                mini_accumulator = mini_accumulator * MICRO_SHIFT + *it;
+            }
+            return mini_accumulator;
+        };
+        /**
+         * @brief Enumerate through the gates
+         *
+         */
+        for (size_t i = 0; i < num_gates; i++) {
+            // The main relation is computed between odd and the next even indices. For example, 1 and 2
+            if (i & 1) {
+                // Get the values
+                Fr op_code = get_variable(op_wire[i]);
+                Fr p_x_lo = get_variable(x_lo_y_hi_wire[i]);
+                Fr p_x_hi = get_variable(x_hi_z_1_wire[i]);
+                Fr p_x_0 = get_variable(p_x_0_p_x_1_wire[i]);
+                Fr p_x_1 = get_variable(p_x_0_p_x_1_wire[i + 1]);
+                Fr p_x_2 = get_variable(p_x_2_p_x_3_wire[i]);
+                Fr p_x_3 = get_variable(p_x_2_p_x_3_wire[i + 1]);
+                const std::vector p_x_binary_limbs = { p_x_0, p_x_1, p_x_2, p_x_3 };
+                Fr p_y_lo = get_variable(y_lo_z_2_wire[i]);
+                Fr p_y_hi = get_variable(x_lo_y_hi_wire[i + 1]);
+                Fr p_y_0 = get_variable(p_y_0_p_y_1_wire[i]);
+                Fr p_y_1 = get_variable(p_y_0_p_y_1_wire[i + 1]);
+                Fr p_y_2 = get_variable(p_y_2_p_y_3_wire[i]);
+                Fr p_y_3 = get_variable(p_y_2_p_y_3_wire[i + 1]);
+                const std::vector p_y_binary_limbs = { p_y_0, p_y_1, p_y_2, p_y_3 };
+                Fr z_1 = get_variable(x_hi_z_1_wire[i + 1]);
+                Fr z_2 = get_variable(y_lo_z_2_wire[i + 1]);
+                Fr z_1_lo = get_variable(z_lo_wire[i]);
+                Fr z_2_lo = get_variable(z_lo_wire[i + 1]);
+                Fr z_1_hi = get_variable(z_hi_wire[i]);
+                Fr z_2_hi = get_variable(z_hi_wire[i + 1]);
+                Fr low_wide_relation_limb = get_variable(relation_wide_limbs_wire[i]);
+                Fr high_wide_relation_limb = get_variable(relation_wide_limbs_wire[i + 1]);
+                const std::vector z_1_binary_limbs = { z_1_lo, z_1_hi };
+                const std::vector z_2_binary_limbs = { z_2_lo, z_2_hi };
+                const std::vector current_accumulator_binary_limbs = {
+                    get_variable(accumulators_binary_limbs_0_wire[i]),
+                    get_variable(accumulators_binary_limbs_1_wire[i]),
+                    get_variable(accumulators_binary_limbs_2_wire[i]),
+                    get_variable(accumulators_binary_limbs_3_wire[i]),
+                };
+                const std::vector previous_accumulator_binary_limbs = {
+                    get_variable(accumulators_binary_limbs_0_wire[i + 1]),
+                    get_variable(accumulators_binary_limbs_1_wire[i + 1]),
+                    get_variable(accumulators_binary_limbs_2_wire[i + 1]),
+                    get_variable(accumulators_binary_limbs_3_wire[i + 1]),
+                };
+                const std::vector quotient_binary_limbs = {
+                    get_variable(quotient_low_binary_limbs[i]),
+                    get_variable(quotient_low_binary_limbs[i + 1]),
+                    get_variable(quotient_high_binary_limbs[i]),
+                    get_variable(quotient_high_binary_limbs[i + 1]),
+                };
+
+                // These need to be range constrained, but that logic is not present yet
+                auto p_x_micro_chunks = {
+                    get_sequential_micro_chunks(i, P_X_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, P_X_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i, P_X_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, P_X_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS)
+                };
+                auto p_y_micro_chunks = {
+                    get_sequential_micro_chunks(i, P_Y_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, P_Y_LOW_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i, P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, P_Y_HIGH_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS)
+                };
+                auto z_1_micro_chunks = {
+                    get_sequential_micro_chunks(i, Z_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+
+                    get_sequential_micro_chunks(i, Z_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                };
+
+                auto z_2_micro_chunks = {
+
+                    get_sequential_micro_chunks(i + 1, Z_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, Z_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS)
+                };
+
+                auto current_accumulator_micro_chunks = {
+                    get_sequential_micro_chunks(i, ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, ACCUMULATOR_LO_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i, ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, ACCUMULATOR_HI_LIMBS_RANGE_CONSTRAINT_0, NUM_MICRO_LIMBS),
+                };
+                auto quotient_micro_chunks = {
+                    get_sequential_micro_chunks(i, QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, QUOTIENT_LO_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i, QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS),
+                    get_sequential_micro_chunks(i + 1, QUOTIENT_HI_LIMBS_RANGE_CONSTRAIN_0, NUM_MICRO_LIMBS),
+                };
+
+                // Lambda for checking the correctness of decomposition of values in the Queue into limbs for checking
+                // the relation
+                auto check_wide_limb_into_binary_limb_relation = [](const std::vector<Fr>& wide_limbs,
+                                                                    const std::vector<Fr>& binary_limbs) {
+                    ASSERT(wide_limbs.size() * 2 == binary_limbs.size());
+                    for (size_t i = 0; i < wide_limbs.size(); i++) {
+                        if ((binary_limbs[i * 2] + Fr(SHIFT_1) * binary_limbs[i * 2 + 1]) != wide_limbs[i]) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+                // Check that everything has been decomposed correctly
+                // P.xₗₒ = P.xₗₒ_0 + SHIFT_1 * P.xₗₒ_1
+                // P.xₕᵢ  = P.xₕᵢ_0 + SHIFT_1 * P.xₕᵢ_1
+                // z_1 = z_1ₗₒ + SHIFT_1 * z_1ₕᵢ
+                // z_2 = z_2ₗₒ + SHIFT_2 * z_1ₕᵢ
+                if (!(check_wide_limb_into_binary_limb_relation({ p_x_lo, p_x_hi }, p_x_binary_limbs) &&
+                      check_wide_limb_into_binary_limb_relation({ p_y_lo, p_y_hi }, p_y_binary_limbs) &&
+                      check_wide_limb_into_binary_limb_relation({ z_1 }, z_1_binary_limbs) &&
+                      check_wide_limb_into_binary_limb_relation({ z_2 }, z_2_binary_limbs))) {
+                    return false;
+                }
+
+                // Check that limbs have been decomposed into microlimbs correctly
+                // value = ∑ (2ˡ)ⁱ⋅ chunkᵢ, where 2ˡ is the shift
+                auto check_micro_limb_decomposition_correctness =
+                    [&accumulate_limb_from_micro_chunks](const std::vector<Fr>& binary_limbs,
+                                                         const std::vector<std::vector<Fr>>& micro_limbs) {
+                        ASSERT(binary_limbs.size() == micro_limbs.size());
+                        for (size_t i = 0; i < binary_limbs.size(); i++) {
+                            if (binary_limbs[i] != accumulate_limb_from_micro_chunks(micro_limbs[i])) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    };
+                // Check all micro limb decompositions
+                if (!check_micro_limb_decomposition_correctness(p_x_binary_limbs, p_x_micro_chunks)) {
+                    return false;
+                }
+                if (!check_micro_limb_decomposition_correctness(p_y_binary_limbs, p_y_micro_chunks)) {
+                    return false;
+                }
+                if (!check_micro_limb_decomposition_correctness(z_1_binary_limbs, z_1_micro_chunks)) {
+                    return false;
+                }
+                if (!check_micro_limb_decomposition_correctness(z_2_binary_limbs, z_2_micro_chunks)) {
+                    return false;
+                }
+                if (!check_micro_limb_decomposition_correctness(current_accumulator_binary_limbs,
+                                                                current_accumulator_micro_chunks)) {
+                    return false;
+                }
+                if (!check_micro_limb_decomposition_correctness(quotient_binary_limbs, quotient_micro_chunks)) {
+                    return false;
+                }
+
+                // The logic we are trying to enforce is:
+                // current_accumulator = previous_accumulator ⋅ x + op_code + P.x ⋅ v + P.y ⋅ v² + z_1 ⋅ v³ + z_2 ⋅ v⁴
+                // mod Fq To ensure this we transform the relation into the form: previous_accumulator ⋅ x + op + P.x ⋅
+                // v + P.y ⋅ v² + z_1 ⋅ v³ + z_2 ⋅ v⁴ - quotient ⋅ p - current_accumulator = 0 However, we don't have
+                // integers. Despite that, we can approximate integers for a certain range, if we know that there will
+                // not be any overflows. For now we set the range to 2²⁷² ⋅ r. We can evaluate the logic modulo 2²⁷²
+                // with range constraints and r is native.
+                //
+                // previous_accumulator ⋅ x + op + P.x ⋅ v + P.y ⋅ v² + z_1 ⋅ v³ + z_2 ⋅ v⁴ - quotient ⋅ p -
+                // current_accumulator = 0 =>
+                // 1. previous_accumulator ⋅ x + op + P.x ⋅ v + P.y ⋅ v² + z_1 ⋅ v³ + z_2 ⋅ v⁴ + quotient ⋅ (-p mod
+                // 2²⁷²) - current_accumulator = 0 mod 2²⁷²
+                // 2. previous_accumulator ⋅ x + op + P.x ⋅ v + P.y ⋅ v² + z_1 ⋅ v³ + z_2 ⋅ v⁴ - quotient ⋅ p -
+                // current_accumulator = 0 mod r
+                //
+                // The second relation is straightforward and easy to check. The first, not so much. We have to evaluate
+                // certain bit chunks of the equation and ensure that they are zero. For example, for the lowest limb it
+                // would be (inclusive ranges):
+                //
+                // previous_accumulator[0:67] ⋅ x[0:67] + op + P.x[0:67] ⋅ v[0:67] + P.y[0:67] ⋅ v²[0:67] + z_1[0:67] ⋅
+                // v³[0:67] + z_2[0:67] ⋅ v⁴[0:67] + quotient[0:67] ⋅ (-p mod 2²⁷²)[0:67] - current_accumulator[0:67] =
+                // intermediate_value; (we don't take parts of op, because it's supposed to be between 0 and 3)
+                //
+                // We could check that this intermediate_value is equal to  0 mod 2⁶⁸ by dividing it by 2⁶⁸ and
+                // constraining it. For efficiency, we actually compute wider evaluations for 136 bits, which require us
+                // to also obtain and shift products of [68:135] by [0:67] and [0:67] by [68:135] bits.
+                // The result of division goes into the next evaluation (the same as a carry flag would)
+                // So the lowest wide limb is : (∑everything[0:67]⋅everything[0:67] +
+                // 2⁶⁸⋅(∑everything[0:67]⋅everything[68:135]))/ 2¹³⁶
+                //
+                // The high is:
+                // (low_limb + ∑everything[0:67]⋅everything[136:203] + ∑everything[68:135]⋅everything[68:135] +
+                // 2⁶⁸(∑everything[0:67]⋅everything[204:271] + ∑everything[68:135]⋅everything[136:203])) / 2¹³⁶
+                //
+                // We also limit computation on limbs of op, z_1 and z_2, since we know that op has only the lowest limb
+                // and z_1 and z_2 have only the two lowest limbs
+                Fr low_wide_limb_relation_check =
+
+                    (previous_accumulator_binary_limbs[0] * relation_inputs.x_limbs[0] + op_code +
+                     relation_inputs.v_limbs[0] * p_x_0 + relation_inputs.v_squared_limbs[0] * p_y_0 +
+                     relation_inputs.v_cubed_limbs[0] * z_1_lo + relation_inputs.v_quarted_limbs[0] * z_2_lo +
+                     quotient_binary_limbs[0] * NEGATIVE_MODULUS_LIMBS[0] - current_accumulator_binary_limbs[0]) +
+                    (previous_accumulator_binary_limbs[1] * relation_inputs.x_limbs[0] +
+                     relation_inputs.v_limbs[1] * p_x_0 + relation_inputs.v_squared_limbs[1] * p_y_0 +
+                     relation_inputs.v_cubed_limbs[1] * z_1_lo + relation_inputs.v_quarted_limbs[1] * z_2_lo +
+                     quotient_binary_limbs[1] * NEGATIVE_MODULUS_LIMBS[0] +
+                     previous_accumulator_binary_limbs[0] * relation_inputs.x_limbs[1] +
+                     relation_inputs.v_limbs[0] * p_x_1 + relation_inputs.v_squared_limbs[0] * p_y_1 +
+                     relation_inputs.v_cubed_limbs[0] * z_1_hi + relation_inputs.v_quarted_limbs[0] * z_2_hi +
+                     quotient_binary_limbs[0] * NEGATIVE_MODULUS_LIMBS[1] - current_accumulator_binary_limbs[1]) *
+                        Fr(SHIFT_1);
+                if (low_wide_limb_relation_check != (low_wide_relation_limb * SHIFT_2)) {
+                    return false;
+                }
+                Fr high_wide_relation_limb_check =
+                    low_wide_relation_limb + previous_accumulator_binary_limbs[2] * relation_inputs.x_limbs[0] +
+                    previous_accumulator_binary_limbs[1] * relation_inputs.x_limbs[1] +
+                    previous_accumulator_binary_limbs[0] * relation_inputs.x_limbs[2] +
+                    relation_inputs.v_limbs[2] * p_x_0 + relation_inputs.v_limbs[1] * p_x_1 +
+                    relation_inputs.v_limbs[0] * p_x_2 + relation_inputs.v_squared_limbs[2] * p_y_0 +
+                    relation_inputs.v_squared_limbs[1] * p_y_1 + relation_inputs.v_squared_limbs[0] * p_y_2 +
+                    relation_inputs.v_cubed_limbs[2] * z_1_lo + relation_inputs.v_cubed_limbs[1] * z_1_hi +
+                    relation_inputs.v_quarted_limbs[2] * z_2_lo + relation_inputs.v_quarted_limbs[1] * z_2_hi +
+                    quotient_binary_limbs[2] * NEGATIVE_MODULUS_LIMBS[0] +
+                    quotient_binary_limbs[1] * NEGATIVE_MODULUS_LIMBS[1] +
+                    quotient_binary_limbs[0] * NEGATIVE_MODULUS_LIMBS[2] - current_accumulator_binary_limbs[2] +
+                    (previous_accumulator_binary_limbs[3] * relation_inputs.x_limbs[0] +
+                     previous_accumulator_binary_limbs[2] * relation_inputs.x_limbs[1] +
+                     previous_accumulator_binary_limbs[1] * relation_inputs.x_limbs[2] +
+                     previous_accumulator_binary_limbs[0] * relation_inputs.x_limbs[3] +
+                     relation_inputs.v_limbs[3] * p_x_0 + relation_inputs.v_limbs[2] * p_x_1 +
+                     relation_inputs.v_limbs[1] * p_x_2 + relation_inputs.v_limbs[0] * p_x_3 +
+                     relation_inputs.v_squared_limbs[3] * p_y_0 + relation_inputs.v_squared_limbs[2] * p_y_1 +
+                     relation_inputs.v_squared_limbs[1] * p_y_2 + relation_inputs.v_squared_limbs[0] * p_y_3 +
+                     relation_inputs.v_cubed_limbs[3] * z_1_lo + relation_inputs.v_cubed_limbs[2] * z_1_hi +
+                     relation_inputs.v_quarted_limbs[3] * z_2_lo + relation_inputs.v_quarted_limbs[2] * z_2_hi +
+                     quotient_binary_limbs[3] * NEGATIVE_MODULUS_LIMBS[0] +
+                     quotient_binary_limbs[2] * NEGATIVE_MODULUS_LIMBS[1] +
+                     quotient_binary_limbs[1] * NEGATIVE_MODULUS_LIMBS[2] +
+                     quotient_binary_limbs[0] * NEGATIVE_MODULUS_LIMBS[3] - current_accumulator_binary_limbs[3]) *
+                        SHIFT_1;
+                if (high_wide_relation_limb_check != (high_wide_relation_limb * SHIFT_2)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+};
+} // namespace proof_system
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.test.cpp
new file mode 100644
index 000000000000..b7f90a260369
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.test.cpp
@@ -0,0 +1,432 @@
+#include "barretenberg/ecc/curves/bn254/bn254.hpp"
+#include "goblin_translator_circuit_builder.hpp"
+#include <array>
+#include <cstddef>
+#include <gtest/gtest.h>
+
+using namespace barretenberg;
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+namespace proof_system {
+template <typename Fq, typename Fr>
+GoblinTranslatorCircuitBuilder::AccumulationInput generate_witness_values(
+    Fr op_code, Fr p_x_lo, Fr p_x_hi, Fr p_y_lo, Fr p_y_hi, Fr z_1, Fr z_2, Fq previous_accumulator, Fq v, Fq x)
+{
+    constexpr size_t NUM_LIMB_BITS = GoblinTranslatorCircuitBuilder::NUM_LIMB_BITS;
+    constexpr size_t MICRO_LIMB_BITS = GoblinTranslatorCircuitBuilder::MICRO_LIMB_BITS;
+    constexpr auto shift_1 = GoblinTranslatorCircuitBuilder::SHIFT_1;
+    constexpr auto shift_2 = GoblinTranslatorCircuitBuilder::SHIFT_2;
+    constexpr auto modulus_u512 = GoblinTranslatorCircuitBuilder::MODULUS_U512;
+    constexpr auto neg_modulus_limbs = GoblinTranslatorCircuitBuilder::NEGATIVE_MODULUS_LIMBS;
+    constexpr auto shift_2_inverse = GoblinTranslatorCircuitBuilder::SHIFT_2_INVERSE;
+
+    /**
+     * @brief A small function to transform a native element Fq into its bigfield representation  in Fr scalars
+     *
+     */
+    auto base_element_to_bigfield = [](Fq& original) {
+        uint256_t original_uint = original;
+        return std::array<Fr, 5>({ Fr(original_uint.slice(0, NUM_LIMB_BITS)),
+                                   Fr(original_uint.slice(NUM_LIMB_BITS, 2 * NUM_LIMB_BITS)),
+                                   Fr(original_uint.slice(2 * NUM_LIMB_BITS, 3 * NUM_LIMB_BITS)),
+                                   Fr(original_uint.slice(3 * NUM_LIMB_BITS, 4 * NUM_LIMB_BITS)),
+                                   Fr(original_uint) });
+    };
+    /**
+     * @brief A small function to transform a uint512_t element into its bigfield representation  in Fr scalars
+     *
+     */
+    auto uint512_t_to_bigfield = [&shift_2](uint512_t& original) {
+        return std::make_tuple(Fr(original.slice(0, NUM_LIMB_BITS).lo),
+                               Fr(original.slice(NUM_LIMB_BITS, 2 * NUM_LIMB_BITS).lo),
+                               Fr(original.slice(2 * NUM_LIMB_BITS, 3 * NUM_LIMB_BITS).lo),
+                               Fr(original.slice(3 * NUM_LIMB_BITS, 4 * NUM_LIMB_BITS).lo),
+                               Fr(original.slice(0, NUM_LIMB_BITS * 2).lo) +
+                                   Fr(original.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 4).lo) * shift_2);
+    };
+
+    /**
+     * @brief A method for splitting wide limbs (P_x_lo, P_y_hi, etc) into two limbs
+     *
+     */
+    auto split_wide_limb_into_2_limbs = [](Fr& wide_limb) {
+        return std::make_tuple(Fr(uint256_t(wide_limb).slice(0, NUM_LIMB_BITS)),
+                               Fr(uint256_t(wide_limb).slice(NUM_LIMB_BITS, 2 * NUM_LIMB_BITS)));
+    };
+    auto split_standard_limb_into_micro_limbs = [](Fr& limb) {
+        return std::array<Fr, 6>{
+            uint256_t(limb).slice(0, MICRO_LIMB_BITS),
+            uint256_t(limb).slice(MICRO_LIMB_BITS, 2 * MICRO_LIMB_BITS),
+            uint256_t(limb).slice(2 * MICRO_LIMB_BITS, 3 * MICRO_LIMB_BITS),
+            uint256_t(limb).slice(3 * MICRO_LIMB_BITS, 4 * MICRO_LIMB_BITS),
+            uint256_t(limb).slice(4 * MICRO_LIMB_BITS, 5 * MICRO_LIMB_BITS),
+            uint256_t(limb).slice(5 * MICRO_LIMB_BITS, 6 * MICRO_LIMB_BITS),
+        };
+    };
+    //  x and powers of v are given to use in challenge form, so the verifier has to deal with this :)
+    Fq v_squared;
+    Fq v_cubed;
+    Fq v_quarted;
+    v_squared = v * v;
+    v_cubed = v_squared * v;
+    v_quarted = v_cubed * v;
+
+    // Convert the accumulator, powers of v and x into "bigfield" form
+    auto previous_accumulator_witnesses = base_element_to_bigfield(previous_accumulator);
+    auto v_witnesses = base_element_to_bigfield(v);
+    auto v_squared_witnesses = base_element_to_bigfield(v_squared);
+    auto v_cubed_witnesses = base_element_to_bigfield(v_cubed);
+    auto v_quarted_witnesses = base_element_to_bigfield(v_quarted);
+    auto x_witnesses = base_element_to_bigfield(x);
+
+    // To calculate the quotient, we need to evaluate the expression in integers. So we need uint512_t versions of all
+    // elements involved
+    auto uint_previous_accumulator = uint512_t(previous_accumulator);
+    auto uint_x = uint512_t(x);
+    auto uint_op = uint512_t(op_code);
+    auto uint_p_x = uint512_t(uint256_t(p_x_lo) + (uint256_t(p_x_hi) << (NUM_LIMB_BITS << 1)));
+    auto uint_p_y = uint512_t(uint256_t(p_y_lo) + (uint256_t(p_y_hi) << (NUM_LIMB_BITS << 1)));
+    auto uint_z_1 = uint512_t(z_1);
+    auto uint_z_2 = uint512_t(z_2);
+    auto uint_v = uint512_t(v);
+    auto uint_v_squared = uint512_t(v_squared);
+    auto uint_v_cubed = uint512_t(v_cubed);
+    auto uint_v_quarted = uint512_t(v_quarted);
+
+    // Construct Fq for op, P.x, P.y, z_1, z_2 for use in witness computation
+    Fq base_op = Fq(uint256_t(op_code));
+    Fq base_p_x = Fq(uint256_t(p_x_lo) + (uint256_t(p_x_hi) << (NUM_LIMB_BITS << 1)));
+    Fq base_p_y = Fq(uint256_t(p_y_lo) + (uint256_t(p_y_hi) << (NUM_LIMB_BITS << 1)));
+    Fq base_z_1 = Fq(uint256_t(z_1));
+    Fq base_z_2 = Fq(uint256_t(z_2));
+
+    // Construct bigfield representations of P.x and P.y
+    auto [p_x_0, p_x_1] = split_wide_limb_into_2_limbs(p_x_lo);
+    auto [p_x_2, p_x_3] = split_wide_limb_into_2_limbs(p_x_hi);
+    Fr p_x_prime = p_x_lo + p_x_hi * Fr(shift_2);
+    std::array<Fr, 5> p_x_witnesses = { p_x_0, p_x_1, p_x_2, p_x_3, p_x_prime };
+    auto [p_y_0, p_y_1] = split_wide_limb_into_2_limbs(p_y_lo);
+    auto [p_y_2, p_y_3] = split_wide_limb_into_2_limbs(p_y_hi);
+    Fr p_y_prime = p_y_lo + p_y_hi * Fr(shift_2);
+    std::array<Fr, 5> p_y_witnesses = { p_y_0, p_y_1, p_y_2, p_y_3, p_y_prime };
+
+    // Construct bigfield representations of z1 and z2 only using 2 limbs each
+    // z_1 and z_2 are low enough to act as their own prime limbs
+    auto [z_1_lo, z_1_hi] = split_wide_limb_into_2_limbs(z_1);
+    auto [z_2_lo, z_2_hi] = split_wide_limb_into_2_limbs(z_2);
+
+    // The formula is `accumulator = accumulator⋅x + (op + v⋅p.x + v²⋅p.y + v³⋅z₁ + v⁴z₂)`. We need to compute the
+    // remainder (new accumulator value)
+
+    Fq remainder = previous_accumulator * x + base_z_2 * v_quarted + base_z_1 * v_cubed + base_p_y * v_squared +
+                   base_p_x * v + base_op;
+    uint512_t quotient_by_modulus = uint_previous_accumulator * uint_x + uint_z_2 * uint_v_quarted +
+                                    uint_z_1 * uint_v_cubed + uint_p_y * uint_v_squared + uint_p_x * uint_v + uint_op -
+                                    uint512_t(remainder);
+
+    uint512_t quotient = quotient_by_modulus / uint512_t(Fq::modulus);
+    constexpr uint512_t MAX_CONSTRAINED_SIZE = uint512_t(1) << 254;
+    constexpr uint512_t MAX_Z_SIZE = uint512_t(1) << (NUM_LIMB_BITS * 2);
+    numeric::uint1024_t max_quotient =
+        (uint1024_t(MAX_CONSTRAINED_SIZE) * MAX_CONSTRAINED_SIZE * 3 + MAX_Z_SIZE * MAX_CONSTRAINED_SIZE * 2 + 4) /
+        modulus_u512;
+    info("Max quotient: ", max_quotient);
+    info("Max quotient range constraint: ", max_quotient.get_msb() + 1);
+
+    auto [remainder_0, remainder_1, remainder_2, remainder_3, remainder_prime] = base_element_to_bigfield(remainder);
+    std::array<Fr, 5> remainder_witnesses = { remainder_0, remainder_1, remainder_2, remainder_3, remainder_prime };
+    auto [quotient_0, quotient_1, quotient_2, quotient_3, quotient_prime] = uint512_t_to_bigfield(quotient);
+    std::array<Fr, 5> quotient_witnesses = { quotient_0, quotient_1, quotient_2, quotient_3, quotient_prime };
+
+    // We will divide by shift_2 instantly in the relation itself, but first we need to compute the low part (0*0) and
+    // the high part (0*1, 1*0) multiplied by a signle limb shift
+    Fr low_wide_relation_limb_part_1 =
+        previous_accumulator_witnesses[0] * x_witnesses[0] + op_code + v_witnesses[0] * p_x_witnesses[0] +
+        v_squared_witnesses[0] * p_y_witnesses[0] + v_cubed_witnesses[0] * z_1_lo + v_quarted_witnesses[0] * z_2_lo +
+        quotient_witnesses[0] * neg_modulus_limbs[0] - remainder_witnesses[0]; // This covers the lowest limb
+    info("LW1:", low_wide_relation_limb_part_1);
+    Fr low_wide_relation_limb =
+        low_wide_relation_limb_part_1 +
+        (previous_accumulator_witnesses[1] * x_witnesses[0] + previous_accumulator_witnesses[0] * x_witnesses[1] +
+         v_witnesses[1] * p_x_witnesses[0] + p_x_witnesses[1] * v_witnesses[0] +
+         v_squared_witnesses[1] * p_y_witnesses[0] + v_squared_witnesses[0] * p_y_witnesses[1] +
+         v_cubed_witnesses[1] * z_1_lo + z_1_hi * v_cubed_witnesses[0] + v_quarted_witnesses[1] * z_2_lo +
+         v_quarted_witnesses[0] * z_2_hi + quotient_witnesses[0] * neg_modulus_limbs[1] +
+         quotient_witnesses[1] * neg_modulus_limbs[0] - remainder_witnesses[1]) *
+            shift_1; // And this covers the limb shifted by 68
+    for (auto& limb : quotient_witnesses) {
+        info("Q: ", limb);
+    }
+    // Treating accumulator as 254-bit constrained value
+    constexpr auto max_limb_size = (uint512_t(1) << NUM_LIMB_BITS) - 1;
+    constexpr auto shift_1_u512 = uint512_t(shift_1);
+    constexpr auto op_max_size = uint512_t(4);
+    constexpr uint512_t low_wide_limb_maximum_value =
+        op_max_size + (max_limb_size * max_limb_size) * ((shift_1_u512 * 12) + 6);
+    constexpr uint512_t low_wide_limb_maximum_value_constraint =
+        (low_wide_limb_maximum_value >> (2 * NUM_LIMB_BITS)).lo +
+        uint256_t(uint64_t((low_wide_limb_maximum_value % uint512_t(1) << (2 * NUM_LIMB_BITS)) != 0));
+    constexpr auto low_wide_limb_range_consraint_size = low_wide_limb_maximum_value_constraint.get_msb() + 1;
+    info("Low limb range constraint: ", low_wide_limb_range_consraint_size);
+    // Low bits have to be zero
+    ASSERT(uint256_t(low_wide_relation_limb).slice(0, 2 * NUM_LIMB_BITS) == 0);
+
+    Fr low_wide_relation_limb_divided = low_wide_relation_limb * shift_2_inverse;
+    // We need to range constrain the low_wide_relation_limb_divided
+    constexpr size_t NUM_LAST_BN254_LIMB_BITS = modulus_u512.get_msb() + 1 - NUM_LIMB_BITS * 3;
+
+    constexpr auto max_high_limb_size = (uint512_t(1) << NUM_LAST_BN254_LIMB_BITS) - 1;
+    constexpr uint512_t high_wide_limb_maximum_value =
+        low_wide_limb_maximum_value_constraint + (max_limb_size * max_limb_size) * 16 +
+        (max_limb_size * max_limb_size * 10 + max_limb_size * max_high_limb_size * 10) * shift_1_u512;
+    constexpr uint512_t high_wide_limb_maximum_value_constraint =
+        (high_wide_limb_maximum_value >> (2 * NUM_LIMB_BITS)).lo +
+        uint256_t(uint64_t((high_wide_limb_maximum_value % uint512_t(1) << (2 * NUM_LIMB_BITS)) != 0));
+    constexpr auto high_wide_limb_range_constraint_size = high_wide_limb_maximum_value_constraint.get_msb() + 1;
+    info(high_wide_limb_range_constraint_size);
+    // 4 high combinations = 8 ml*ml + 8 ml*last_ml. 2 low combinations = 2*ml*ml + 2*ml*last_ml
+    Fr high_wide_relation_limb =
+        low_wide_relation_limb_divided + previous_accumulator_witnesses[2] * x_witnesses[0] +
+        previous_accumulator_witnesses[1] * x_witnesses[1] + previous_accumulator_witnesses[0] * x_witnesses[2] +
+        v_witnesses[2] * p_x_witnesses[0] + v_witnesses[1] * p_x_witnesses[1] + v_witnesses[0] * p_x_witnesses[2] +
+        v_squared_witnesses[2] * p_y_witnesses[0] + v_squared_witnesses[1] * p_y_witnesses[1] +
+        v_squared_witnesses[0] * p_y_witnesses[2] + v_cubed_witnesses[2] * z_1_lo + v_cubed_witnesses[1] * z_1_hi +
+        v_quarted_witnesses[2] * z_2_lo + v_quarted_witnesses[1] * z_2_hi +
+        quotient_witnesses[2] * neg_modulus_limbs[0] + quotient_witnesses[1] * neg_modulus_limbs[1] +
+        quotient_witnesses[0] * neg_modulus_limbs[2] - remainder_witnesses[2] +
+        (previous_accumulator_witnesses[3] * x_witnesses[0] + previous_accumulator_witnesses[2] * x_witnesses[1] +
+         previous_accumulator_witnesses[1] * x_witnesses[2] + previous_accumulator_witnesses[0] * x_witnesses[3] +
+         v_witnesses[3] * p_x_witnesses[0] + v_witnesses[2] * p_x_witnesses[1] + v_witnesses[1] * p_x_witnesses[2] +
+         v_witnesses[0] * p_x_witnesses[3] + v_squared_witnesses[3] * p_y_witnesses[0] +
+         v_squared_witnesses[2] * p_y_witnesses[1] + v_squared_witnesses[1] * p_y_witnesses[2] +
+         v_squared_witnesses[0] * p_y_witnesses[3] + v_cubed_witnesses[3] * z_1_lo + v_cubed_witnesses[2] * z_1_hi +
+         v_quarted_witnesses[3] * z_2_lo + v_quarted_witnesses[2] * z_2_hi +
+         quotient_witnesses[3] * neg_modulus_limbs[0] + quotient_witnesses[2] * neg_modulus_limbs[1] +
+         quotient_witnesses[1] * neg_modulus_limbs[2] + quotient_witnesses[0] * neg_modulus_limbs[3] -
+         remainder_witnesses[3]) *
+            shift_1;
+    info("Value: ", high_wide_relation_limb);
+    info("Value: ", high_wide_relation_limb * shift_2_inverse);
+    ASSERT(uint256_t(high_wide_relation_limb).slice(0, 2 * NUM_LIMB_BITS) == 0);
+
+    GoblinTranslatorCircuitBuilder::AccumulationInput input{
+        .op_code = op_code,
+        .P_x_lo = p_x_lo,
+        .P_x_hi = p_x_hi,
+        .P_x_limbs = p_x_witnesses,
+        .P_x_microlimbs = {},
+        .P_y_lo = p_y_lo,
+        .P_y_hi = p_y_hi,
+        .P_y_limbs = p_y_witnesses,
+        .P_y_microlimbs = {},
+        .z_1 = z_1,
+        .z_1_limbs = { z_1_lo, z_1_hi },
+        .z_1_microlimbs = {},
+        .z_2 = z_2,
+        .z_2_limbs = { z_2_lo, z_2_hi },
+        .z_2_microlimbs = {},
+        .previous_accumulator = previous_accumulator_witnesses,
+        .current_accumulator = remainder_witnesses,
+        .current_accumulator_microlimbs = {},
+        .quotient_binary_limbs = quotient_witnesses,
+        .quotient_microlimbs = {},
+        .relation_wide_limbs = { low_wide_relation_limb_divided, high_wide_relation_limb * shift_2_inverse },
+        .x_limbs = x_witnesses,
+        .v_limbs = v_witnesses,
+        .v_squared_limbs = v_squared_witnesses,
+        .v_cubed_limbs = v_cubed_witnesses,
+        .v_quarted_limbs = v_quarted_witnesses,
+
+    };
+    for (size_t i = 0; i < GoblinTranslatorCircuitBuilder::NUM_BINARY_LIMBS; i++) {
+        input.P_x_microlimbs[i] = split_standard_limb_into_micro_limbs(input.P_x_limbs[i]);
+    }
+    for (size_t i = 0; i < GoblinTranslatorCircuitBuilder::NUM_BINARY_LIMBS; i++) {
+        input.P_y_microlimbs[i] = split_standard_limb_into_micro_limbs(input.P_y_limbs[i]);
+    }
+
+    for (size_t i = 0; i < GoblinTranslatorCircuitBuilder::NUM_Z_LIMBS; i++) {
+        input.z_1_microlimbs[i] = split_standard_limb_into_micro_limbs(input.z_1_limbs[i]);
+        input.z_2_microlimbs[i] = split_standard_limb_into_micro_limbs(input.z_2_limbs[i]);
+    }
+    for (size_t i = 0; i < GoblinTranslatorCircuitBuilder::NUM_BINARY_LIMBS; i++) {
+        input.current_accumulator_microlimbs[i] = split_standard_limb_into_micro_limbs(input.current_accumulator[i]);
+        // info("Stored: ", single_accumulation_step.current_accumulator_microlimbs[i][5], " at ", i);
+    }
+    for (size_t i = 0; i < GoblinTranslatorCircuitBuilder::NUM_BINARY_LIMBS; i++) {
+        input.quotient_microlimbs[i] = split_standard_limb_into_micro_limbs(input.quotient_binary_limbs[i]);
+        // info("Stored: ", single_accumulation_step.current_accumulator_microlimbs[i][5], " at ", i);
+    }
+    return input;
+}
+TEST(translator_circuit_builder, scoping_out_the_circuit)
+{
+    // Questions:
+    // 1. Do we need 68-bit limbs at all?
+    using Fr = ::curve::BN254::ScalarField;
+    using Fq = ::curve::BN254::BaseField;
+
+    constexpr size_t NUM_LIMB_BITS = 68;
+
+    constexpr std::array<Fr, 5> neg_modulus_limbs = GoblinTranslatorCircuitBuilder::NEGATIVE_MODULUS_LIMBS;
+    // x is the value (challenge) at which we are evaluating the polynomials
+    // y is the end result of the whole combination (I don't know why we use y for domain and x for evalutation in
+    // the pepe paper) v is the polynomial batching challenge
+
+    // 2 rows:
+    // OP | P.xₗₒ | P.xₕᵢ | P.yₗₒ
+    // -  | P.yₕᵢ | z₁    | z₂
+
+    // Rows written vertically:
+    // 0	 |  -       |   OP      |
+    // 1	 |  P.yₕᵢ   |   P.xₗₒ   |
+    // 2	 |  z₁      |   P.xₕᵢ   |
+    // 3	 |  z₂      |   P.yₗₒ   |
+    // 4	 |  p_x_1   |   p_x_0   | 68-bit limbs
+    // 5	 |  p_x_1_0 |   p_x_0_0 | 12 bit limbs
+    // 6	 |  p_x_1_1 |   p_x_0_1 | 12 bit limbs
+    // 7	 |  p_x_1_2 |   p_x_0_2 | 12 bit limbs
+    // 8	 |  p_x_1_3 |   p_x_0_3 | 12 bit limbs
+    // 9	 |  p_x_1_4 |   p_x_0_4 | 12 bit limbs
+    // 10	 |  p_x_1_5 |   p_x_0_5 | 8 bit limns
+    // 11	 |  p_x_3   |   p_x_2   | 68-bit limbs
+    // 12	 |  p_x_3_0 |   p_x_2_0 | 12 bit limbs
+    // 13	 |  p_x_3_1 |   p_x_2_1 | 12 bit limbs
+    // 14	 |  p_x_3_2 |   p_x_2_2 | 12 bit limbs
+    // 15	 |  p_x_3_3 |   p_x_2_3 | 12 bit limbs
+    // 16	 |  p_x_3_4 |   p_x_2_4 | p_x_3_4 is 2 bits and enforced with a relation. p_x_2_4 is 12 bits
+    // 17	 |  -       |   p_x_2_5 | 8 bit limb
+    // 18	 |  p_y_1   |   p_y_0   | 68-bit limbs
+    // 19	 |  p_y_1_0 |   p_y_0_0 | 12 bit limbs
+    // 20	 |  p_y_1_1 |   p_y_0_1 | 12 bit limbs
+    // 21	 |  p_y_1_2 |   p_y_0_2 | 12 bit limbs
+    // 22	 |  p_y_1_3 |   p_y_0_3 | 12 bit limbs
+    // 23	 |  p_y_1_4 |   p_y_0_4 | 12 bit limbs
+    // 24	 |  p_y_1_5 |   p_y_0_5 | 8 bit limns
+    // 25	 |  p_y_3   |   p_y_2   | 68-bit limbs
+    // 26	 |  p_y_3_0 |   p_y_2_0 | 12 bit limbs
+    // 27	 |  p_y_3_1 |   p_y_2_1 | 12 bit limbs
+    // 28	 |  p_y_3_2 |   p_y_2_2 | 12 bit limbs
+    // 29	 |  p_y_3_3 |   p_y_2_3 | 12 bit limbs
+    // 30	 |  p_y_3_4 |   p_y_2_4 | p_y_3_4 is 2 bits and enforced with a relation. p_y_2_4 is 12 bits
+    // 31	 |  -       |   p_y_2_5 | 8 bit limb
+    // 32	 |  z_1_hi  |   z_1_lo  | 68 bit limbs
+    // 33	 |  z_1_hi_0|   z_1_lo_0| 12 bit limbs
+    // 34	 |  z_1_hi_1|   z_1_lo_1| 12 bit limbs
+    // 35	 |  z_1_hi_2|   z_1_lo_2| 12 bit limbs
+    // 36	 |  z_1_hi_3|   z_1_lo_3| 12 bit limbs
+    // 37	 |  z_1_hi_4|   z_1_lo_4| 12 bit limbs
+    // 38	 |  z_1_hi_5|   z_1_lo_5| 8 bit limbs
+    // 39	 |  z_2_hi  |   z_2_lo  | 68 bit limbs
+    // 40	 |  z_2_hi_0|   z_2_lo_0| 12 bit limbs
+    // 41	 |  z_2_hi_1|   z_2_lo_1| 12 bit limbs
+    // 42	 |  z_2_hi_2|   z_2_lo_2| 12 bit limbs
+    // 43	 |  z_2_hi_3|   z_2_lo_3| 12 bit limbs
+    // 44	 |  z_2_hi_4|   z_2_lo_4| 12 bit limbs
+    // 45	 |  z_2_hi_5|   z_2_lo_5| 8 bit limbs
+    // 46	 |  Aₚᵣₑᵥ_₀ |   A₀      | 68
+    // 47	 |  Aₚᵣₑᵥ_₁ |   A₁      | 68
+    // 48	 |  Aₚᵣₑᵥ_₂ |   A₂      | 68
+    // 49	 |  Aₚᵣₑᵥ_₃ |   A₃      | 68
+    // 50	 |  A_1_0   |   A_0_0   | 12
+    // 51	 |  A_1_1   |   A_0_1   | 12
+    // 52	 |  A_1_2   |   A_0_2   | 12
+    // 53	 |  A_1_3   |   A_0_3   | 12
+    // 54	 |  A_1_4   |   A_0_4   | 12
+    // 55	 |  A_1_5   |   A_0_5   | 8
+    // 56	 |  A_3_0   |   A_2_0   | 12
+    // 57	 |  A_3_1   |   A_2_1   | 12
+    // 58	 |  A_3_2   |   A_2_2   | 12
+    // 59	 |  A_3_3   |   A_2_3   | 12
+    // 60	 |  A_3_4   |   A_2_4   | 2/12
+    // 61	 |  -       |   A_2_5   | 12
+    // 62    |  Q_1     |   Q_0     | 68
+    // 63    |  Q_1_0   |   Q_0_0   | 12
+    // 64    |  Q_1_1   |   Q_0_1   | 12
+    // 65    |  Q_1_2   |   Q_0_2   | 12
+    // 66    |  Q_1_3   |   Q_0_3   | 12
+    // 67    |  Q_1_4   |   Q_0_4   | 12
+    // 68    |  Q_1_5   |   Q_0_5   | 8
+    // 69    |  Q_3     |   Q_2     | 68
+    // 70    |  Q_3_0   |   Q_2_0   | 12
+    // 71    |  Q_3_1   |   Q_2_1   | 12
+    // 72    |  Q_3_2   |   Q_2_2   | 12
+    // 73    |  Q_3_3   |   Q_2_3   | 12
+    // 74    |  Q_3_4   |   Q_2_4   | 4
+    // 75    |  -       |   Q_2_5   | 8
+    Fr op;
+    Fr p_x_lo;
+    Fr p_x_hi;
+    Fr p_y_lo;
+    Fr p_y_hi;
+    Fr z_1;
+    Fr z_2;
+    op = Fr::random_element();
+    auto get_random_wide_limb = []() { return Fr(engine.get_random_uint256() >> (256 - NUM_LIMB_BITS * 2)); };
+    auto get_random_shortened_wide_limb = []() { return uint256_t(Fq::random_element()) >> (NUM_LIMB_BITS * 2); };
+    p_x_lo = get_random_wide_limb();
+    p_x_hi = get_random_shortened_wide_limb();
+    p_y_lo = get_random_wide_limb();
+    p_y_hi = get_random_shortened_wide_limb();
+    z_1 = get_random_wide_limb();
+    z_2 = get_random_wide_limb();
+
+    Fq accumulator;
+    accumulator = Fq::random_element();
+    Fq v = Fq::random_element();
+    Fq x = Fq::random_element();
+    // p_y_lo = get_random_wide_limb();
+    //  Creating a bigfield representation from (binary_limb_0, binary_limb_1, binary_limb_2, binary_limb_3, prime_limb)
+
+    // Range constrain all the individual limbs
+
+    // Low bits have to be zero
+    // And we'll need to range constrain it
+    // 68 can be treated as 12/12/12/12/12/8
+    // 68 can be treated as 12/12/12/12/12/8
+    GoblinTranslatorCircuitBuilder::AccumulationInput witnesses =
+        generate_witness_values(op, p_x_lo, p_x_hi, p_y_lo, p_y_hi, z_1, z_2, accumulator, v, x);
+    // Prime relation
+    Fr prime_relation = witnesses.previous_accumulator[4] * witnesses.x_limbs[4] + witnesses.op_code +
+                        witnesses.v_limbs[4] * witnesses.P_x_limbs[4] +
+                        witnesses.v_squared_limbs[4] * witnesses.P_y_limbs[4] + witnesses.v_cubed_limbs[4] * z_1 +
+                        witnesses.v_quarted_limbs[4] * z_2 + witnesses.quotient_binary_limbs[4] * neg_modulus_limbs[4] -
+                        witnesses.current_accumulator[4];
+    EXPECT_EQ(prime_relation, 0);
+}
+
+TEST(translator_circuit_builder, circuit_builder_base_case)
+{
+    // Questions:
+    // 1. Do we need 68-bit limbs at all?
+    using Fr = ::curve::BN254::ScalarField;
+    using Fq = ::curve::BN254::BaseField;
+    // using Fq = ::curve::BN254::BaseField;
+
+    constexpr size_t NUM_LIMB_BITS = GoblinTranslatorCircuitBuilder::NUM_LIMB_BITS;
+
+    Fr op;
+    op = Fr(engine.get_random_uint8() & 3);
+    auto get_random_wide_limb = []() { return Fr(engine.get_random_uint256().slice(0, 2 * NUM_LIMB_BITS)); };
+    //  auto get_random_shortened_wide_limb = []() { return uint256_t(Fq::random_element()) >> (NUM_LIMB_BITS * 2); };
+    Fq p_x = Fq::random_element();
+    Fr p_x_lo = uint256_t(p_x).slice(0, 2 * NUM_LIMB_BITS);
+    Fr p_x_hi = uint256_t(p_x).slice(2 * NUM_LIMB_BITS, 4 * NUM_LIMB_BITS);
+    Fq p_y = Fq::random_element();
+    Fr p_y_lo = uint256_t(p_y).slice(0, 2 * NUM_LIMB_BITS);
+    Fr p_y_hi = uint256_t(p_y).slice(2 * NUM_LIMB_BITS, 4 * NUM_LIMB_BITS);
+    Fr z_1 = get_random_wide_limb();
+    Fr z_2 = get_random_wide_limb();
+    Fq v = Fq::random_element();
+    Fq x = Fq::random_element();
+
+    Fq previous_accumulator = Fq::random_element();
+    GoblinTranslatorCircuitBuilder::AccumulationInput single_accumulation_step =
+        generate_witness_values(op, p_x_lo, p_x_hi, p_y_lo, p_y_hi, z_1, z_2, previous_accumulator, v, x);
+
+    auto circuit_builder = GoblinTranslatorCircuitBuilder();
+    circuit_builder.create_accumulation_gate(single_accumulation_step);
+    EXPECT_TRUE(circuit_builder.check_circuit(x, v));
+}
+} // namespace proof_system
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.cpp
index 025699f52193..100e4045706a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.cpp
@@ -301,14 +301,14 @@ std::vector<uint32_t> StandardCircuitBuilder_<FF>::decompose_into_base4_accumula
 }
 
 template <typename FF>
-accumulator_triple StandardCircuitBuilder_<FF>::create_logic_constraint(const uint32_t a,
-                                                                        const uint32_t b,
-                                                                        const size_t num_bits,
-                                                                        const bool is_xor_gate)
+accumulator_triple_<FF> StandardCircuitBuilder_<FF>::create_logic_constraint(const uint32_t a,
+                                                                             const uint32_t b,
+                                                                             const size_t num_bits,
+                                                                             const bool is_xor_gate)
 {
     this->assert_valid_variables({ a, b });
 
-    accumulator_triple accumulators;
+    accumulator_triple_<FF> accumulators;
 
     const uint256_t left_witness_value(this->get_variable(a));
     const uint256_t right_witness_value(this->get_variable(b));
@@ -457,17 +457,17 @@ template <typename FF> uint32_t StandardCircuitBuilder_<FF>::put_constant_variab
 }
 
 template <typename FF>
-accumulator_triple StandardCircuitBuilder_<FF>::create_and_constraint(const uint32_t a,
-                                                                      const uint32_t b,
-                                                                      const size_t num_bits)
+accumulator_triple_<FF> StandardCircuitBuilder_<FF>::create_and_constraint(const uint32_t a,
+                                                                           const uint32_t b,
+                                                                           const size_t num_bits)
 {
     return create_logic_constraint(a, b, num_bits, false);
 }
 
 template <typename FF>
-accumulator_triple StandardCircuitBuilder_<FF>::create_xor_constraint(const uint32_t a,
-                                                                      const uint32_t b,
-                                                                      const size_t num_bits)
+accumulator_triple_<FF> StandardCircuitBuilder_<FF>::create_xor_constraint(const uint32_t a,
+                                                                           const uint32_t b,
+                                                                           const size_t num_bits)
 {
     return create_logic_constraint(a, b, num_bits, true);
 }
@@ -494,13 +494,16 @@ template <typename FF> bool StandardCircuitBuilder_<FF>::check_circuit()
     FF gate_sum;
     FF left, right, output;
     for (size_t i = 0; i < this->num_gates; i++) {
+
         gate_sum = FF::zero();
         left = this->get_variable(w_l[i]);
         right = this->get_variable(w_r[i]);
         output = this->get_variable(w_o[i]);
         gate_sum = q_m[i] * left * right + q_1[i] * left + q_2[i] * right + q_3[i] * output + q_c[i];
-        if (!gate_sum.is_zero())
+        if (!gate_sum.is_zero()) {
+            info("gate number", i);
             return false;
+        }
     }
     return true;
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp
index a30bf488e19c..2c0230016090 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp
@@ -84,7 +84,7 @@ template <typename FF> class StandardCircuitBuilder_ : public CircuitBuilderBase
                                                const fixed_group_init_quad_<FF>& init);
     void create_fixed_group_add_gate_final(const add_quad_<FF>& in);
 
-    fixed_group_add_quad previous_add_quad;
+    fixed_group_add_quad_<FF> previous_add_quad;
 
     // TODO(#216)(Adrian): This should be a virtual overridable method in the base class.
     void fix_witness(const uint32_t witness_index, const FF& witness_value);
@@ -100,12 +100,12 @@ template <typename FF> class StandardCircuitBuilder_ : public CircuitBuilderBase
         decompose_into_base4_accumulators(variable_index, num_bits, msg);
     }
 
-    accumulator_triple create_logic_constraint(const uint32_t a,
-                                               const uint32_t b,
-                                               const size_t num_bits,
-                                               bool is_xor_gate);
-    accumulator_triple create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
-    accumulator_triple create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_logic_constraint(const uint32_t a,
+                                                    const uint32_t b,
+                                                    const size_t num_bits,
+                                                    bool is_xor_gate);
+    accumulator_triple_<FF> create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
 
     // TODO(#216)(Adrian): The 2 following methods should be virtual in the base class
     uint32_t put_constant_variable(const FF& variable);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.test.cpp
index c263b13f8bee..2eb80bb438ad 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/standard_circuit_builder.test.cpp
@@ -24,11 +24,47 @@ TEST(standard_circuit_constructor, base_case)
 
 TEST(standard_circuit_constructor, grumpkin_base_case)
 {
-    StandardGrumpkinCircuitBuilder composer = StandardGrumpkinCircuitBuilder();
+    StandardGrumpkinCircuitBuilder circuit_constructor = StandardGrumpkinCircuitBuilder();
     grumpkin::fr a = grumpkin::fr::one();
-    composer.add_public_variable(a);
+    circuit_constructor.add_public_variable(a);
+    grumpkin::fr b = grumpkin::fr::one();
+    grumpkin::fr c = a + b;
+    grumpkin::fr d = a + c;
+    uint32_t a_idx = circuit_constructor.add_variable(a);
+    uint32_t b_idx = circuit_constructor.add_variable(b);
+    uint32_t c_idx = circuit_constructor.add_variable(c);
+    uint32_t d_idx = circuit_constructor.add_variable(d);
+
+    uint32_t w_l_2_idx = circuit_constructor.add_variable(2);
+    uint32_t w_r_2_idx = circuit_constructor.add_variable(2);
+    uint32_t w_o_2_idx = circuit_constructor.add_variable(4);
+    circuit_constructor.create_mul_gate({ w_l_2_idx, w_r_2_idx, w_o_2_idx, 1, -1, 0 });
+
+    circuit_constructor.create_add_gate({ a_idx,
+                                          b_idx,
+                                          c_idx,
+                                          grumpkin::fr::one(),
+                                          grumpkin::fr::one(),
+                                          grumpkin::fr::neg_one(),
+                                          grumpkin::fr::zero() });
+
+    circuit_constructor.create_add_gate({ d_idx,
+                                          c_idx,
+                                          a_idx,
+                                          grumpkin::fr::one(),
+                                          grumpkin::fr::neg_one(),
+                                          grumpkin::fr::neg_one(),
+                                          grumpkin::fr::zero() });
+
+    circuit_constructor.create_add_gate({ d_idx,
+                                          c_idx,
+                                          b_idx,
+                                          grumpkin::fr::one(),
+                                          grumpkin::fr::neg_one(),
+                                          grumpkin::fr::neg_one(),
+                                          grumpkin::fr::zero() });
 
-    bool result = composer.check_circuit();
+    bool result = circuit_constructor.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -229,7 +265,7 @@ TEST(standard_circuit_constructor, and_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
+        auto accumulators =
             circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
         // circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
@@ -297,7 +333,7 @@ TEST(standard_circuit_constructor, xor_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
+        auto accumulators =
             circuit_constructor.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
@@ -361,17 +397,16 @@ TEST(standard_circuit_constructor, big_add_gate_with_bit_extract)
         uint32_t input = engine.get_random_uint32();
         uint32_t output = input + (quad_value > 1 ? 1 : 0);
 
-        add_quad gate{ circuit_constructor.add_variable(uint256_t(input)),
-                       circuit_constructor.add_variable(uint256_t(output)),
-                       right_idx,
-                       left_idx,
-                       fr(6),
-                       -fr(6),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-
-        circuit_constructor.create_big_add_gate_with_bit_extraction(gate);
+        circuit_constructor.create_big_add_gate_with_bit_extraction(
+            { circuit_constructor.add_variable(uint256_t(input)),
+              circuit_constructor.add_variable(uint256_t(output)),
+              right_idx,
+              left_idx,
+              fr(6),
+              -fr(6),
+              fr::zero(),
+              fr::zero(),
+              fr::zero() });
     };
 
     generate_constraints(0);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.cpp
index 3bfb16c48cf0..ba7a5d213ce9 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.cpp
@@ -33,7 +33,7 @@ TurboCircuitBuilder_<FF>::TurboCircuitBuilder_(const size_t size_hint)
  * @param in Specifies addition gate parameters:
  * w_l, w_r, w_o, q_1, q_2, q_3, q_c.
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_add_gate(const add_triple& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_add_gate(const add_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -64,7 +64,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_add_gate(const add_
  * @param in Specifies addition gate parameters:
  * w_l, w_r, w_o, w_4, q_1, q_2, q_3, q_4, q_c.
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate(const add_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate(const add_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -102,7 +102,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate(const
  * ensure this assumption is backed by a constraint (e.g., c and d could be accumulators produced using the TurboPLONK
  * function `decompose_into_base4_accumulators`).
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate_with_bit_extraction(const add_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate_with_bit_extraction(const add_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -124,7 +124,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_big_add_gate_with_b
     ++this->num_gates;
 }
 
-template <typename FF> void TurboCircuitBuilder_<FF>::create_big_mul_gate(const mul_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_big_mul_gate(const mul_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -163,7 +163,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_big_mul_gate(const
  * @warning Even with the constraint on w_3, it is typically necessary to range constrain the wire value that will be
  * returned.
  */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_balanced_add_gate(const add_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_balanced_add_gate(const add_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -194,7 +194,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_balanced_add_gate(c
  * @param in Contains the values for w_l, w_r, w_o,
  * q_m, q_3, q_c.
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_mul_gate(const mul_triple& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_mul_gate(const mul_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -255,7 +255,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_bool_gate(const uin
  * @param in Contains the values for
  * w_l, w_r, w_o, q_m, q_1, q_2, q_3, q_c.
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_poly_gate(const poly_triple& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_poly_gate(const poly_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -283,7 +283,7 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_poly_gate(const pol
  *
  * @param in Witnesses and values of two points.
  * */
-template <typename FF> void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate(const fixed_group_add_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate(const fixed_group_add_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -314,8 +314,8 @@ template <typename FF> void TurboCircuitBuilder_<FF>::create_fixed_group_add_gat
  * @param init Initialization parameters (points).
  * */
 template <typename FF>
-void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate_with_init(const fixed_group_add_quad& in,
-                                                                     const fixed_group_init_quad& init)
+void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate_with_init(const fixed_group_add_quad_<FF>& in,
+                                                                     const fixed_group_init_quad_<FF>& init)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -339,7 +339,7 @@ void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate_with_init(const fixed
     ++this->num_gates;
 }
 
-template <typename FF> void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate_final(const add_quad& in)
+template <typename FF> void TurboCircuitBuilder_<FF>::create_fixed_group_add_gate_final(const add_quad_<FF>& in)
 {
     create_big_add_gate(in);
 }
@@ -563,10 +563,10 @@ std::vector<uint32_t> TurboCircuitBuilder_<FF>::decompose_into_base4_accumulator
  * The same holds, mutatis mutandis, for T.right.
  */
 template <typename FF>
-accumulator_triple TurboCircuitBuilder_<FF>::create_logic_constraint(const uint32_t a,
-                                                                     const uint32_t b,
-                                                                     const size_t num_bits,
-                                                                     const bool is_xor_gate)
+accumulator_triple_<FF> TurboCircuitBuilder_<FF>::create_logic_constraint(const uint32_t a,
+                                                                          const uint32_t b,
+                                                                          const size_t num_bits,
+                                                                          const bool is_xor_gate)
 {
     this->assert_valid_variables({ a, b });
 
@@ -647,7 +647,7 @@ accumulator_triple TurboCircuitBuilder_<FF>::create_logic_constraint(const uint3
     const uint256_t left_witness_value(this->get_variable(a));
     const uint256_t right_witness_value(this->get_variable(b));
 
-    accumulator_triple accumulators;
+    accumulator_triple_<FF> accumulators;
     FF left_accumulator = FF::zero();
     FF right_accumulator = FF::zero();
     FF out_accumulator = FF::zero();
@@ -751,17 +751,17 @@ accumulator_triple TurboCircuitBuilder_<FF>::create_logic_constraint(const uint3
 }
 
 template <typename FF>
-accumulator_triple TurboCircuitBuilder_<FF>::create_and_constraint(const uint32_t a,
-                                                                   const uint32_t b,
-                                                                   const size_t num_bits)
+accumulator_triple_<FF> TurboCircuitBuilder_<FF>::create_and_constraint(const uint32_t a,
+                                                                        const uint32_t b,
+                                                                        const size_t num_bits)
 {
     return create_logic_constraint(a, b, num_bits, false);
 }
 
 template <typename FF>
-accumulator_triple TurboCircuitBuilder_<FF>::create_xor_constraint(const uint32_t a,
-                                                                   const uint32_t b,
-                                                                   const size_t num_bits)
+accumulator_triple_<FF> TurboCircuitBuilder_<FF>::create_xor_constraint(const uint32_t a,
+                                                                        const uint32_t b,
+                                                                        const size_t num_bits)
 {
     return create_logic_constraint(a, b, num_bits, true);
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp
index 9ec56e68df7e..7ab81feef2d3 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp
@@ -54,19 +54,20 @@ template <typename FF> class TurboCircuitBuilder_ : public CircuitBuilderBase<ar
     };
     ~TurboCircuitBuilder_() {}
 
-    void create_add_gate(const add_triple& in);
+    void create_add_gate(const add_triple_<FF>& in);
 
-    void create_big_add_gate(const add_quad& in);
-    void create_big_add_gate_with_bit_extraction(const add_quad& in);
-    void create_big_mul_gate(const mul_quad& in);
-    void create_balanced_add_gate(const add_quad& in);
+    void create_big_add_gate(const add_quad_<FF>& in);
+    void create_big_add_gate_with_bit_extraction(const add_quad_<FF>& in);
+    void create_big_mul_gate(const mul_quad_<FF>& in);
+    void create_balanced_add_gate(const add_quad_<FF>& in);
 
-    void create_mul_gate(const mul_triple& in);
+    void create_mul_gate(const mul_triple_<FF>& in);
     void create_bool_gate(const uint32_t a);
-    void create_poly_gate(const poly_triple& in);
-    void create_fixed_group_add_gate(const fixed_group_add_quad& in);
-    void create_fixed_group_add_gate_with_init(const fixed_group_add_quad& in, const fixed_group_init_quad& init);
-    void create_fixed_group_add_gate_final(const add_quad& in);
+    void create_poly_gate(const poly_triple_<FF>& in);
+    void create_fixed_group_add_gate(const fixed_group_add_quad_<FF>& in);
+    void create_fixed_group_add_gate_with_init(const fixed_group_add_quad_<FF>& in,
+                                               const fixed_group_init_quad_<FF>& init);
+    void create_fixed_group_add_gate_final(const add_quad_<FF>& in);
     void fix_witness(const uint32_t witness_index, const FF& witness_value);
 
     FF arithmetic_gate_evaluation(const size_t index, const FF alpha_base);
@@ -90,12 +91,12 @@ template <typename FF> class TurboCircuitBuilder_ : public CircuitBuilderBase<ar
         decompose_into_base4_accumulators(variable_index, num_bits, msg);
     }
 
-    accumulator_triple create_logic_constraint(const uint32_t a,
-                                               const uint32_t b,
-                                               const size_t num_bits,
-                                               bool is_xor_gate);
-    accumulator_triple create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
-    accumulator_triple create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_logic_constraint(const uint32_t a,
+                                                    const uint32_t b,
+                                                    const size_t num_bits,
+                                                    bool is_xor_gate);
+    accumulator_triple_<FF> create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
 
     uint32_t put_constant_variable(const FF& variable);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.test.cpp
index 6b84323572aa..27b3398651b7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/turbo_circuit_builder.test.cpp
@@ -221,16 +221,11 @@ TEST(turbo_circuit_constructor, small_scalar_multipliers)
     }
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
-
     TurboCircuitBuilder circuit_constructor = TurboCircuitBuilder();
 
     fr x_alpha = accumulator_offset;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<barretenberg::fr> round_quad;
         round_quad.d = circuit_constructor.add_variable(accumulator_transcript[i]);
         round_quad.a = circuit_constructor.add_variable(multiplication_transcript[i].x);
         round_quad.b = circuit_constructor.add_variable(multiplication_transcript[i].y);
@@ -248,20 +243,23 @@ TEST(turbo_circuit_constructor, small_scalar_multipliers)
         if (i > 0) {
             circuit_constructor.create_fixed_group_add_gate(round_quad);
         } else {
-            circuit_constructor.create_fixed_group_add_gate_with_init(round_quad, init_quad);
+            circuit_constructor.create_fixed_group_add_gate_with_init(round_quad,
+                                                                      { origin_points[0].x,
+                                                                        (origin_points[0].x - origin_points[1].x),
+                                                                        origin_points[0].y,
+                                                                        (origin_points[0].y - origin_points[1].y) });
         }
     }
 
-    add_quad add_quad{ circuit_constructor.add_variable(multiplication_transcript[num_quads].x),
-                       circuit_constructor.add_variable(multiplication_transcript[num_quads].y),
-                       circuit_constructor.add_variable(x_alpha),
-                       circuit_constructor.add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-    circuit_constructor.create_big_add_gate(add_quad);
+    circuit_constructor.create_big_add_gate({ circuit_constructor.add_variable(multiplication_transcript[num_quads].x),
+                                              circuit_constructor.add_variable(multiplication_transcript[num_quads].y),
+                                              circuit_constructor.add_variable(x_alpha),
+                                              circuit_constructor.add_variable(accumulator_transcript[num_quads]),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero() });
 
     grumpkin::g1::element expected_point =
         grumpkin::g1::element(generator * scalar_multiplier.to_montgomery_form()).normalize();
@@ -345,16 +343,11 @@ TEST(turbo_circuit_constructor, large_scalar_multipliers)
     }
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
-
     TurboCircuitBuilder circuit_constructor = TurboCircuitBuilder();
 
     fr x_alpha = accumulator_offset;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<barretenberg::fr> round_quad;
         round_quad.d = circuit_constructor.add_variable(accumulator_transcript[i]);
         round_quad.a = circuit_constructor.add_variable(multiplication_transcript[i].x);
         round_quad.b = circuit_constructor.add_variable(multiplication_transcript[i].y);
@@ -372,20 +365,23 @@ TEST(turbo_circuit_constructor, large_scalar_multipliers)
         if (i > 0) {
             circuit_constructor.create_fixed_group_add_gate(round_quad);
         } else {
-            circuit_constructor.create_fixed_group_add_gate_with_init(round_quad, init_quad);
+            circuit_constructor.create_fixed_group_add_gate_with_init(round_quad,
+                                                                      { origin_points[0].x,
+                                                                        (origin_points[0].x - origin_points[1].x),
+                                                                        origin_points[0].y,
+                                                                        (origin_points[0].y - origin_points[1].y) });
         }
     }
 
-    add_quad add_quad{ circuit_constructor.add_variable(multiplication_transcript[num_quads].x),
-                       circuit_constructor.add_variable(multiplication_transcript[num_quads].y),
-                       circuit_constructor.add_variable(x_alpha),
-                       circuit_constructor.add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-    circuit_constructor.create_big_add_gate(add_quad);
+    circuit_constructor.create_big_add_gate({ circuit_constructor.add_variable(multiplication_transcript[num_quads].x),
+                                              circuit_constructor.add_variable(multiplication_transcript[num_quads].y),
+                                              circuit_constructor.add_variable(x_alpha),
+                                              circuit_constructor.add_variable(accumulator_transcript[num_quads]),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero() });
 
     grumpkin::g1::element expected_point =
         grumpkin::g1::element(generator * scalar_multiplier.to_montgomery_form()).normalize();
@@ -474,8 +470,7 @@ TEST(turbo_circuit_constructor, and_constraint_failure)
     uint32_t right_witness_index = circuit_constructor.add_variable(right_witness_value);
 
     // 4 && 5 is 4, so 3 bits are needed, but we only constrain 2
-    accumulator_triple accumulators =
-        circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 2);
+    auto accumulators = circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 2);
 
     bool result = circuit_constructor.check_circuit();
 
@@ -504,7 +499,7 @@ TEST(turbo_circuit_constructor, and_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
+        auto accumulators =
             circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
         // circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
@@ -571,8 +566,7 @@ TEST(turbo_circuit_constructor, xor_constraint_failure)
     uint32_t right_witness_index = circuit_constructor.add_variable(right_witness_value);
 
     // 4 && 1 is 5, so 3 bits are needed, but we only constrain 2
-    accumulator_triple accumulators =
-        circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 2);
+    auto accumulators = circuit_constructor.create_and_constraint(left_witness_index, right_witness_index, 2);
 
     bool result = circuit_constructor.check_circuit();
 
@@ -601,7 +595,7 @@ TEST(turbo_circuit_constructor, xor_constraint)
         // include non-nice numbers of bits, that will bleed over gate boundaries
         size_t extra_bits = 2 * (i % 4);
 
-        accumulator_triple accumulators =
+        auto accumulators =
             circuit_constructor.create_xor_constraint(left_witness_index, right_witness_index, 32 + extra_bits);
 
         for (uint32_t j = 0; j < 16; ++j) {
@@ -665,17 +659,16 @@ TEST(turbo_circuit_constructor, big_add_gate_with_bit_extract)
         uint32_t input = engine.get_random_uint32();
         uint32_t output = input + (quad_value > 1 ? 1 : 0);
 
-        add_quad gate{ circuit_constructor.add_variable(uint256_t(input)),
-                       circuit_constructor.add_variable(uint256_t(output)),
-                       right_idx,
-                       left_idx,
-                       fr(6),
-                       -fr(6),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
-
-        circuit_constructor.create_big_add_gate_with_bit_extraction(gate);
+        circuit_constructor.create_big_add_gate_with_bit_extraction(
+            { circuit_constructor.add_variable(uint256_t(input)),
+              circuit_constructor.add_variable(uint256_t(output)),
+              right_idx,
+              left_idx,
+              fr(6),
+              -fr(6),
+              fr::zero(),
+              fr::zero(),
+              fr::zero() });
     };
 
     generate_constraints(0);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.cpp
index fad06b949fea..d96dfce13c91 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.cpp
@@ -118,7 +118,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::add_gates_to_ensure_all_po
  *
  * @param in A structure with variable indexes and selector values for the gate.
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_add_gate(const add_triple& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_add_gate(const add_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -149,7 +149,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_add_gate(const add_
  * @param include_next_gate_w_4 Switches on/off the addition of w_4 at the next index
  */
 template <typename FF>
-void UltraCircuitBuilder_<FF>::create_big_add_gate(const add_quad& in, const bool include_next_gate_w_4)
+void UltraCircuitBuilder_<FF>::create_big_add_gate(const add_quad_<FF>& in, const bool include_next_gate_w_4)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
     w_l.emplace_back(in.a);
@@ -176,7 +176,7 @@ void UltraCircuitBuilder_<FF>::create_big_add_gate(const add_quad& in, const boo
  *
  * @param in Structure with variables and witness selector values
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_big_add_gate_with_bit_extraction(const add_quad& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_big_add_gate_with_bit_extraction(const add_quad_<FF>& in)
 {
     // This method is an artifact of a turbo plonk feature that implicitly extracts
     // a high or low bit from a base-4 quad and adds it into the arithmetic gate relationship.
@@ -239,7 +239,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_big_add_gate_with_b
  *
  * @param in Structure containing variables and witness selectors
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_big_mul_gate(const mul_quad& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_big_mul_gate(const mul_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -263,7 +263,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_big_mul_gate(const
 
 // Creates a width-4 addition gate, where the fourth witness must be a boolean.
 // Can be used to normalize a 32-bit addition
-template <typename FF> void UltraCircuitBuilder_<FF>::create_balanced_add_gate(const add_quad& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_balanced_add_gate(const add_quad_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
@@ -303,7 +303,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_balanced_add_gate(c
  *
  * @param in Structure containing variables and witness selectors
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_mul_gate(const mul_triple& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_mul_gate(const mul_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -358,7 +358,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_bool_gate(const uin
  *
  * @param in Structure containing variables and witness selectors
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_poly_gate(const poly_triple& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_poly_gate(const poly_triple_<FF>& in)
 {
     this->assert_valid_variables({ in.a, in.b, in.c });
 
@@ -391,7 +391,7 @@ template <typename FF> void UltraCircuitBuilder_<FF>::create_poly_gate(const pol
  * added, the resulting point coordinates and the selector values that describe whether the endomorphism is used on the
  * second point and whether it is negated.
  */
-template <typename FF> void UltraCircuitBuilder_<FF>::create_ecc_add_gate(const ecc_add_gate& in)
+template <typename FF> void UltraCircuitBuilder_<FF>::create_ecc_add_gate(const ecc_add_gate_<FF>& in)
 {
     /**
      * | 1  | 2  | 3  | 4  |
@@ -3535,4 +3535,7 @@ template <typename FF> bool UltraCircuitBuilder_<FF>::check_circuit()
     return result;
 }
 template class UltraCircuitBuilder_<barretenberg::fr>;
+// To enable this we need to template plookup
+// template class UltraCircuitBuilder_<grumpkin::fr>;
+
 } // namespace proof_system
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp
index 29220028f6ad..2ff9f0eb70ac 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp
@@ -644,17 +644,17 @@ template <typename FF> class UltraCircuitBuilder_ : public CircuitBuilderBase<ar
 
     void add_gates_to_ensure_all_polys_are_non_zero();
 
-    void create_add_gate(const add_triple& in) override;
+    void create_add_gate(const add_triple_<FF>& in) override;
 
-    void create_big_add_gate(const add_quad& in, const bool use_next_gate_w_4 = false);
-    void create_big_add_gate_with_bit_extraction(const add_quad& in);
-    void create_big_mul_gate(const mul_quad& in);
-    void create_balanced_add_gate(const add_quad& in);
+    void create_big_add_gate(const add_quad_<FF>& in, const bool use_next_gate_w_4 = false);
+    void create_big_add_gate_with_bit_extraction(const add_quad_<FF>& in);
+    void create_big_mul_gate(const mul_quad_<FF>& in);
+    void create_balanced_add_gate(const add_quad_<FF>& in);
 
-    void create_mul_gate(const mul_triple& in) override;
+    void create_mul_gate(const mul_triple_<FF>& in) override;
     void create_bool_gate(const uint32_t a) override;
-    void create_poly_gate(const poly_triple& in) override;
-    void create_ecc_add_gate(const ecc_add_gate& in);
+    void create_poly_gate(const poly_triple_<FF>& in) override;
+    void create_ecc_add_gate(const ecc_add_gate_<FF>& in);
 
     void fix_witness(const uint32_t witness_index, const FF& witness_value);
 
@@ -678,7 +678,7 @@ template <typename FF> class UltraCircuitBuilder_ : public CircuitBuilderBase<ar
              *    num_bits <= DEFAULT_PLOOKUP_RANGE_BITNUM is correctly enforced in the circuit.
              *    Longer term, as Zac says, we would need to refactor the composer to fix this.
              **/
-            create_poly_gate(poly_triple{
+            create_poly_gate(poly_triple_<FF>{
                 .a = variable_index,
                 .b = variable_index,
                 .c = variable_index,
@@ -694,12 +694,12 @@ template <typename FF> class UltraCircuitBuilder_ : public CircuitBuilderBase<ar
         }
     }
 
-    accumulator_triple create_logic_constraint(const uint32_t a,
-                                               const uint32_t b,
-                                               const size_t num_bits,
-                                               bool is_xor_gate);
-    accumulator_triple create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
-    accumulator_triple create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_logic_constraint(const uint32_t a,
+                                                    const uint32_t b,
+                                                    const size_t num_bits,
+                                                    bool is_xor_gate);
+    accumulator_triple_<FF> create_and_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
+    accumulator_triple_<FF> create_xor_constraint(const uint32_t a, const uint32_t b, const size_t num_bits);
 
     uint32_t put_constant_variable(const FF& variable);
 
@@ -1201,5 +1201,8 @@ template <typename FF> class UltraCircuitBuilder_ : public CircuitBuilderBase<ar
     bool check_circuit();
 };
 extern template class UltraCircuitBuilder_<barretenberg::fr>;
+// TODO: template plookup to be able to be able to have UltraCircuitBuilder on Grumpkin
+// extern template class UltraCircuitBuilder_<grumpkin::fr>;
 using UltraCircuitBuilder = UltraCircuitBuilder_<barretenberg::fr>;
+// using UltraGrumpkinCircuitBuilder = UltraCircuitBuilder_<grumpkin::fr>;
 } // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.test.cpp
index d994c0b9235b..5ed67a0e028d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/ultra_circuit_builder.test.cpp
@@ -147,8 +147,7 @@ TEST(ultra_circuit_constructor, test_elliptic_gate)
     uint32_t x3 = circuit_constructor.add_variable(p3.x);
     uint32_t y3 = circuit_constructor.add_variable(p3.y);
 
-    ecc_add_gate gate{ x1, y1, x2, y2, x3, y3, 1, 1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, 1, 1 });
 
     grumpkin::fq beta = grumpkin::fq::cube_root_of_unity();
     affine_element p2_endo = p2;
@@ -156,15 +155,13 @@ TEST(ultra_circuit_constructor, test_elliptic_gate)
     p3 = affine_element(element(p1) + element(p2_endo));
     x3 = circuit_constructor.add_variable(p3.x);
     y3 = circuit_constructor.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta, 1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta, 1 });
 
     p2_endo.x *= beta;
     p3 = affine_element(element(p1) - element(p2_endo));
     x3 = circuit_constructor.add_variable(p3.x);
     y3 = circuit_constructor.add_variable(p3.y);
-    gate = ecc_add_gate{ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1, y1, x2, y2, x3, y3, beta.sqr(), -1 });
 
     auto saved_state = UltraCircuitBuilder::CircuitDataBackup::store_full_state(circuit_constructor);
     bool result = circuit_constructor.check_circuit();
@@ -172,8 +169,7 @@ TEST(ultra_circuit_constructor, test_elliptic_gate)
     EXPECT_EQ(result, true);
     EXPECT_TRUE(saved_state.is_same_state(circuit_constructor));
 
-    gate = ecc_add_gate{ x1 + 1, y1, x2, y2, x3, y3, beta.sqr(), -1 };
-    circuit_constructor.create_ecc_add_gate(gate);
+    circuit_constructor.create_ecc_add_gate({ x1 + 1, y1, x2, y2, x3, y3, beta.sqr(), -1 });
 
     EXPECT_EQ(circuit_constructor.check_circuit(), false);
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.hpp
index 5b8bce15f81c..b4934e7186f0 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.hpp
@@ -45,7 +45,7 @@ void construct_selector_polynomials(const typename Flavor::CircuitBuilder& circu
 
         // Copy the selector values for all gates, keeping the rows at which we store public inputs as 0.
         // Initializing the polynomials in this way automatically applies 0-padding to the selectors.
-        barretenberg::polynomial selector_poly_lagrange(proving_key->circuit_size);
+        typename Flavor::Polynomial selector_poly_lagrange(proving_key->circuit_size);
         for (size_t i = 0; i < selector_values.size(); ++i) {
             selector_poly_lagrange[i + gate_offset] = selector_values[i];
         }
@@ -75,10 +75,10 @@ void construct_selector_polynomials(const typename Flavor::CircuitBuilder& circu
  * @param circuit_constructor
  * @param dyadic_circuit_size Power of 2 circuit size
  *
- * @return std::vector<barretenberg::polynomial>
+ * @return std::vector<typename Flavor::Polynomial>
  * */
 template <typename Flavor>
-std::vector<barretenberg::polynomial> construct_wire_polynomials_base(
+std::vector<typename Flavor::Polynomial> construct_wire_polynomials_base(
     const typename Flavor::CircuitBuilder& circuit_constructor, const size_t dyadic_circuit_size)
 {
     // Determine size of each block of data in the wire polynomials
@@ -96,13 +96,13 @@ std::vector<barretenberg::polynomial> construct_wire_polynomials_base(
     size_t pub_input_offset = num_zero_rows + num_ecc_op_gates;
     size_t gate_offset = num_zero_rows + num_ecc_op_gates + num_public_inputs;
 
-    std::vector<barretenberg::polynomial> wire_polynomials;
+    std::vector<typename Flavor::Polynomial> wire_polynomials;
 
     // Populate the wire polynomials with values from ecc op gates, public inputs and conventional wires
     for (size_t wire_idx = 0; wire_idx < Flavor::NUM_WIRES; ++wire_idx) {
 
         // Expect all values to be set to 0 initially
-        barretenberg::polynomial w_lagrange(dyadic_circuit_size);
+        typename Flavor::Polynomial w_lagrange(dyadic_circuit_size);
 
         // Insert leading zero row into wire poly (for clarity; not stricly necessary due to zero-initialization)
         for (size_t i = 0; i < num_zero_rows; ++i) {
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.test.cpp
index 0df8d5066613..2d9a85a410d7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/composer_lib.test.cpp
@@ -14,7 +14,7 @@ class ComposerLibTests : public ::testing::Test {
     using FF = typename Flavor::FF;
     Flavor::CircuitBuilder circuit_constructor;
     Flavor::ProvingKey proving_key = []() {
-        auto crs_factory = barretenberg::srs::factories::CrsFactory();
+        auto crs_factory = barretenberg::srs::factories::CrsFactory<curve::BN254>();
         auto crs = crs_factory.get_prover_crs(4);
         return Flavor::ProvingKey(/*circuit_size=*/4, /*num_public_inputs=*/0);
     }();
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.hpp
index fe7994ce6fc4..65c5e318e998 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.hpp
@@ -62,7 +62,9 @@ namespace {
 
 /**
  * @brief Compute all CyclicPermutations of the circuit. Each CyclicPermutation represents the indices of the values in
- * the witness wires that must have the same value.
+ * the witness wires that must have the same value.    using Curve = curve::BN254;
+    using FF = Curve::ScalarField;
+    using Polynomial = barretenberg::Polynomial<FF>;
  *
  * @tparam program_width Program width
  *
@@ -284,6 +286,7 @@ void compute_honk_style_permutation_lagrange_polynomials_from_mapping(
     std::array<std::vector<permutation_subgroup_element>, Flavor::NUM_WIRES>& permutation_mappings,
     typename Flavor::ProvingKey* proving_key)
 {
+    using FF = typename Flavor::FF;
     const size_t num_gates = proving_key->circuit_size;
 
     size_t wire_index = 0;
@@ -299,16 +302,14 @@ void compute_honk_style_permutation_lagrange_polynomials_from_mapping(
             //  -(i+1) -> (n+i)
             // These indices are chosen so they can easily be computed by the verifier. They can expect the running
             // product to be equal to the "public input delta" that is computed in <honk/utils/grand_product_delta.hpp>
-            current_permutation_poly[i] =
-                -barretenberg::fr(current_mapping.row_index + 1 + num_gates * current_mapping.column_index);
+            current_permutation_poly[i] = -FF(current_mapping.row_index + 1 + num_gates * current_mapping.column_index);
         } else if (current_mapping.is_tag) {
             // Set evaluations to (arbitrary) values disjoint from non-tag values
             current_permutation_poly[i] = num_gates * Flavor::NUM_WIRES + current_mapping.row_index;
         } else {
             // For the regular permutation we simply point to the next location by setting the evaluation to its
             // index
-            current_permutation_poly[i] =
-                barretenberg::fr(current_mapping.row_index + num_gates * current_mapping.column_index);
+            current_permutation_poly[i] = FF(current_mapping.row_index + num_gates * current_mapping.column_index);
         }
         ITERATE_OVER_DOMAIN_END;
         wire_index++;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.test.cpp
index ee9125606a41..4d9bb3592908 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/composer/permutation_lib.test.cpp
@@ -14,7 +14,8 @@ class PermutationHelperTests : public ::testing::Test {
     using FF = typename Flavor::FF;
     using ProvingKey = Flavor::ProvingKey;
     Flavor::CircuitBuilder circuit_constructor;
-    barretenberg::srs::factories::CrsFactory crs_factory = barretenberg::srs::factories::CrsFactory();
+    barretenberg::srs::factories::CrsFactory<curve::BN254> crs_factory =
+        barretenberg::srs::factories::CrsFactory<curve::BN254>();
     std::shared_ptr<Flavor::ProvingKey> proving_key;
 
     virtual void SetUp()
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/concepts.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/concepts.hpp
index 78ca01eeaa1d..87d646753565 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/concepts.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/concepts.hpp
@@ -4,15 +4,23 @@ struct DoNothing {
     void operator()(auto...) {}
 };
 namespace msgpack_concepts {
-template <typename T>
-concept HasMsgPack = requires(T t, DoNothing nop) { t.msgpack(nop); };
+template <typename T> concept HasMsgPack = requires(T t, DoNothing nop)
+{
+    t.msgpack(nop);
+};
 
-template <typename T>
-concept HasMsgPackSchema = requires(const T t, DoNothing nop) { t.msgpack_schema(nop); };
+template <typename T> concept HasMsgPackSchema = requires(const T t, DoNothing nop)
+{
+    t.msgpack_schema(nop);
+};
 
-template <typename T>
-concept HasMsgPackPack = requires(T t, DoNothing nop) { t.msgpack_pack(nop); };
-template <typename T, typename... Args>
-concept MsgpackConstructible = requires(T object, Args... args) { T{ args... }; };
+template <typename T> concept HasMsgPackPack = requires(T t, DoNothing nop)
+{
+    t.msgpack_pack(nop);
+};
+template <typename T, typename... Args> concept MsgpackConstructible = requires(T object, Args... args)
+{
+    T{ args... };
+};
 
 } // namespace msgpack_concepts
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/func_traits.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/func_traits.hpp
index 492dc6be8ef2..63e69ffd564b 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/func_traits.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/func_traits.hpp
@@ -32,9 +32,10 @@ template <typename R, typename T, typename... Vs> struct func_traits<R (T::*)(Vs
 
 // Define a concept that checks if the type is a lambda (or functor) type
 // This is done by checking if T::operator() exists
-template <typename T>
-concept LambdaType =
-    requires() { typename std::enable_if_t<std::is_member_function_pointer_v<decltype(&T::operator())>, void>; };
+template <typename T> concept LambdaType = requires()
+{
+    typename std::enable_if_t<std::is_member_function_pointer_v<decltype(&T::operator())>, void>;
+};
 
 // Overload for lambda (or functor) types
 template <LambdaType T> constexpr auto get_func_traits()
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/schema_impl.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/schema_impl.hpp
index 9729ba1bb033..cdc90789f87e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/schema_impl.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/serialize/msgpack_impl/schema_impl.hpp
@@ -102,8 +102,10 @@ inline void _schema_pack_map_content(MsgpackSchemaPacker&)
 }
 
 namespace msgpack_concepts {
-template <typename T>
-concept SchemaPackable = requires(T value, MsgpackSchemaPacker packer) { msgpack_schema_pack(packer, value); };
+template <typename T> concept SchemaPackable = requires(T value, MsgpackSchemaPacker packer)
+{
+    msgpack_schema_pack(packer, value);
+};
 } // namespace msgpack_concepts
 
 // Helper for packing (key, value, key, value, ...) arguments
@@ -119,8 +121,8 @@ inline void _schema_pack_map_content(MsgpackSchemaPacker& packer, std::string ke
 }
 
 template <typename T>
-    requires(!msgpack_concepts::HasMsgPackSchema<T> && !msgpack_concepts::HasMsgPack<T>)
-inline void msgpack_schema_pack(MsgpackSchemaPacker& packer, T const& obj)
+requires(!msgpack_concepts::HasMsgPackSchema<T> &&
+         !msgpack_concepts::HasMsgPack<T>) inline void msgpack_schema_pack(MsgpackSchemaPacker& packer, T const& obj)
 {
     packer.pack(msgpack_schema_name(obj));
 }
@@ -144,8 +146,8 @@ inline void msgpack_schema_pack(MsgpackSchemaPacker& packer, T const& obj)
  * @param object The object in question.
  */
 template <msgpack_concepts::HasMsgPack T>
-    requires(!msgpack_concepts::HasMsgPackSchema<T>)
-inline void msgpack_schema_pack(MsgpackSchemaPacker& packer, T const& object)
+requires(!msgpack_concepts::HasMsgPackSchema<T>) inline void msgpack_schema_pack(MsgpackSchemaPacker& packer,
+                                                                                 T const& object)
 {
     std::string type = msgpack_schema_name(object);
     packer.pack_with_name(type, object);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
index bf448229a817..1bb8ab702c66 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
@@ -1,15 +1,17 @@
 barretenberg_module(stdlib_solidity_helpers plonk proof_system transcript crypto_pedersen_commitment polynomials crypto_sha256 ecc crypto_blake3s stdlib_primitives stdlib_pedersen_commitment stdlib_blake3s stdlib_blake2s srs)
 
-add_executable(solidity_key_gen key_gen.cpp)
+if (!FUZZING)
+  add_executable(solidity_key_gen key_gen.cpp)
 
-add_executable(solidity_proof_gen proof_gen.cpp)
+  add_executable(solidity_proof_gen proof_gen.cpp)
 
-target_link_libraries(
-  solidity_key_gen
-  stdlib_solidity_helpers
-)
+  target_link_libraries(
+    solidity_key_gen
+    stdlib_solidity_helpers
+  )
 
-target_link_libraries(
-  solidity_proof_gen
-  stdlib_solidity_helpers
-)
+  target_link_libraries(
+    solidity_proof_gen
+    stdlib_solidity_helpers
+  )
+endif()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/crs_factory.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/crs_factory.hpp
index 1cffa463bdce..f9d989d30493 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/crs_factory.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/crs_factory.hpp
@@ -3,6 +3,7 @@
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/ecc/curves/bn254/g2.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include <cstddef>
 
 namespace barretenberg::pairing {
@@ -20,36 +21,65 @@ template <typename Curve> class ProverCrs {
     ;
 
     /**
-     * Returns the monomial points in a form to be consumed by scalar_multiplication pippenger algorithm.
+     *  @brief Returns the monomial points in a form to be consumed by scalar_multiplication pippenger algorithm.
      */
     virtual typename Curve::AffineElement* get_monomial_points() = 0;
     virtual size_t get_monomial_size() const = 0;
 };
 
-class VerifierCrs {
+template <typename Curve> class VerifierCrs {
   public:
     virtual ~VerifierCrs() = default;
-    ;
-
-    virtual barretenberg::g2::affine_element get_g2x() const = 0;
+};
+template <> class VerifierCrs<curve::BN254> {
+    using Curve = curve::BN254;
 
+  public:
+    virtual Curve::G2AffineElement get_g2x() const = 0;
+    /**
+     * @brief As the G_2 element of the CRS is fixed, we can precompute the operations performed on it during the
+     * pairing algorithm to optimise pairing computations.
+     */
     virtual barretenberg::pairing::miller_lines const* get_precomputed_g2_lines() const = 0;
+    /**
+     *  @brief Returns the first G_1 element from the CRS, used by the Shplonk verifier to compute the final
+     * commtiment.
+     */
+    virtual Curve::AffineElement get_first_g1() const = 0;
+};
+
+template <> class VerifierCrs<curve::Grumpkin> {
+    using Curve = curve::Grumpkin;
+
+  public:
+    /**
+     * @brief Returns the G_1 elements in the CRS after the pippenger point table has been applied on them
+     *
+     */
+    virtual Curve::AffineElement* get_monomial_points() const = 0;
+    virtual size_t get_monomial_size() const = 0;
+    /**
+     * @brief Returns the first G_1 element from the CRS, used by the Shplonk verifier to compute the final
+     * commtiment.
+     */
+    virtual Curve::AffineElement get_first_g1() const = 0;
 };
 
 /**
  * A factory class to return the prover crs and verifier crs on request.
  * You can construct an empty placeholder factory, because composers need to be given a factory at construction time.
  */
-class CrsFactory {
+template <typename Curve> class CrsFactory {
   public:
     CrsFactory() = default;
     CrsFactory(CrsFactory&& other) = default;
     virtual ~CrsFactory() = default;
-    virtual std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> get_prover_crs(size_t)
+    virtual std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> get_prover_crs(size_t) { return nullptr; }
+    virtual std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> get_verifier_crs(
+        [[maybe_unused]] size_t degree = 0)
     {
         return nullptr;
     }
-    virtual std::shared_ptr<barretenberg::srs::factories::VerifierCrs> get_verifier_crs() { return nullptr; }
 };
 
-} // namespace barretenberg::srs::factories
+} // namespace barretenberg::srs::factories
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.cpp
index fbc15949cd4a..602300657dc1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.cpp
@@ -3,67 +3,79 @@
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/ecc/curves/bn254/pairing.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/ecc/scalar_multiplication/point_table.hpp"
 #include "barretenberg/ecc/scalar_multiplication/scalar_multiplication.hpp"
 
 namespace barretenberg::srs::factories {
 
-template <typename Curve>
-FileProverCrs<Curve>::FileProverCrs(const size_t num_points, std::string const& path)
-    : num_points(num_points)
-{
-    monomials_ = scalar_multiplication::point_table_alloc<typename Curve::AffineElement>(num_points);
-
-    srs::IO<Curve>::read_transcript_g1(monomials_.get(), num_points, path);
-    scalar_multiplication::generate_pippenger_point_table<Curve>(monomials_.get(), monomials_.get(), num_points);
-}
-
-FileVerifierCrs::FileVerifierCrs(std::string const& path)
+FileVerifierCrs<curve::BN254>::FileVerifierCrs(std::string const& path, const size_t)
     : precomputed_g2_lines(
           (barretenberg::pairing::miller_lines*)(aligned_alloc(64, sizeof(barretenberg::pairing::miller_lines) * 2)))
 {
-
+    using Curve = curve::BN254;
+    auto point_buf = scalar_multiplication::point_table_alloc<Curve::AffineElement>(1);
+    srs::IO<Curve>::read_transcript_g1(point_buf.get(), 1, path);
     srs::IO<curve::BN254>::read_transcript_g2(g2_x, path);
     barretenberg::pairing::precompute_miller_lines(barretenberg::g2::one, precomputed_g2_lines[0]);
     barretenberg::pairing::precompute_miller_lines(g2_x, precomputed_g2_lines[1]);
+    first_g1 = point_buf[0];
 }
 
-FileVerifierCrs::~FileVerifierCrs()
+FileVerifierCrs<curve::BN254>::~FileVerifierCrs()
 {
     aligned_free(precomputed_g2_lines);
 }
 
-g2::affine_element FileVerifierCrs::get_g2x() const
+FileVerifierCrs<curve::Grumpkin>::FileVerifierCrs(std::string const& path, const size_t num_points)
+    : num_points(num_points)
 {
-    return g2_x;
+    using Curve = curve::Grumpkin;
+    monomials_ = scalar_multiplication::point_table_alloc<Curve::AffineElement>(num_points);
+    srs::IO<Curve>::read_transcript_g1(monomials_.get(), num_points, path);
+    scalar_multiplication::generate_pippenger_point_table<Curve>(monomials_.get(), monomials_.get(), num_points);
+    first_g1 = monomials_[0];
+};
+
+curve::Grumpkin::AffineElement* FileVerifierCrs<curve::Grumpkin>::get_monomial_points() const
+{
+    return monomials_.get();
 }
 
-pairing::miller_lines const* FileVerifierCrs::get_precomputed_g2_lines() const
+size_t FileVerifierCrs<curve::Grumpkin>::get_monomial_size() const
 {
-    return precomputed_g2_lines;
+    return num_points;
 }
 
-FileCrsFactory::FileCrsFactory(std::string path, size_t initial_degree)
+template <typename Curve>
+FileCrsFactory<Curve>::FileCrsFactory(std::string path, size_t initial_degree)
     : path_(std::move(path))
     , degree_(initial_degree)
-    , verifier_crs_(std::make_shared<FileVerifierCrs>(path_))
 {}
 
-std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> FileCrsFactory::get_prover_crs(size_t degree)
+template <typename Curve>
+std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> FileCrsFactory<Curve>::get_prover_crs(size_t degree)
 {
     if (degree != degree_ || !prover_crs_) {
-        prover_crs_ = std::make_shared<FileProverCrs<curve::BN254>>(degree, path_);
+        prover_crs_ = std::make_shared<FileProverCrs<Curve>>(degree, path_);
         degree_ = degree;
     }
     return prover_crs_;
 }
 
-std::shared_ptr<barretenberg::srs::factories::VerifierCrs> FileCrsFactory::get_verifier_crs()
+template <typename Curve>
+std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> FileCrsFactory<Curve>::get_verifier_crs(size_t degree)
 {
+    if (degree != degree_ || !verifier_crs_) {
+        verifier_crs_ = std::make_shared<FileVerifierCrs<Curve>>(path_, degree);
+        degree_ = degree;
+    }
     return verifier_crs_;
 }
 
 template class FileProverCrs<curve::BN254>;
 template class FileProverCrs<curve::Grumpkin>;
+template class FileCrsFactory<curve::BN254>;
+template class FileCrsFactory<curve::Grumpkin>;
 
-} // namespace barretenberg::srs::factories
\ No newline at end of file
+} // namespace barretenberg::srs::factories
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.hpp
index 83ea35d84e38..3a925e2ccf94 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/file_crs_factory.hpp
@@ -1,15 +1,44 @@
 #pragma once
+#include "../io.hpp"
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
+#include "barretenberg/ecc/scalar_multiplication/point_table.hpp"
+#include "barretenberg/ecc/scalar_multiplication/scalar_multiplication.hpp"
 #include "crs_factory.hpp"
 #include <cstddef>
 #include <utility>
 
 namespace barretenberg::srs::factories {
 
+/**
+ * Create reference strings given a path to a directory of transcript files.
+ */
+template <typename Curve> class FileCrsFactory : public CrsFactory<Curve> {
+  public:
+    FileCrsFactory(std::string path, size_t initial_degree = 0);
+    FileCrsFactory(FileCrsFactory&& other) = default;
+
+    std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> get_prover_crs(size_t degree) override;
+
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> get_verifier_crs(size_t degree = 0) override;
+
+  private:
+    std::string path_;
+    size_t degree_;
+    std::shared_ptr<barretenberg::srs::factories::ProverCrs<Curve>> prover_crs_;
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<Curve>> verifier_crs_;
+};
+
 template <typename Curve> class FileProverCrs : public ProverCrs<Curve> {
   public:
-    FileProverCrs(const size_t num_points, std::string const& path);
+    FileProverCrs(const size_t num_points, std::string const& path)
+        : num_points(num_points)
+    {
+        monomials_ = scalar_multiplication::point_table_alloc<typename Curve::AffineElement>(num_points);
+
+        srs::IO<Curve>::read_transcript_g1(monomials_.get(), num_points, path);
+        scalar_multiplication::generate_pippenger_point_table<Curve>(monomials_.get(), monomials_.get(), num_points);
+    };
 
     typename Curve::AffineElement* get_monomial_points() { return monomials_.get(); }
 
@@ -20,38 +49,41 @@ template <typename Curve> class FileProverCrs : public ProverCrs<Curve> {
     std::shared_ptr<typename Curve::AffineElement[]> monomials_;
 };
 
-class FileVerifierCrs : public VerifierCrs {
+template <typename Curve> class FileVerifierCrs : public VerifierCrs<Curve> {
   public:
-    FileVerifierCrs(std::string const& path);
-
-    ~FileVerifierCrs();
+    FileVerifierCrs(std::string const& path, const size_t num_points);
+};
 
-    g2::affine_element get_g2x() const override;
+template <> class FileVerifierCrs<curve::BN254> : public VerifierCrs<curve::BN254> {
+    using Curve = curve::BN254;
 
-    pairing::miller_lines const* get_precomputed_g2_lines() const override;
+  public:
+    FileVerifierCrs(std::string const& path, const size_t num_points = 0);
+    virtual ~FileVerifierCrs();
+    Curve::G2AffineElement get_g2x() const override { return g2_x; };
+    pairing::miller_lines const* get_precomputed_g2_lines() const override { return precomputed_g2_lines; };
+    Curve::AffineElement get_first_g1() const override { return first_g1; };
 
   private:
-    g2::affine_element g2_x;
+    Curve::AffineElement first_g1;
+    Curve::G2AffineElement g2_x;
     pairing::miller_lines* precomputed_g2_lines;
 };
 
-/**
- * Create reference strings given a path to a directory of transcript files.
- */
-class FileCrsFactory : public CrsFactory {
-  public:
-    FileCrsFactory(std::string path, size_t initial_degree = 0);
-    FileCrsFactory(FileCrsFactory&& other) = default;
-
-    std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> get_prover_crs(size_t degree) override;
+template <> class FileVerifierCrs<curve::Grumpkin> : public VerifierCrs<curve::Grumpkin> {
+    using Curve = curve::Grumpkin;
 
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> get_verifier_crs() override;
+  public:
+    FileVerifierCrs(std::string const& path, const size_t num_points);
+    virtual ~FileVerifierCrs() = default;
+    Curve::AffineElement* get_monomial_points() const override;
+    size_t get_monomial_size() const override;
+    Curve::AffineElement get_first_g1() const override { return first_g1; };
 
   private:
-    std::string path_;
-    size_t degree_;
-    std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> prover_crs_;
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> verifier_crs_;
+    Curve::AffineElement first_g1;
+    size_t num_points;
+    std::shared_ptr<Curve::AffineElement[]> monomials_;
 };
 
 extern template class FileProverCrs<curve::BN254>;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.cpp
index 94ae89a76aa1..44315a8b7ca4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.cpp
@@ -30,24 +30,27 @@ class MemProverCrs : public ProverCrs<curve::BN254> {
     std::shared_ptr<g1::affine_element[]> monomials_;
 };
 
-class MemVerifierCrs : public VerifierCrs {
+class MemVerifierCrs : public VerifierCrs<curve::BN254> {
   public:
     MemVerifierCrs(g2::affine_element const& g2_point)
         : g2_x(g2_point)
+        , precomputed_g2_lines(
+              static_cast<pairing::miller_lines*>(aligned_alloc(64, sizeof(barretenberg::pairing::miller_lines) * 2)))
     {
-        precomputed_g2_lines =
-            (pairing::miller_lines*)(aligned_alloc(64, sizeof(barretenberg::pairing::miller_lines) * 2));
+
         barretenberg::pairing::precompute_miller_lines(barretenberg::g2::one, precomputed_g2_lines[0]);
         barretenberg::pairing::precompute_miller_lines(g2_x, precomputed_g2_lines[1]);
     }
 
-    ~MemVerifierCrs() { aligned_free(precomputed_g2_lines); }
+    virtual ~MemVerifierCrs() { aligned_free(precomputed_g2_lines); }
 
-    g2::affine_element get_g2x() const override { return g2_x; }
+    g2::affine_element get_g2x() const { return g2_x; }
 
-    pairing::miller_lines const* get_precomputed_g2_lines() const override { return precomputed_g2_lines; }
+    pairing::miller_lines const* get_precomputed_g2_lines() const { return precomputed_g2_lines; }
+    g1::affine_element get_first_g1() const { return first_g1x; };
 
   private:
+    g1::affine_element first_g1x;
     g2::affine_element g2_x;
     pairing::miller_lines* precomputed_g2_lines;
 };
@@ -66,7 +69,7 @@ std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> MemCrsFac
     return prover_crs_;
 }
 
-std::shared_ptr<barretenberg::srs::factories::VerifierCrs> MemCrsFactory::get_verifier_crs()
+std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> MemCrsFactory::get_verifier_crs(size_t)
 {
     return verifier_crs_;
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.hpp
index c4c9fba8d520..a4e6b90db6d7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.hpp
@@ -10,19 +10,22 @@ namespace barretenberg::srs::factories {
 
 /**
  * Create reference strings given pointers to in memory buffers.
+ *
+ * This class is currently only used with wasm and works exclusively with the BN254 CRS.
  */
-class MemCrsFactory : public CrsFactory {
+class MemCrsFactory : public CrsFactory<curve::BN254> {
   public:
     MemCrsFactory(std::vector<g1::affine_element> const& points, g2::affine_element const g2_point);
     MemCrsFactory(MemCrsFactory&& other) = default;
 
     std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> get_prover_crs(size_t degree) override;
 
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> get_verifier_crs() override;
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> get_verifier_crs(
+        size_t degree = 0) override;
 
   private:
     std::shared_ptr<barretenberg::srs::factories::ProverCrs<curve::BN254>> prover_crs_;
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> verifier_crs_;
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> verifier_crs_;
 };
 
 } // namespace barretenberg::srs::factories
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.test.cpp
index 57b725e9e2ac..2b50a60209de 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/factories/mem_crs_factory.test.cpp
@@ -12,7 +12,7 @@ using namespace barretenberg::srs::factories;
 TEST(reference_string, mem_file_consistency)
 {
     // Load 1024 from file.
-    auto file_crs = FileCrsFactory("../srs_db/ignition", 1024);
+    auto file_crs = FileCrsFactory<curve::BN254>("../srs_db/ignition", 1024);
 
     // Use low level io lib to read 1024 from file.
     std::vector<g1::affine_element> points(1024);
@@ -43,3 +43,8 @@ TEST(reference_string, mem_file_consistency)
                      sizeof(barretenberg::pairing::miller_lines) * 2),
               0);
 }
+
+TEST(reference_string, grumpkin)
+{
+    auto file_crs = FileCrsFactory<curve::Grumpkin>("../srs_db/grumpkin");
+}
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.cpp
index 912a5758d7a1..acd615b8b8a2 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.cpp
@@ -4,26 +4,43 @@
 #include "barretenberg/common/throw_or_abort.hpp"
 
 namespace {
-std::shared_ptr<barretenberg::srs::factories::CrsFactory> crs_factory;
-}
+// TODO(#637): As a PoC we have two global variables for the two CRS but this could be improved to avoid duplication.
+std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> crs_factory;
+std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::Grumpkin>> grumpkin_crs_factory;
+} // namespace
 
 namespace barretenberg::srs {
 
+// Initialises the crs using the memory buffers
 void init_crs_factory(std::vector<g1::affine_element> const& points, g2::affine_element const g2_point)
 {
     crs_factory = std::make_shared<factories::MemCrsFactory>(points, g2_point);
 }
 
+// Initialises crs from a file path this we use in the entire codebase
 void init_crs_factory(std::string crs_path)
 {
-    crs_factory = std::make_shared<factories::FileCrsFactory>(crs_path);
+    crs_factory = std::make_shared<factories::FileCrsFactory<curve::BN254>>(crs_path);
+}
+
+void init_grumpkin_crs_factory(std::string crs_path)
+{
+    grumpkin_crs_factory = std::make_shared<factories::FileCrsFactory<curve::Grumpkin>>(crs_path);
 }
 
-std::shared_ptr<factories::CrsFactory> get_crs_factory()
+std::shared_ptr<factories::CrsFactory<curve::BN254>> get_crs_factory()
 {
     if (!crs_factory) {
         throw_or_abort("You need to initalize the global CRS with a call to init_crs_factory(...)!");
     }
     return crs_factory;
 }
+
+std::shared_ptr<factories::CrsFactory<curve::Grumpkin>> get_grumpkin_crs_factory()
+{
+    if (!grumpkin_crs_factory) {
+        throw_or_abort("You need to initalize the global CRS with a call to init_grumpkin_crs_factory(...)!");
+    }
+    return grumpkin_crs_factory;
+}
 } // namespace barretenberg::srs
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.hpp
index 08ba671a75b2..06ecd066d913 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/srs/global_crs.hpp
@@ -1,11 +1,15 @@
 #include "./factories/crs_factory.hpp"
+#include "barretenberg/ecc/curves/bn254/bn254.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
 namespace barretenberg::srs {
-
 void init_crs_factory(std::vector<barretenberg::g1::affine_element> const& points,
                       barretenberg::g2::affine_element const g2_point);
 
 void init_crs_factory(std::string crs_path);
+void init_grumpkin_crs_factory(std::string crs_path);
+
+std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::BN254>> get_crs_factory();
+std::shared_ptr<barretenberg::srs::factories::CrsFactory<curve::Grumpkin>> get_grumpkin_crs_factory();
 
-std::shared_ptr<barretenberg::srs::factories::CrsFactory> get_crs_factory();
 } // namespace barretenberg::srs
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
index 8458d3a3fa04..97bda1baf6a5 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
@@ -35,14 +35,15 @@ void generate_test_sha256_plonk_circuit(Builder& builder, size_t num_iterations)
     for (size_t i = 0; i < 32; ++i) {
         in[i] = 0;
     }
+
     proof_system::plonk::stdlib::packed_byte_array<Builder> input(&builder, in);
     for (size_t i = 0; i < num_iterations; i++) {
         input = proof_system::plonk::stdlib::sha256<Builder>(input);
     }
 }
 
-Builder external_builders[NUM_PROOFS];
-Composer external_composers[NUM_PROOFS];
+void* external_builders[NUM_PROOFS];
+void* external_composers[NUM_PROOFS];
 Prover external_provers[NUM_PROOFS];
 Verifier external_verifiers[NUM_PROOFS];
 plonk::proof external_proofs[NUM_PROOFS];
@@ -55,15 +56,15 @@ plonk::proof external_proofs[NUM_PROOFS];
 void generate_sha256_proof_bench(State& state) noexcept
 {
     for (auto _ : state) {
-
         size_t idx = static_cast<size_t>(state.range(0));
         size_t num_iterations = 1;
         for (size_t i = 0; i < idx; i++) {
             num_iterations *= PROOF_COUNT_LOG;
         }
-        external_composers[idx] = Composer();
-        generate_test_sha256_plonk_circuit(external_builders[idx], num_iterations);
-        external_provers[idx] = external_composers[idx].create_prover(external_builders[idx]);
+        external_composers[idx] = (void*)new Composer();
+        external_builders[idx] = (void*)new Builder();
+        generate_test_sha256_plonk_circuit(*(Builder*)external_builders[idx], num_iterations);
+        external_provers[idx] = ((Composer*)external_composers[idx])->create_prover(*(Builder*)external_builders[idx]);
         external_proofs[idx] = external_provers[idx].construct_proof();
         // info("Proof Size for SHA256 hash count ", num_iterations, ": ", external_proofs[idx].proof_data.size());
     }
@@ -85,7 +86,7 @@ static void generate_sha256_verifier(const State& state)
 {
 
     size_t idx = static_cast<size_t>(state.range(0));
-    external_verifiers[idx] = external_composers[idx].create_verifier(external_builders[idx]);
+    external_verifiers[idx] = ((Composer*)external_composers[idx])->create_verifier(*(Builder*)external_builders[idx]);
 }
 /**
  * @brief Benchmark sha256 verification
@@ -136,9 +137,9 @@ void generate_blake3s_proof_bench(State& state) noexcept
         for (size_t i = 0; i < idx; i++) {
             num_iterations *= PROOF_COUNT_LOG;
         }
-        external_composers[idx] = Composer();
-        generate_test_blake3s_plonk_circuit(external_builders[idx], num_iterations);
-        external_provers[idx] = external_composers[idx].create_prover(external_builders[idx]);
+        external_composers[idx] = new Composer();
+        generate_test_blake3s_plonk_circuit(*(Builder*)external_builders[idx], num_iterations);
+        external_provers[idx] = ((Composer*)external_composers[idx])->create_prover(*(Builder*)external_builders[idx]);
         external_proofs[idx] = external_provers[idx].construct_proof();
         // Proof size with no public inputs is always 2144
         // info("Proof Size for Blake3s hash count ", num_iterations, ": ", external_proofs[idx].proof_data.size());
@@ -158,7 +159,7 @@ static void generate_blake3s_verifier(const State& state)
 {
 
     size_t idx = static_cast<size_t>(state.range(0));
-    external_verifiers[idx] = external_composers[idx].create_verifier(external_builders[idx]);
+    external_verifiers[idx] = ((Composer*)external_composers[idx])->create_verifier(*(Builder*)external_builders[idx]);
 }
 
 /**
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
index e63c5a3c3717..c5724ac2a7fd 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
@@ -30,8 +30,8 @@ void generate_test_plonk_circuit(Builder& builder, size_t num_bytes)
     proof_system::plonk::stdlib::sha256<Builder>(input);
 }
 
-Builder builders[NUM_HASHES];
-Composer composers[NUM_HASHES];
+void* builders[NUM_HASHES];
+void* composers[NUM_HASHES];
 Prover provers[NUM_HASHES];
 Verifier verifiers[NUM_HASHES];
 plonk::proof proofs[NUM_HASHES];
@@ -40,8 +40,8 @@ void construct_witnesses_bench(State& state) noexcept
 {
     for (auto _ : state) {
         size_t idx = (static_cast<size_t>((state.range(0))) - START_BYTES) / BYTES_PER_CHUNK;
-        builders[idx] = Builder();
-        generate_test_plonk_circuit(builders[idx], static_cast<size_t>(state.range(0)));
+        builders[idx] = (void*)new Builder();
+        generate_test_plonk_circuit(*(Builder*)builders[idx], static_cast<size_t>(state.range(0)));
     }
 }
 BENCHMARK(construct_witnesses_bench)->DenseRange(START_BYTES, MAX_BYTES, BYTES_PER_CHUNK);
@@ -50,8 +50,8 @@ void preprocess_witnesses_bench(State& state) noexcept
 {
     for (auto _ : state) {
         size_t idx = (static_cast<size_t>((state.range(0))) - START_BYTES) / BYTES_PER_CHUNK;
-        composers[idx] = Composer();
-        provers[idx] = composers[idx].create_prover(builders[idx]);
+        composers[idx] = (void*)new Composer();
+        provers[idx] = ((Composer*)composers[idx])->create_prover(*(Builder*)builders[idx]);
         std::cout << "prover subgroup size = " << provers[idx].key->small_domain.size << std::endl;
         // printf("num bytes = %" PRIx64 ", num gates = %zu\n", state.range(0), composers[idx].get_num_gates());
     }
@@ -62,7 +62,7 @@ void construct_instances_bench(State& state) noexcept
 {
     for (auto _ : state) {
         size_t idx = (static_cast<size_t>((state.range(0))) - START_BYTES) / BYTES_PER_CHUNK;
-        verifiers[idx] = composers[idx].create_verifier(builders[idx]);
+        verifiers[idx] = ((Composer*)composers[idx])->create_verifier(*(Builder*)builders[idx]);
     }
 }
 BENCHMARK(construct_instances_bench)->DenseRange(START_BYTES, MAX_BYTES, BYTES_PER_CHUNK);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
index e642faecb0e2..28f2b8c5a0b4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
@@ -143,10 +143,10 @@ point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
 
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
+    fixed_group_init_quad_<fr> init_quad{ origin_points[0].x,
+                                          (origin_points[0].x - origin_points[1].x),
+                                          origin_points[0].y,
+                                          (origin_points[0].y - origin_points[1].y) };
 
     /**
      * Fill the gates as following:
@@ -180,7 +180,7 @@ point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
     fr x_alpha = accumulator_offset;
     std::vector<uint32_t> accumulator_witnesses;
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<fr> round_quad;
         round_quad.d = ctx->add_variable(accumulator_transcript[i]);
         round_quad.a = ctx->add_variable(multiplication_transcript[i].x);
         round_quad.b = ctx->add_variable(multiplication_transcript[i].y);
@@ -225,17 +225,16 @@ point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
                  *        - init_quad.q_x_2 * round_quad.d
                  *        + init_quad.q_x_2
                  * */
-                mul_quad x_init_quad{ .a = round_quad.a,
-                                      .b = round_quad.c,
-                                      .c = 0,
-                                      .d = round_quad.d,
-                                      .mul_scaling = -1,
-                                      .a_scaling = 0,
-                                      .b_scaling = init_quad.q_x_1,
-                                      .c_scaling = 0,
-                                      .d_scaling = -init_quad.q_x_2,
-                                      .const_scaling = init_quad.q_x_2 };
-                ctx->create_big_mul_gate(x_init_quad);
+                ctx->create_big_mul_gate({ .a = round_quad.a,
+                                           .b = round_quad.c,
+                                           .c = 0,
+                                           .d = round_quad.d,
+                                           .mul_scaling = -1,
+                                           .a_scaling = 0,
+                                           .b_scaling = init_quad.q_x_1,
+                                           .c_scaling = 0,
+                                           .d_scaling = -init_quad.q_x_2,
+                                           .const_scaling = init_quad.q_x_2 });
             }
             gates.create_fixed_group_add_gate_with_init(round_quad, init_quad);
         };
@@ -245,15 +244,15 @@ point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
 
     // In Turbo PLONK, this effectively just adds the last row of the table as witnesses.
     // In Standard PLONK, this also creates the constraint involving the final two rows.
-    add_quad add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
-                       ctx->add_variable(multiplication_transcript[num_quads].y),
-                       ctx->add_variable(x_alpha),
-                       ctx->add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
+    add_quad_<fr> add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
+                            ctx->add_variable(multiplication_transcript[num_quads].y),
+                            ctx->add_variable(x_alpha),
+                            ctx->add_variable(accumulator_transcript[num_quads]),
+                            fr::zero(),
+                            fr::zero(),
+                            fr::zero(),
+                            fr::zero(),
+                            fr::zero() };
     gates.create_fixed_group_add_gate_final(add_quad);
     accumulator_witnesses.push_back(add_quad.d);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
index b91574306ec7..1a5cb6ac44ef 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
@@ -22,9 +22,10 @@ namespace stdlib {
  */
 template <typename Composer> class pedersen_gates {
   public:
-    using fixed_group_add_quad = proof_system::fixed_group_add_quad;
-    using fixed_group_init_quad = proof_system::fixed_group_init_quad;
-    using add_quad = proof_system::add_quad;
+    using FF = typename Composer::FF;
+    using fixed_group_add_quad = proof_system::fixed_group_add_quad_<FF>;
+    using fixed_group_init_quad = proof_system::fixed_group_init_quad_<FF>;
+    using add_quad = proof_system::add_quad_<FF>;
 
     Composer* context;
     fixed_group_add_quad previous_add_quad;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
index 67e95f1735c7..164906d7b818 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.cpp
@@ -67,10 +67,14 @@ point<C> pedersen_plookup_hash<C>::add_points(const point& p1, const point& p2,
 
     point p3{ witness_t(ctx, x_3_raw), witness_t(ctx, y_3_raw) };
 
-    ecc_add_gate add_gate =
-        ecc_add_gate{ p1.x.witness_index, p1.y.witness_index, p2.x.witness_index,       p2.y.witness_index,
-                      p3.x.witness_index, p3.y.witness_index, endomorphism_coefficient, sign_coefficient };
-    ctx->create_ecc_add_gate(add_gate);
+    ctx->create_ecc_add_gate({ p1.x.witness_index,
+                               p1.y.witness_index,
+                               p2.x.witness_index,
+                               p2.y.witness_index,
+                               p3.x.witness_index,
+                               p3.y.witness_index,
+                               endomorphism_coefficient,
+                               sign_coefficient });
 
     return p3;
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
index 1480c61407a7..a3991444a614 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
@@ -156,15 +156,11 @@ template <typename Composer> class BigFieldBase {
             RANDOMSEED,
             _LAST
         };
-        Instruction& operator=(const Instruction& other) = default;
 
         struct Element {
-            Element() = default;
-            Element(const Element& other) = default;
-            Element(const Element&& other) { value = std::move(other.value); };
-            Element(fq in)
-                : value(in){};
-            Element& operator=(const Element& other) = default;
+            Element(uint64_t v)
+                : value(v)
+            {}
             fq value;
         };
         struct TwoArgs {
@@ -213,8 +209,9 @@ template <typename Composer> class BigFieldBase {
             uint8_t out3;
         };
         union ArgumentContents {
-            ArgumentContents() { element = Element(fq(0)); }
-            ArgumentContents& operator=(const ArgumentContents& other) = default;
+            ArgumentContents()
+                : randomseed(0)
+            {}
             uint32_t randomseed;
             Element element;
             TwoArgs twoArgs;
@@ -229,6 +226,7 @@ template <typename Composer> class BigFieldBase {
         OPCODE id;
         // Instruction arguments
         ArgumentContents arguments;
+
         /**
          * @brief Generate a random instruction
          *
@@ -1929,7 +1927,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BigFieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BigFieldBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1950,7 +1948,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BigFieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BigFieldBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
index 106b0b6a5b4e..2c3e7c5fc769 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
@@ -33,7 +33,7 @@ template <typename Composer> class BitArrayFuzzBase {
     typedef proof_system::plonk::stdlib::bit_array<Composer> bit_array_t;
     typedef proof_system::plonk::stdlib::byte_array<Composer> byte_array_t;
     template <size_t NumBytes, size_t NumWords>
-    static std::vector<uint8_t> to_vector(std::array<plonk::stdlib::uint32<Composer>, NumWords>& a32)
+    static std::vector<uint8_t> to_vector(std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords>& a32)
     {
         /* Convert array of uint32_t to vector of uint8_t */
         std::vector<uint8_t> v(NumBytes);
@@ -60,7 +60,7 @@ template <typename Composer> class BitArrayFuzzBase {
              */
             return static_cast<byte_array_t>(bit_array).get_value();
         } else if (bit_array.size() - offset == NumBits) {
-            std::array<plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
             bit_array.template populate_uint32_array<NumWords>(offset, a32);
             return to_vector<NumBytes, NumWords>(a32);
         } else {
@@ -92,7 +92,7 @@ template <typename Composer> class BitArrayFuzzBase {
              */
             return static_cast<byte_array_t>(bit_array).get_value();
         } else if (bit_array.size() == NumBits) {
-            std::array<plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
 
             /* Switch between two different methods to retrieve the uint32 array */
             if (cast_or_populate) {
@@ -444,7 +444,8 @@ template <typename Composer> class BitArrayFuzzBase {
                 if (bit_array.size() == MAX_ARRAY_SIZE / 32) {
                     std::array<uint32_t, MAX_ARRAY_SIZE> a32;
                     const auto a32_ =
-                        static_cast<std::array<plonk::stdlib::uint32<Composer>, MAX_ARRAY_SIZE>>(bit_array);
+                        static_cast<std::array<proof_system::plonk::stdlib::uint32<Composer>, MAX_ARRAY_SIZE>>(
+                            bit_array);
                     for (size_t i = 0; i < a32_.size(); i++) {
                         a32[i] = static_cast<uint32_t>(a32_[i].get_value());
                     }
@@ -881,7 +882,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BitArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BitArrayFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -902,7 +903,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BitArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BitArrayFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
index a106f811c550..0ee6c3ef8ad9 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
@@ -150,11 +150,16 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator&(const bool_t& other)
         fr q2(i_a * (1 - 2 * i_b));
         fr q3(-1);
         fr qc(i_a * i_b);
-
-        const poly_triple gate_coefficients{
-            witness_index, other.witness_index, result.witness_index, qm, q1, q2, q3, qc,
-        };
-        context->create_poly_gate(gate_coefficients);
+        context->create_poly_gate({
+            witness_index,
+            other.witness_index,
+            result.witness_index,
+            qm,
+            q1,
+            q2,
+            q3,
+            qc,
+        });
     } else if (witness_index != IS_CONSTANT && other.witness_index == IS_CONSTANT) {
         if (other.witness_bool ^ other.witness_inverted) {
             result = bool_t<ComposerContext>(*this);
@@ -229,11 +234,14 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator|(const bool_t& other)
             right_coefficient = barretenberg::fr::one();
             constant_coefficient = barretenberg::fr::zero();
         }
-        const poly_triple gate_coefficients{
-            witness_index,    other.witness_index, result.witness_index,        multiplicative_coefficient,
-            left_coefficient, right_coefficient,   barretenberg::fr::neg_one(), constant_coefficient
-        };
-        context->create_poly_gate(gate_coefficients);
+        context->create_poly_gate({ witness_index,
+                                    other.witness_index,
+                                    result.witness_index,
+                                    multiplicative_coefficient,
+                                    left_coefficient,
+                                    right_coefficient,
+                                    barretenberg::fr::neg_one(),
+                                    constant_coefficient });
     } else if (witness_index != IS_CONSTANT && other.witness_index == IS_CONSTANT) {
         if (other.witness_bool ^ other.witness_inverted) {
             result.witness_index = IS_CONSTANT;
@@ -289,11 +297,14 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator^(const bool_t& other)
             right_coefficient = barretenberg::fr::neg_one();
             constant_coefficient = barretenberg::fr::one();
         }
-        const poly_triple gate_coefficients{
-            witness_index,    other.witness_index, result.witness_index,        multiplicative_coefficient,
-            left_coefficient, right_coefficient,   barretenberg::fr::neg_one(), constant_coefficient
-        };
-        context->create_poly_gate(gate_coefficients);
+        context->create_poly_gate({ witness_index,
+                                    other.witness_index,
+                                    result.witness_index,
+                                    multiplicative_coefficient,
+                                    left_coefficient,
+                                    right_coefficient,
+                                    barretenberg::fr::neg_one(),
+                                    constant_coefficient });
     } else if (witness_index != IS_CONSTANT && other.witness_index == IS_CONSTANT) {
         // witness ^ 1 = !witness
         if (other.witness_bool ^ other.witness_inverted) {
@@ -364,11 +375,14 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator==(const bool_t& other)
             right_coefficient = barretenberg::fr::one();
             constant_coefficient = barretenberg::fr::zero();
         }
-        const poly_triple gate_coefficients{
-            witness_index,    other.witness_index, result.witness_index,        multiplicative_coefficient,
-            left_coefficient, right_coefficient,   barretenberg::fr::neg_one(), constant_coefficient
-        };
-        context->create_poly_gate(gate_coefficients);
+        context->create_poly_gate({ witness_index,
+                                    other.witness_index,
+                                    result.witness_index,
+                                    multiplicative_coefficient,
+                                    left_coefficient,
+                                    right_coefficient,
+                                    barretenberg::fr::neg_one(),
+                                    constant_coefficient });
         return result;
     }
 }
@@ -538,10 +552,7 @@ template <typename ComposerContext> bool_t<ComposerContext> bool_t<ComposerConte
     barretenberg::fr q_o = barretenberg::fr::neg_one();
     barretenberg::fr q_m = barretenberg::fr::zero();
     barretenberg::fr q_r = barretenberg::fr::zero();
-
-    const poly_triple gate_coefficients{ witness_index, witness_index, new_witness, q_m, q_l, q_r, q_o, q_c };
-
-    context->create_poly_gate(gate_coefficients);
+    context->create_poly_gate({ witness_index, witness_index, new_witness, q_m, q_l, q_r, q_o, q_c });
 
     witness_index = new_witness;
     witness_bool = new_value;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
index 06dc11eee668..072c9d47e2bc 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
@@ -800,7 +800,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BoolFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BoolFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -821,7 +821,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BoolFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BoolFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
index 6ec22b68cde6..63d45764eede 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
@@ -929,7 +929,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = ByteArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = ByteArrayFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -950,7 +950,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = ByteArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = ByteArrayFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
index 7db8a2ab0b09..52a83dda9a4a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
@@ -18,11 +18,13 @@ class Ultra;
 
 namespace barretenberg {
 class Bn254FrParams;
+class Bn254FqParams;
 template <class Params> struct alignas(32) field;
 } // namespace barretenberg
 namespace proof_system {
 template <class FF> class StandardCircuitBuilder_;
 using StandardCircuitBuilder = StandardCircuitBuilder_<barretenberg::field<barretenberg::Bn254FrParams>>;
+using StandardGrumpkinCircuitBuilder = StandardCircuitBuilder_<barretenberg::field<barretenberg::Bn254FqParams>>;
 template <class FF> class TurboCircuitBuilder_;
 using TurboCircuitBuilder = TurboCircuitBuilder_<barretenberg::field<barretenberg::Bn254FrParams>>;
 template <class FF> class UltraCircuitBuilder_;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
index 46a6487e6a38..a9b756f61806 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
@@ -121,14 +121,13 @@ field_t<ComposerContext> field_t<ComposerContext>::operator+(const field_t& othe
         out += other.additive_constant;
         result.witness_index = ctx->add_variable(out);
 
-        const add_triple gate_coefficients{ witness_index,
-                                            other.witness_index,
-                                            result.witness_index,
-                                            multiplicative_constant,
-                                            other.multiplicative_constant,
-                                            barretenberg::fr::neg_one(),
-                                            (additive_constant + other.additive_constant) };
-        ctx->create_add_gate(gate_coefficients);
+        ctx->create_add_gate({ witness_index,
+                               other.witness_index,
+                               result.witness_index,
+                               multiplicative_constant,
+                               other.multiplicative_constant,
+                               barretenberg::fr::neg_one(),
+                               (additive_constant + other.additive_constant) });
     }
     return result;
 }
@@ -233,15 +232,14 @@ field_t<ComposerContext> field_t<ComposerContext>::operator*(const field_t& othe
         out += T0;
         out += q_c;
         result.witness_index = ctx->add_variable(out);
-        const poly_triple gate_coefficients{ .a = witness_index,
-                                             .b = other.witness_index,
-                                             .c = result.witness_index,
-                                             .q_m = q_m,
-                                             .q_l = q_l,
-                                             .q_r = q_r,
-                                             .q_o = barretenberg::fr::neg_one(),
-                                             .q_c = q_c };
-        ctx->create_poly_gate(gate_coefficients);
+        ctx->create_poly_gate({ .a = witness_index,
+                                .b = other.witness_index,
+                                .c = result.witness_index,
+                                .q_m = q_m,
+                                .q_l = q_l,
+                                .q_r = q_r,
+                                .q_o = barretenberg::fr::neg_one(),
+                                .q_c = q_c });
     }
     return result;
 }
@@ -289,15 +287,14 @@ field_t<ComposerContext> field_t<ComposerContext>::divide_no_zero_check(const fi
             barretenberg::fr q_c = -get_value();
             barretenberg::fr out_value = get_value() / other.get_value();
             result.witness_index = ctx->add_variable(out_value);
-            const poly_triple gate_coefficients{ .a = result.witness_index,
-                                                 .b = other.witness_index,
-                                                 .c = result.witness_index,
-                                                 .q_m = q_m,
-                                                 .q_l = q_l,
-                                                 .q_r = 0,
-                                                 .q_o = 0,
-                                                 .q_c = q_c };
-            ctx->create_poly_gate(gate_coefficients);
+            ctx->create_poly_gate({ .a = result.witness_index,
+                                    .b = other.witness_index,
+                                    .c = result.witness_index,
+                                    .q_m = q_m,
+                                    .q_l = q_l,
+                                    .q_r = 0,
+                                    .q_o = 0,
+                                    .q_c = q_c });
         }
     } else {
         // TODO SHOULD WE CARE ABOUT IF THE DIVISOR IS ZERO?
@@ -335,15 +332,14 @@ field_t<ComposerContext> field_t<ComposerContext>::divide_no_zero_check(const fi
         barretenberg::fr q_o = -multiplicative_constant;
         barretenberg::fr q_c = -additive_constant;
 
-        const poly_triple gate_coefficients{ .a = result.witness_index,
-                                             .b = other.witness_index,
-                                             .c = witness_index,
-                                             .q_m = q_m,
-                                             .q_l = q_l,
-                                             .q_r = q_r,
-                                             .q_o = q_o,
-                                             .q_c = q_c };
-        ctx->create_poly_gate(gate_coefficients);
+        ctx->create_poly_gate({ .a = result.witness_index,
+                                .b = other.witness_index,
+                                .c = witness_index,
+                                .q_m = q_m,
+                                .q_l = q_l,
+                                .q_r = q_r,
+                                .q_o = q_o,
+                                .q_c = q_c });
     }
     return result;
 }
@@ -439,8 +435,7 @@ field_t<ComposerContext> field_t<ComposerContext>::madd(const field_t& to_mul, c
 
     field_t<ComposerContext> result(ctx);
     result.witness_index = ctx->add_variable(out);
-
-    const mul_quad gate_coefficients{
+    ctx->create_big_mul_gate({
         .a = witness_index == IS_CONSTANT ? ctx->zero_idx : witness_index,
         .b = to_mul.witness_index == IS_CONSTANT ? ctx->zero_idx : to_mul.witness_index,
         .c = to_add.witness_index == IS_CONSTANT ? ctx->zero_idx : to_add.witness_index,
@@ -451,8 +446,7 @@ field_t<ComposerContext> field_t<ComposerContext>::madd(const field_t& to_mul, c
         .c_scaling = q_3,
         .d_scaling = -barretenberg::fr(1),
         .const_scaling = q_c,
-    };
-    ctx->create_big_mul_gate(gate_coefficients);
+    });
     return result;
 }
 
@@ -481,7 +475,7 @@ field_t<ComposerContext> field_t<ComposerContext>::add_two(const field_t& add_a,
     field_t<ComposerContext> result(ctx);
     result.witness_index = ctx->add_variable(out);
 
-    const mul_quad gate_coefficients{
+    ctx->create_big_mul_gate({
         .a = witness_index == IS_CONSTANT ? ctx->zero_idx : witness_index,
         .b = add_a.witness_index == IS_CONSTANT ? ctx->zero_idx : add_a.witness_index,
         .c = add_b.witness_index == IS_CONSTANT ? ctx->zero_idx : add_b.witness_index,
@@ -492,8 +486,7 @@ field_t<ComposerContext> field_t<ComposerContext>::add_two(const field_t& add_a,
         .c_scaling = q_3,
         .d_scaling = -barretenberg::fr(1),
         .const_scaling = q_c,
-    };
-    ctx->create_big_mul_gate(gate_coefficients);
+    });
     return result;
 }
 
@@ -523,15 +516,13 @@ template <typename ComposerContext> field_t<ComposerContext> field_t<ComposerCon
     // <=> this.v * this.v * [ 0 ] + this.v * [this.mul] + this.v * [ 0 ] + result.v * [ -1] + [this.add] == 0
     // <=> this.v * this.v * [q_m] + this.v * [   q_l  ] + this.v * [q_r] + result.v * [q_o] + [   q_c  ] == 0
 
-    const add_triple gate_coefficients{ .a = witness_index,
-                                        .b = witness_index,
-                                        .c = result.witness_index,
-                                        .a_scaling = multiplicative_constant,
-                                        .b_scaling = 0,
-                                        .c_scaling = barretenberg::fr::neg_one(),
-                                        .const_scaling = additive_constant };
-
-    context->create_add_gate(gate_coefficients);
+    context->create_add_gate({ .a = witness_index,
+                               .b = witness_index,
+                               .c = result.witness_index,
+                               .a_scaling = multiplicative_constant,
+                               .b_scaling = 0,
+                               .c_scaling = barretenberg::fr::neg_one(),
+                               .const_scaling = additive_constant });
     return result;
 }
 
@@ -552,7 +543,8 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_zer
     // this.v * 0 * [q_m] + this.v * [   q_l  ] + 0 * [q_r] + 0 * [q_o] + [   q_c  ] == 0
 
     ComposerContext* ctx = context;
-    const poly_triple gate_coefficients{
+
+    context->create_poly_gate({
         .a = witness_index,
         .b = ctx->zero_idx,
         .c = ctx->zero_idx,
@@ -561,8 +553,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_zer
         .q_r = barretenberg::fr(0),
         .q_o = barretenberg::fr(0),
         .q_c = additive_constant,
-    };
-    context->create_poly_gate(gate_coefficients);
+    });
 }
 
 template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not_zero(std::string const& msg) const
@@ -593,7 +584,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not
     // <=> this.v * inverse.v * [   q_m  ] + this.v * [q_l] + inverse.v * [   q_r  ] + 0 * [q_o] + [q_c] == 0
 
     // (a * mul_const + add_const) * b - 1 = 0
-    const poly_triple gate_coefficients{
+    context->create_poly_gate({
         .a = witness_index,             // input value
         .b = inverse.witness_index,     // inverse
         .c = ctx->zero_idx,             // no output
@@ -602,8 +593,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not
         .q_r = additive_constant,       // b * mul_const
         .q_o = barretenberg::fr(0),     // c * 0
         .q_c = barretenberg::fr(-1),    // -1
-    };
-    context->create_poly_gate(gate_coefficients);
+    });
 }
 
 template <typename ComposerContext> bool_t<ComposerContext> field_t<ComposerContext>::is_zero() const
@@ -641,28 +631,28 @@ template <typename ComposerContext> bool_t<ComposerContext> field_t<ComposerCont
     barretenberg::fr q_r = barretenberg::fr::zero();
     barretenberg::fr q_o = barretenberg::fr::one();
     barretenberg::fr q_c = barretenberg::fr::neg_one();
-    const poly_triple gate_coefficients_a{ .a = k.witness_index,
-                                           .b = k_inverse.witness_index,
-                                           .c = is_zero.witness_index,
-                                           .q_m = q_m,
-                                           .q_l = q_l,
-                                           .q_r = q_r,
-                                           .q_o = q_o,
-                                           .q_c = q_c };
-    context->create_poly_gate(gate_coefficients_a);
+
+    context->create_poly_gate({ .a = k.witness_index,
+                                .b = k_inverse.witness_index,
+                                .c = is_zero.witness_index,
+                                .q_m = q_m,
+                                .q_l = q_l,
+                                .q_r = q_r,
+                                .q_o = q_o,
+                                .q_c = q_c });
 
     // is_zero * k_inverse - is_zero = 0
     q_o = barretenberg::fr::neg_one();
     q_c = barretenberg::fr::zero();
-    const poly_triple gate_coefficients_b{ .a = is_zero.witness_index,
-                                           .b = k_inverse.witness_index,
-                                           .c = is_zero.witness_index,
-                                           .q_m = q_m,
-                                           .q_l = q_l,
-                                           .q_r = q_r,
-                                           .q_o = q_o,
-                                           .q_c = q_c };
-    context->create_poly_gate(gate_coefficients_b);
+
+    context->create_poly_gate({ .a = is_zero.witness_index,
+                                .b = k_inverse.witness_index,
+                                .c = is_zero.witness_index,
+                                .q_m = q_m,
+                                .q_l = q_l,
+                                .q_r = q_r,
+                                .q_o = q_o,
+                                .q_c = q_c });
     return is_zero;
 }
 
@@ -897,7 +887,7 @@ void field_t<ComposerContext>::evaluate_linear_identity(const field_t& a,
     barretenberg::fr q_4 = d.multiplicative_constant;
     barretenberg::fr q_c = a.additive_constant + b.additive_constant + c.additive_constant + d.additive_constant;
 
-    const add_quad gate_coefficients{
+    ctx->create_big_add_gate({
         a.witness_index == IS_CONSTANT ? ctx->zero_idx : a.witness_index,
         b.witness_index == IS_CONSTANT ? ctx->zero_idx : b.witness_index,
         c.witness_index == IS_CONSTANT ? ctx->zero_idx : c.witness_index,
@@ -907,8 +897,7 @@ void field_t<ComposerContext>::evaluate_linear_identity(const field_t& a,
         q_3,
         q_4,
         q_c,
-    };
-    ctx->create_big_add_gate(gate_coefficients);
+    });
 }
 
 template <typename ComposerContext>
@@ -934,7 +923,7 @@ void field_t<ComposerContext>::evaluate_polynomial_identity(const field_t& a,
     barretenberg::fr q_4 = d.multiplicative_constant;
     barretenberg::fr q_c = a.additive_constant * b.additive_constant + c.additive_constant + d.additive_constant;
 
-    const mul_quad gate_coefficients{
+    ctx->create_big_mul_gate({
         a.witness_index == IS_CONSTANT ? ctx->zero_idx : a.witness_index,
         b.witness_index == IS_CONSTANT ? ctx->zero_idx : b.witness_index,
         c.witness_index == IS_CONSTANT ? ctx->zero_idx : c.witness_index,
@@ -945,8 +934,7 @@ void field_t<ComposerContext>::evaluate_polynomial_identity(const field_t& a,
         q_3,
         q_4,
         q_c,
-    };
-    ctx->create_big_mul_gate(gate_coefficients);
+    });
 }
 
 /**
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
index 53483c9f2f52..bbaa6f95e571 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
@@ -3,7 +3,7 @@
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/stdlib/primitives/bool/bool.hpp"
-#include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "cstring"
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wc99-designator"
 
@@ -98,7 +98,7 @@ FastRandom VarianceRNG(0);
 
 #define OPERATION_TYPE_SIZE 1
 
-#define ELEMENT_SIZE (sizeof(fr) + 1)
+#define ELEMENT_SIZE (sizeof(barretenberg::fr) + 1)
 #define TWO_IN_ONE_OUT 3
 #define THREE_IN_ONE_OUT 4
 #define SLICE_ARGS_SIZE 6
@@ -158,17 +158,8 @@ template <typename Composer> class FieldBase {
             INVERT,
             _LAST
         };
-        Instruction& operator=(const Instruction& other) = default;
-
-        struct Element {
-            Element() = default;
-            Element(const Element& other) = default;
-            Element(const Element&& other) { value = std::move(other.value); };
-            Element(fr in)
-                : value(in){};
-            Element& operator=(const Element& other) = default;
-            fr value;
-        };
+
+        typedef barretenberg::fr Element;
         struct SingleArg {
             uint8_t in;
         };
@@ -212,8 +203,6 @@ template <typename Composer> class FieldBase {
             uint8_t out3;
         };
         union ArgumentContents {
-            ArgumentContents() { element = Element(fr(0)); }
-            ArgumentContents& operator=(const ArgumentContents& other) = default;
             uint32_t randomseed;
             Element element;
             SingleArg singleArg;
@@ -229,6 +218,7 @@ template <typename Composer> class FieldBase {
         OPCODE id;
         // Instruction arguments
         ArgumentContents arguments;
+
         /**
          * @brief Generate a random instruction
          *
@@ -242,7 +232,6 @@ template <typename Composer> class FieldBase {
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
             uint8_t in1, in2, in3, lsb, msb, out, out1, out2, out3, mask_size;
             uint256_t mask, temp;
-            Instruction instr;
 
             // Depending on instruction
             switch (instruction_opcode) {
@@ -335,7 +324,9 @@ template <typename Composer> class FieldBase {
          * @return Mutated element
          */
         template <typename T>
-        inline static fr mutateFieldElement(fr e, T& rng, HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static barretenberg::fr mutateFieldElement(barretenberg::fr e,
+                                                          T& rng,
+                                                          HavocSettings& havoc_config) requires SimpleRng<T>
         {
             // With a certain probability, we apply changes to the Montgomery form, rather than the plain form. This
             // has merit, since the computation is performed in montgomery form and comparisons are often performed
@@ -354,9 +345,9 @@ template <typename Composer> class FieldBase {
             // Inverse conversion at the end
 #define INV_MONT_CONVERSION                                                                                            \
     if (convert_to_montgomery) {                                                                                       \
-        e = fr(value_data).from_montgomery_form();                                                                     \
+        e = barretenberg::fr(value_data).from_montgomery_form();                                                       \
     } else {                                                                                                           \
-        e = fr(value_data);                                                                                            \
+        e = barretenberg::fr(value_data);                                                                              \
     }
 
             // Pick the last value from the mutation distrivution vector
@@ -374,9 +365,9 @@ template <typename Composer> class FieldBase {
                     e = e.to_montgomery_form();
                 }
                 if (rng.next() & 1) {
-                    value_data = e + fr(rng.next() & 0xff);
+                    value_data = e + barretenberg::fr(rng.next() & 0xff);
                 } else {
-                    value_data = e - fr(rng.next() & 0xff);
+                    value_data = e - barretenberg::fr(rng.next() & 0xff);
                 }
                 if (convert_to_montgomery) {
                     e = e.from_montgomery_form();
@@ -386,31 +377,31 @@ template <typename Composer> class FieldBase {
                 MONT_CONVERSION
                 switch (rng.next() % 9) {
                 case 0:
-                    e = fr::zero();
+                    e = barretenberg::fr::zero();
                     break;
                 case 1:
-                    e = fr::one();
+                    e = barretenberg::fr::one();
                     break;
                 case 2:
-                    e = -fr::one();
+                    e = -barretenberg::fr::one();
                     break;
                 case 3:
-                    e = fr::one().sqrt().second;
+                    e = barretenberg::fr::one().sqrt().second;
                     break;
                 case 4:
-                    e = fr::one().sqrt().second.invert();
+                    e = barretenberg::fr::one().sqrt().second.invert();
                     break;
                 case 5:
-                    e = fr::get_root_of_unity(8);
+                    e = barretenberg::fr::get_root_of_unity(8);
                     break;
                 case 6:
-                    e = fr(2);
+                    e = barretenberg::fr(2);
                     break;
                 case 7:
-                    e = fr((fr::modulus - 1) / 2);
+                    e = barretenberg::fr((barretenberg::fr::modulus - 1) / 2);
                     break;
                 case 8:
-                    e = fr((fr::modulus));
+                    e = barretenberg::fr((barretenberg::fr::modulus));
                     break;
                 default:
                     abort();
@@ -447,8 +438,8 @@ template <typename Composer> class FieldBase {
                 // If it represents pushing a value on the stack with a 50% probability randomly sample a bit_range
                 // Maybe mutate the value
                 if (rng.next() & 1) {
-                    instruction.arguments.element.value =
-                        mutateFieldElement(instruction.arguments.element.value, rng, havoc_config);
+                    instruction.arguments.element =
+                        mutateFieldElement(instruction.arguments.element, rng, havoc_config);
                 }
                 break;
             case OPCODE::ASSERT_ZERO:
@@ -510,9 +501,9 @@ template <typename Composer> class FieldBase {
     // instruction is enabled (if it is -1,it's disabled )
     class ArgSizes {
       public:
-        static constexpr size_t CONSTANT = sizeof(fr);
-        static constexpr size_t WITNESS = sizeof(fr);
-        static constexpr size_t CONSTANT_WITNESS = sizeof(fr);
+        static constexpr size_t CONSTANT = sizeof(barretenberg::fr);
+        static constexpr size_t WITNESS = sizeof(barretenberg::fr);
+        static constexpr size_t CONSTANT_WITNESS = sizeof(barretenberg::fr);
         static constexpr size_t SQR = 2;
         static constexpr size_t ASSERT_EQUAL = 2;
         static constexpr size_t ASSERT_NOT_EQUAL = 2;
@@ -594,8 +585,8 @@ template <typename Composer> class FieldBase {
                           opcode == Instruction::OPCODE::CONSTANT_WITNESS) {
                 Instruction instr;
                 instr.id = static_cast<typename Instruction::OPCODE>(opcode);
-                // instr.arguments.element.value = fr::serialize_from_buffer(Data+1);
-                instr.arguments.element.value = fr::serialize_from_buffer(Data);
+                // instr.arguments.element = fr::serialize_from_buffer(Data+1);
+                instr.arguments.element = barretenberg::fr::serialize_from_buffer(Data);
                 return instr;
             };
             if constexpr (opcode == Instruction::OPCODE::ASSERT_ZERO ||
@@ -655,9 +646,7 @@ template <typename Composer> class FieldBase {
                           instruction_opcode == Instruction::OPCODE::WITNESS ||
                           instruction_opcode == Instruction::OPCODE::CONSTANT_WITNESS) {
                 *Data = instruction.id;
-                memcpy(Data + 1,
-                       &instruction.arguments.element.value.data[0],
-                       sizeof(instruction.arguments.element.value.data));
+                memcpy(Data + 1, &instruction.arguments.element.data[0], sizeof(instruction.arguments.element.data));
             }
 
             if constexpr (instruction_opcode == Instruction::OPCODE::ASSERT_ZERO ||
@@ -777,18 +766,18 @@ template <typename Composer> class FieldBase {
         }
 
       public:
-        fr base;
+        barretenberg::fr base;
         field_t field;
         ExecutionHandler() = default;
-        ExecutionHandler(fr a, field_t b)
+        ExecutionHandler(barretenberg::fr a, field_t b)
             : base(a)
             , field(b)
         {}
-        ExecutionHandler(fr a, field_t& b)
+        ExecutionHandler(barretenberg::fr a, field_t& b)
             : base(a)
             , field(b)
         {}
-        ExecutionHandler(fr& a, field_t& b)
+        ExecutionHandler(barretenberg::fr& a, field_t& b)
             : base(a)
             , field(b)
         {}
@@ -1019,7 +1008,7 @@ template <typename Composer> class FieldBase {
 #ifdef SHOW_INFORMATION
                 std::cout << "Construct via fr" << std::endl;
 #endif
-                return construct_via_cast<fr>(fr::modulus - 1);
+                return construct_via_cast<barretenberg::fr>(barretenberg::fr::modulus - 1);
             case 6:
 #if 1
                 /* Disabled because casting to bool_t can fail.
@@ -1027,10 +1016,10 @@ template <typename Composer> class FieldBase {
                  *
                  * TEST(stdlib_field, test_construct_via_bool_t)
                  * {
-                 *     plonk::StandardPlonkComposer composer = proof_system::plonk::StandardPlonkComposer();
-                 *     field_t a(witness_t(&composer, fr(uint256_t{0xf396b678452ebf15, 0x82ae10893982638b,
-                 * 0xdf185a29c65fbf80, 0x1d18b2de99e48308}))); field_t b = a - a; field_t c(static_cast<bool_t>(b));
-                 *     std::cout << c.get_value() << std::endl;
+                 *     proof_system::StandardCircuitConstructor composer =
+                 * proof_system::proof_system::StandardCircuitConstructor(); field_t a(witness_t(&composer,
+                 * fr(uint256_t{0xf396b678452ebf15, 0x82ae10893982638b, 0xdf185a29c65fbf80, 0x1d18b2de99e48308})));
+                 * field_t b = a - a; field_t c(static_cast<bool_t>(b)); std::cout << c.get_value() << std::endl;
                  * }
                  *
                  * According to Rumata this is because the input value needs to be normalized
@@ -1071,14 +1060,15 @@ template <typename Composer> class FieldBase {
                 // const auto bits = this->f().decompose_into_bits(num_bits);
                 const auto bits = this->f().decompose_into_bits();
 
-                std::vector<fr> frs(bits.size());
+                std::vector<barretenberg::fr> frs(bits.size());
                 for (size_t i = 0; i < bits.size(); i++) {
-                    frs[i] = bits[i].get_value() ? fr(uint256_t(1) << i) : 0;
+                    frs[i] = bits[i].get_value() ? barretenberg::fr(uint256_t(1) << i) : 0;
                 }
 
                 switch (VarianceRNG.next() % 2) {
                 case 0: {
-                    const fr field_from_bits = std::accumulate(frs.begin(), frs.end(), fr(0));
+                    const barretenberg::fr field_from_bits =
+                        std::accumulate(frs.begin(), frs.end(), barretenberg::fr(0));
                     return ExecutionHandler(this->base, field_t(composer, field_from_bits));
                 }
                 case 1: {
@@ -1104,7 +1094,7 @@ template <typename Composer> class FieldBase {
             if (this->base == 0) {
                 return ExecutionHandler(this->base, this->f());
             } else {
-                return ExecutionHandler(fr(1) / this->base, this->f().invert());
+                return ExecutionHandler(barretenberg::fr(1) / this->base, this->f().invert());
             }
         }
 
@@ -1121,10 +1111,10 @@ template <typename Composer> class FieldBase {
                                               Instruction& instruction)
         {
             (void)composer;
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value,
-                                             field_t(composer, instruction.arguments.element.value)));
+            stack.push_back(
+                ExecutionHandler(instruction.arguments.element, field_t(composer, instruction.arguments.element)));
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed constant value " << instruction.arguments.element.value << " to position "
+            std::cout << "Pushed constant value " << instruction.arguments.element << " to position "
                       << stack.size() - 1 << std::endl;
 #endif
             return 0;
@@ -1144,12 +1134,12 @@ template <typename Composer> class FieldBase {
         {
 
             // THis is strange
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value,
-                                             witness_t(composer, instruction.arguments.element.value)));
+            stack.push_back(
+                ExecutionHandler(instruction.arguments.element, witness_t(composer, instruction.arguments.element)));
 
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed witness value " << instruction.arguments.element.value << " to position "
-                      << stack.size() - 1 << std::endl;
+            std::cout << "Pushed witness value " << instruction.arguments.element << " to position " << stack.size() - 1
+                      << std::endl;
 #endif
             return 0;
         }
@@ -1167,11 +1157,11 @@ template <typename Composer> class FieldBase {
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            auto v = field_t(witness_t(composer, instruction.arguments.element.value));
-            v.convert_constant_to_witness(composer);
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value, std::move(v)));
+            auto v = field_t(witness_t(composer, instruction.arguments.element));
+            v.convert_constant_to_fixed_witness(composer);
+            stack.push_back(ExecutionHandler(instruction.arguments.element, std::move(v)));
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed constant witness value " << instruction.arguments.element.value << " to position "
+            std::cout << "Pushed constant witness value " << instruction.arguments.element << " to position "
                       << stack.size() - 1 << std::endl;
 #endif
             return 0;
@@ -1458,7 +1448,7 @@ template <typename Composer> class FieldBase {
             PRINT_TWO_ARG_INSTRUCTION(first_index, second_index, stack, "Dividing", "/")
 
             ExecutionHandler result;
-            if (fr((uint256_t(stack[second_index].f().get_value()) % fr::modulus)) == 0) {
+            if (barretenberg::fr((uint256_t(stack[second_index].f().get_value()) % barretenberg::fr::modulus)) == 0) {
                 return 0; // This is not handled by field
             }
             // TODO: FIX THIS. I can't think of an elegant fix for this field issue right now
@@ -1841,7 +1831,7 @@ template <typename Composer> class FieldBase {
         (void)composer;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
-            if (fr((uint256_t(element.field.get_value()) % fr::modulus)) != element.base) {
+            if (barretenberg::fr((uint256_t(element.field.get_value()) % barretenberg::fr::modulus)) != element.base) {
                 std::cerr << "Failed at " << i << " with actual value " << element.base << " and value in field "
                           << element.field.get_value() << std::endl;
                 return false;
@@ -1979,7 +1969,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = FieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = FieldBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -2000,7 +1990,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = FieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = FieldBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
index 43181df58827..5677bee9e774 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
@@ -138,27 +138,25 @@ template <typename Composer> class stdlib_field : public testing::Test {
                  */
                 if (true_when_y_val_zero) {
                     // constraint: 0*x + 1*y + 0*0 + 0 == 0
-                    add_triple t{ .a = x.witness_index,
-                                  .b = y.witness_index,
-                                  .c = composer.zero_idx,
-                                  .a_scaling = 0,
-                                  .b_scaling = 1,
-                                  .c_scaling = 0,
-                                  .const_scaling = 0 };
-
-                    composer.create_add_gate(t);
+
+                    composer.create_add_gate({ .a = x.witness_index,
+                                               .b = y.witness_index,
+                                               .c = composer.zero_idx,
+                                               .a_scaling = 0,
+                                               .b_scaling = 1,
+                                               .c_scaling = 0,
+                                               .const_scaling = 0 });
                     expected_result = false;
                 } else {
                     // constraint: 0*x + 1*y + 0*0 - 1 == 0
-                    add_triple t{ .a = x.witness_index,
-                                  .b = y.witness_index,
-                                  .c = composer.zero_idx,
-                                  .a_scaling = 0,
-                                  .b_scaling = 1,
-                                  .c_scaling = 0,
-                                  .const_scaling = -1 };
-
-                    composer.create_add_gate(t);
+
+                    composer.create_add_gate({ .a = x.witness_index,
+                                               .b = y.witness_index,
+                                               .c = composer.zero_idx,
+                                               .a_scaling = 0,
+                                               .b_scaling = 1,
+                                               .c_scaling = 0,
+                                               .const_scaling = -1 });
                     expected_result = true;
                 }
             }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
index 8023dad30dfe..90b666f95727 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
@@ -153,16 +153,16 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
 
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad init_quad{ origin_points[0].x,
-                                     (origin_points[0].x - origin_points[1].x),
-                                     origin_points[0].y,
-                                     (origin_points[0].y - origin_points[1].y) };
+    fixed_group_init_quad_<typename ComposerContext::FF> init_quad{ origin_points[0].x,
+                                                                    (origin_points[0].x - origin_points[1].x),
+                                                                    origin_points[0].y,
+                                                                    (origin_points[0].y - origin_points[1].y) };
 
     fr x_alpha = accumulator_offset;
     std::vector<uint32_t> accumulator_witnesses;
     pedersen_gates<ComposerContext> pedersen_gates(ctx);
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad round_quad;
+        fixed_group_add_quad_<typename ComposerContext::FF> round_quad;
         round_quad.d = ctx->add_variable(accumulator_transcript[i]);
         round_quad.a = ctx->add_variable(multiplication_transcript[i].x);
         round_quad.b = ctx->add_variable(multiplication_transcript[i].y);
@@ -193,15 +193,15 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
         accumulator_witnesses.push_back(round_quad.d);
     }
 
-    add_quad add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
-                       ctx->add_variable(multiplication_transcript[num_quads].y),
-                       ctx->add_variable(x_alpha),
-                       ctx->add_variable(accumulator_transcript[num_quads]),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero(),
-                       fr::zero() };
+    add_quad_<typename ComposerContext::FF> add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
+                                                      ctx->add_variable(multiplication_transcript[num_quads].y),
+                                                      ctx->add_variable(x_alpha),
+                                                      ctx->add_variable(accumulator_transcript[num_quads]),
+                                                      fr::zero(),
+                                                      fr::zero(),
+                                                      fr::zero(),
+                                                      fr::zero(),
+                                                      fr::zero() };
     ctx->create_big_add_gate(add_quad);
     accumulator_witnesses.push_back(add_quad.d);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
index d41b51107e84..f31c2c032580 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
@@ -9,6 +9,7 @@
 // the input should fail
 bool circuit_should_fail = false;
 
+using fr = barretenberg::fr;
 #define HAVOC_TESTING
 
 #include "barretenberg/common/fuzzer.hpp"
@@ -1417,7 +1418,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = SafeUintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = SafeUintFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1438,7 +1439,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = SafeUintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = SafeUintFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
index 26b10b520ea4..b1e5d26e6d90 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
@@ -80,7 +80,7 @@ uint<Composer, Native> uint<Composer, Native>::operator+(const uint& other) cons
      * is {0, 1, 2}.
      **/
 
-    const add_quad gate{
+    const add_quad_<typename Composer::FF> gate{
         .a = witness_index,
         .b = other.witness_index,
         .c = ctx->add_variable(remainder),
@@ -161,7 +161,7 @@ uint<Composer, Native> uint<Composer, Native>::operator-(const uint& other) cons
     //   witness - other_witness - remainder - 2**width . overflow + (2**width + constant_term) == 0
     // and
     //   overflow in {0, 1, 2}
-    const add_quad gate{
+    const add_quad_<typename Composer::FF> gate{
         .a = lhs_idx,
         .b = rhs_idx,
         .c = ctx->add_variable(remainder),
@@ -232,7 +232,7 @@ uint<Composer, Native> uint<Composer, Native>::operator*(const uint& other) cons
      *      ab + a const_b + b const_a - r - (2**width) overflow + (const_a const_b % 2**width) == 0
      */
 
-    const mul_quad gate{
+    const mul_quad_<typename Composer::FF> gate{
         .a = witness_index, // a
         .b = rhs_idx,       // b
         .c = ctx->add_variable(remainder),
@@ -344,30 +344,29 @@ std::pair<uint<Composer, Native>, uint<Composer, Native>> uint<Composer, Native>
 
     // constraint: qb + const_b q + 0 b - a + r - const_a == 0
     // i.e., a + const_a = q(b + const_b) + r
-    const mul_quad division_gate{ .a = quotient_idx,  // q
-                                  .b = divisor_idx,   // b
-                                  .c = dividend_idx,  // a
-                                  .d = remainder_idx, // r
-                                  .mul_scaling = fr::one(),
-                                  .a_scaling = other.additive_constant,
-                                  .b_scaling = fr::zero(),
-                                  .c_scaling = fr::neg_one(),
-                                  .d_scaling = fr::one(),
-                                  .const_scaling = -fr(additive_constant) };
-    ctx->create_big_mul_gate(division_gate);
+    ctx->create_big_mul_gate({ .a = quotient_idx,  // q
+                               .b = divisor_idx,   // b
+                               .c = dividend_idx,  // a
+                               .d = remainder_idx, // r
+                               .mul_scaling = fr::one(),
+                               .a_scaling = other.additive_constant,
+                               .b_scaling = fr::zero(),
+                               .c_scaling = fr::neg_one(),
+                               .d_scaling = fr::one(),
+                               .const_scaling = -fr(additive_constant) });
 
     // set delta = (b + const_b - r - 1)
     const uint256_t delta = divisor - r - 1;
     const uint32_t delta_idx = ctx->add_variable(delta);
 
     // constraint: b - r - delta + const_b - 1 == 0
-    const add_triple delta_gate{ .a = divisor_idx,
-                                 .b = remainder_idx,
-                                 .c = delta_idx,
-                                 .a_scaling = fr::one(),
-                                 .b_scaling = fr::neg_one(),
-                                 .c_scaling = fr::neg_one(),
-                                 .const_scaling = other.additive_constant + fr::neg_one() };
+    const add_triple_<typename Composer::FF> delta_gate{ .a = divisor_idx,
+                                                         .b = remainder_idx,
+                                                         .c = delta_idx,
+                                                         .a_scaling = fr::one(),
+                                                         .b_scaling = fr::neg_one(),
+                                                         .c_scaling = fr::neg_one(),
+                                                         .const_scaling = other.additive_constant + fr::neg_one() };
 
     ctx->create_add_gate(delta_gate);
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
index e9f3d8e6be0f..e22efc1e226a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
@@ -134,7 +134,7 @@ uint<Composer, Native> uint<Composer, Native>::operator>>(const size_t shift) co
     const uint32_t left_index = shift == width - 1 ? context->zero_idx : accumulators[static_cast<size_t>(idx - 1)];
 
     // Constraint: -6.(self >> shift) + 12.a[idx-1] + 6.high bit of (a[idx] - 4.a[idx-1]) = 0.
-    const add_quad gate{
+    const add_quad_<typename Composer::FF> gate{
         .a = context->zero_idx,
         .b = context->add_variable(output),
         .c = right_index,
@@ -199,13 +199,13 @@ uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) co
         const uint256_t output = (get_value() << shift) & MASK; // (value * 2**shift) % 2**32
 
         // constraint: A.2**shift - A_{x-1}.2**width + (value * 2**shift) % 2**32 == 0
-        const add_triple gate{ .a = base_idx,
-                               .b = right_idx,
-                               .c = context->add_variable(output),
-                               .a_scaling = base_shift_factor,
-                               .b_scaling = -fr(right_shift_factor),
-                               .c_scaling = fr::neg_one(),
-                               .const_scaling = fr::zero() };
+        const add_triple_<typename Composer::FF> gate{ .a = base_idx,
+                                                       .b = right_idx,
+                                                       .c = context->add_variable(output),
+                                                       .a_scaling = base_shift_factor,
+                                                       .b_scaling = -fr(right_shift_factor),
+                                                       .c_scaling = fr::neg_one(),
+                                                       .const_scaling = fr::zero() };
 
         context->create_add_gate(gate);
 
@@ -272,15 +272,15 @@ uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) co
      *                       + 6 * high bit of A_x - 4 A_{x-1}                                   ,
      * where A = witness and shift = s = 2x + 1 and A_{-1} = 0.
      */
-    const add_quad gate{ .a = context->add_variable(output),
-                         .b = base_index,
-                         .c = left_index,
-                         .d = right_index,
-                         .a_scaling = -q_1,
-                         .b_scaling = q_2,
-                         .c_scaling = fr::zero(),
-                         .d_scaling = -q_3,
-                         .const_scaling = fr::zero() };
+    const add_quad_<typename Composer::FF> gate{ .a = context->add_variable(output),
+                                                 .b = base_index,
+                                                 .c = left_index,
+                                                 .d = right_index,
+                                                 .a_scaling = -q_1,
+                                                 .b_scaling = q_2,
+                                                 .c_scaling = fr::zero(),
+                                                 .d_scaling = -q_3,
+                                                 .const_scaling = fr::zero() };
 
     context->create_big_add_gate_with_bit_extraction(gate);
 
@@ -344,13 +344,13 @@ uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation)
         const fr base_shift_factor = t1;
 
         // constraint: 4^{w-x} A + (1 - 4^w) A_pivot - out == 0
-        const add_triple gate{ .a = base_idx,
-                               .b = left_idx,
-                               .c = context->add_variable(output),
-                               .a_scaling = base_shift_factor,
-                               .b_scaling = left_shift_factor,
-                               .c_scaling = fr::neg_one(),
-                               .const_scaling = fr::zero() };
+        const add_triple_<typename Composer::FF> gate{ .a = base_idx,
+                                                       .b = left_idx,
+                                                       .c = context->add_variable(output),
+                                                       .a_scaling = base_shift_factor,
+                                                       .b_scaling = left_shift_factor,
+                                                       .c_scaling = fr::neg_one(),
+                                                       .const_scaling = fr::zero() };
 
         context->create_add_gate(gate);
 
@@ -413,15 +413,15 @@ uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation)
      *   -out + (2 * 4^{w-x}) A + (2 - 2 * 4^{w}) A_{w-x-1} + (1 - 4^w) a_{x-1, 1} == 0.
      *
      */
-    const add_quad gate{ .a = context->add_variable(output),
-                         .b = base_idx,
-                         .c = next_pivot_idx,
-                         .d = pivot_idx,
-                         .a_scaling = q_1,
-                         .b_scaling = q_2,
-                         .c_scaling = fr::zero(),
-                         .d_scaling = q_3,
-                         .const_scaling = fr::zero() };
+    const add_quad_<typename Composer::FF> gate{ .a = context->add_variable(output),
+                                                 .b = base_idx,
+                                                 .c = next_pivot_idx,
+                                                 .d = pivot_idx,
+                                                 .a_scaling = q_1,
+                                                 .b_scaling = q_2,
+                                                 .c_scaling = fr::zero(),
+                                                 .d_scaling = q_3,
+                                                 .const_scaling = fr::zero() };
 
     context->create_big_add_gate_with_bit_extraction(gate);
 
@@ -483,7 +483,7 @@ uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other,
     const uint32_t lhs_idx = is_constant() ? ctx->add_variable(lhs) : witness_index;
     const uint32_t rhs_idx = other.is_constant() ? ctx->add_variable(rhs) : other.witness_index;
 
-    accumulator_triple logic_accumulators;
+    accumulator_triple_<typename Composer::FF> logic_accumulators;
 
     switch (op_type) {
     case AND: {
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
index befd21c39277..ab461f3c14d2 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
@@ -10,6 +10,7 @@ namespace stdlib {
 template <typename Composer, typename Native>
 uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator+(const uint_plookup& other) const
 {
+
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
     Composer* ctx = (context == nullptr) ? other.context : context;
@@ -26,15 +27,15 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator+(const u
     const uint256_t overflow = sum >> width;
     const uint256_t remainder = sum & MASK;
 
-    const add_quad gate{
+    const add_quad_<FF> gate{
         is_constant() ? ctx->zero_idx : witness_index,
         other.is_constant() ? ctx->zero_idx : other.witness_index,
         ctx->add_variable(remainder),
         ctx->add_variable(overflow),
-        fr::one(),
-        fr::one(),
-        fr::neg_one(),
-        -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
+        FF::one(),
+        FF::one(),
+        FF::neg_one(),
+        -FF(CIRCUIT_UINT_MAX_PLUS_ONE),
         constants,
     };
 
@@ -50,6 +51,7 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator+(const u
 template <typename Composer, typename Native>
 uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator-(const uint_plookup& other) const
 {
+
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
 
@@ -71,15 +73,15 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator-(const u
     const uint256_t overflow = difference >> width;
     const uint256_t remainder = difference & MASK;
 
-    const add_quad gate{
+    const add_quad_<FF> gate{
         lhs_idx,
         rhs_idx,
         ctx->add_variable(remainder),
         ctx->add_variable(overflow),
-        fr::one(),
-        fr::neg_one(),
-        fr::neg_one(),
-        -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
+        FF::one(),
+        FF::neg_one(),
+        FF::neg_one(),
+        -FF(CIRCUIT_UINT_MAX_PLUS_ONE),
         CIRCUIT_UINT_MAX_PLUS_ONE + constant_term,
     };
 
@@ -95,6 +97,7 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator-(const u
 template <typename Composer, typename Native>
 uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator*(const uint_plookup& other) const
 {
+
     Composer* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
@@ -113,16 +116,16 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator*(const u
     const uint256_t overflow = product >> width;
     const uint256_t remainder = product & MASK;
 
-    const mul_quad gate{
+    const mul_quad_<FF> gate{
         witness_index,
         rhs_idx,
         ctx->add_variable(remainder),
         ctx->add_variable(overflow),
-        fr::one(),
+        FF::one(),
         other.additive_constant,
         additive_constant,
-        fr::neg_one(),
-        -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
+        FF::neg_one(),
+        -FF(CIRCUIT_UINT_MAX_PLUS_ONE),
         0,
     };
 
@@ -180,12 +183,12 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
     // We want to force the divisor to be non-zero, as this is an error state
     if (other.is_constant() && other.get_value() == 0) {
         // TODO: should have an actual error handler!
-        const uint32_t one = ctx->add_variable(fr::one());
-        ctx->assert_equal_constant(one, fr::zero());
+        const uint32_t one = ctx->add_variable(FF::one());
+        ctx->assert_equal_constant(one, FF::zero());
         ctx->failure("plookup_arithmetic: divide by zero!");
     } else if (!other.is_constant()) {
         const bool_t<Composer> is_divisor_zero = field_t<Composer>(other).is_zero();
-        ctx->assert_equal_constant(is_divisor_zero.witness_index, fr::zero(), "plookup_arithmetic: divide by zero!");
+        ctx->assert_equal_constant(is_divisor_zero.witness_index, FF::zero(), "plookup_arithmetic: divide by zero!");
     }
 
     if (is_constant() && other.is_constant()) {
@@ -210,17 +213,17 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
     const uint32_t quotient_idx = ctx->add_variable(q);
     const uint32_t remainder_idx = ctx->add_variable(r);
 
-    const mul_quad division_gate{
+    const mul_quad_<FF> division_gate{
         quotient_idx,            // q
         divisor_idx,             // b
         dividend_idx,            // a
         remainder_idx,           // r
-        fr::one(),               // q_m.w_1.w_2 = q.b
+        FF::one(),               // q_m.w_1.w_2 = q.b
         other.additive_constant, // q_l.w_1 = q.b if b const
-        fr::zero(),              // q_2.w_2 = 0
-        fr::neg_one(),           // q_3.w_3 = -a
-        fr::one(),               // q_4.w_4 = r
-        -fr(additive_constant)   // q_c = -a if a const
+        FF::zero(),              // q_2.w_2 = 0
+        FF::neg_one(),           // q_3.w_3 = -a
+        FF::one(),               // q_4.w_4 = r
+        -FF(additive_constant)   // q_c = -a if a const
     };
     ctx->create_big_mul_gate(division_gate);
 
@@ -228,13 +231,13 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
     const uint256_t delta = divisor - r;
 
     const uint32_t delta_idx = ctx->add_variable(delta);
-    const add_triple delta_gate{
+    const add_triple_<FF> delta_gate{
         divisor_idx,             // b
         remainder_idx,           // r
         delta_idx,               // d
-        fr::one(),               // q_l = 1
-        fr::neg_one(),           // q_r = -1
-        fr::neg_one(),           // q_o = -1
+        FF::one(),               // q_l = 1
+        FF::neg_one(),           // q_r = -1
+        FF::neg_one(),           // q_o = -1
         other.additive_constant, // q_c = d if const
     };
     ctx->create_add_gate(delta_gate);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
index 6b41f6c4ceee..1b7ed3d27752 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
@@ -10,6 +10,7 @@ namespace stdlib {
 
 template <typename Composer, typename Native> class uint_plookup {
   public:
+    using FF = typename Composer::FF;
     static constexpr size_t width = sizeof(Native) * 8;
 
     uint_plookup(const witness_t<Composer>& other);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
index e6cc06dfbbb1..2e14c6c0bf9b 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
@@ -215,15 +215,15 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
         const uint256_t value = get_unbounded_value();
         const uint256_t overflow = value >> width;
         const uint256_t remainder = value & MASK;
-        const add_quad gate{ .a = witness_index,
-                             .b = context->zero_idx,
-                             .c = context->add_variable(remainder),
-                             .d = context->add_variable(overflow),
-                             .a_scaling = fr::one(),
-                             .b_scaling = fr::zero(),
-                             .c_scaling = fr::neg_one(),
-                             .d_scaling = -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
-                             .const_scaling = (additive_constant & MASK) };
+        const add_quad_<typename Composer::FF> gate{ .a = witness_index,
+                                                     .b = context->zero_idx,
+                                                     .c = context->add_variable(remainder),
+                                                     .d = context->add_variable(overflow),
+                                                     .a_scaling = fr::one(),
+                                                     .b_scaling = fr::zero(),
+                                                     .c_scaling = fr::neg_one(),
+                                                     .d_scaling = -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
+                                                     .const_scaling = (additive_constant & MASK) };
 
         context->create_balanced_add_gate(gate);
 
@@ -323,7 +323,7 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
         // difference in quads = 0, 1, 2, 3 = delta
         // (delta - lo_bit) / 2 \in [0, 1]
         // lo_bit \in [0, 1]
-        add_quad gate{
+        add_quad_<typename Composer::FF> gate{
             context->add_variable(lo_bit), context->add_variable(hi_bit), right_idx, left_idx, 1, 2, -1, 4, 0,
         };
         context->create_new_range_constraint(gate.a, 1);
@@ -352,15 +352,15 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
     if ((bit_index & 1UL) == 0UL) {
         // we want a low bit
         uint256_t lo_bit = quad & 1;
-        add_quad gate{ .a = context->add_variable(lo_bit),
-                       .b = context->zero_idx,
-                       .c = right_idx,
-                       .d = left_idx,
-                       .a_scaling = fr(3),
-                       .b_scaling = fr::zero(),
-                       .c_scaling = -fr(3),
-                       .d_scaling = fr(12),
-                       .const_scaling = fr::zero() };
+        add_quad_<typename Composer::FF> gate{ .a = context->add_variable(lo_bit),
+                                               .b = context->zero_idx,
+                                               .c = right_idx,
+                                               .d = left_idx,
+                                               .a_scaling = fr(3),
+                                               .b_scaling = fr::zero(),
+                                               .c_scaling = -fr(3),
+                                               .d_scaling = fr(12),
+                                               .const_scaling = fr::zero() };
         /** constraint:
          *    3 lo_bit + 0 * 0 - 3 a_pivot + 12 a_{pivot - 1} + 0 + 6 high bit of (A_pivot - 4 A_{pivot - 1}) == 0
          *  i.e.,
@@ -376,15 +376,15 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
     // if 'index' is odd, we want a high bit
     uint256_t hi_bit = quad >> 1;
 
-    add_quad gate{ .a = context->zero_idx,
-                   .b = context->add_variable(hi_bit),
-                   .c = right_idx,
-                   .d = left_idx,
-                   .a_scaling = fr::zero(),
-                   .b_scaling = -fr(6),
-                   .c_scaling = fr::zero(),
-                   .d_scaling = fr::zero(),
-                   .const_scaling = fr::zero() };
+    add_quad_<typename Composer::FF> gate{ .a = context->zero_idx,
+                                           .b = context->add_variable(hi_bit),
+                                           .c = right_idx,
+                                           .d = left_idx,
+                                           .a_scaling = fr::zero(),
+                                           .b_scaling = -fr(6),
+                                           .c_scaling = fr::zero(),
+                                           .d_scaling = fr::zero(),
+                                           .const_scaling = fr::zero() };
 
     /**
      * constraint:
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
index 921f5cbc0e6b..a609935c200b 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
@@ -1545,7 +1545,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = UintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = UintFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1566,7 +1566,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = UintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = UintFuzzBase<proof_system::StandardCircuitConstructor>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
index 5b0e1a6287a7..24778dc6efca 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
@@ -1129,17 +1129,16 @@ template <typename Composer> class stdlib_uint : public testing::Test {
 
         // constraint: qb + const_b q + 0 b - a + r - const_a == 0
         // i.e., a + const_a = q(b + const_b) + r
-        const mul_quad division_gate{ .a = quotient_idx,  // q
-                                      .b = divisor_idx,   // b
-                                      .c = dividend_idx,  // a
-                                      .d = remainder_idx, // r
-                                      .mul_scaling = fr::one(),
-                                      .a_scaling = b.get_additive_constant(),
-                                      .b_scaling = fr::zero(),
-                                      .c_scaling = fr::neg_one(),
-                                      .d_scaling = fr::one(),
-                                      .const_scaling = -a.get_additive_constant() };
-        composer.create_big_mul_gate(division_gate);
+        composer.create_big_mul_gate({ .a = quotient_idx,  // q
+                                       .b = divisor_idx,   // b
+                                       .c = dividend_idx,  // a
+                                       .d = remainder_idx, // r
+                                       .mul_scaling = fr::one(),
+                                       .a_scaling = b.get_additive_constant(),
+                                       .b_scaling = fr::zero(),
+                                       .c_scaling = fr::neg_one(),
+                                       .d_scaling = fr::one(),
+                                       .const_scaling = -a.get_additive_constant() });
 
         // set delta = (b + const_b - r)
 
@@ -1147,7 +1146,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         const uint256_t delta = divisor - r - 1;
         const uint32_t delta_idx = composer.add_variable(delta);
 
-        const add_triple delta_gate{
+        composer.create_add_gate({
             .a = divisor_idx,   // b
             .b = remainder_idx, // r
             .c = delta_idx,     // d
@@ -1155,9 +1154,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             .b_scaling = fr::neg_one(),
             .c_scaling = fr::neg_one(),
             .const_scaling = b.get_additive_constant(),
-        };
-
-        composer.create_add_gate(delta_gate);
+        });
 
         // validate delta is in the correct range
         stdlib::field_t<Composer>::from_witness_index(&composer, delta_idx)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index b5ac65cb7fd5..aa990dce7dde 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -444,7 +444,7 @@ template <typename Curve> struct verification_key {
 
     // Native data:
 
-    std::shared_ptr<barretenberg::srs::factories::VerifierCrs> reference_string;
+    std::shared_ptr<barretenberg::srs::factories::VerifierCrs<curve::BN254>> reference_string;
 
     PolynomialManifest polynomial_manifest;
     // Used to check in the circuit if a proof contains any aggregated state.
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
index 26765efd3725..440049eac32f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
@@ -57,7 +57,7 @@ TYPED_TEST(VerificationKeyFixture, vk_data_vs_recursion_compress_native)
     verification_key_data vk_data = TestFixture::rand_vk_data();
     verification_key_data vk_data_copy = vk_data;
 
-    auto file_crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto file_crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto file_verifier = file_crs->get_verifier_crs();
 
     auto native_vk = std::make_shared<verification_key>(std::move(vk_data_copy), file_verifier);
@@ -77,7 +77,7 @@ TYPED_TEST(VerificationKeyFixture, compress_vs_compress_native)
 
     verification_key_data vk_data = TestFixture::rand_vk_data();
 
-    auto file_crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory>("../srs_db/ignition");
+    auto file_crs = std::make_unique<barretenberg::srs::factories::FileCrsFactory<curve::BN254>>("../srs_db/ignition");
     auto file_verifier = file_crs->get_verifier_crs();
 
     auto native_vk = std::make_shared<verification_key>(std::move(vk_data), file_verifier);