diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
index 079ae269f7f..1a2fcda97c4 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/grumpkin_srs_gen/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
index ab74222c700..bc7540c7258 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 (NOT(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/solidity_helpers/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
index bf448229a81..d0281e4e1a2 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 (NOT(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/stdlib/primitives/bigfield/bigfield.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
index 1480c61407a..a3991444a61 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 106b0b6a5b4..2c3e7c5fc76 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.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
index 06dc11eee66..072c9d47e2b 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 6ec22b68cde..63d45764eed 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/field/field.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
index 53483c9f2f5..bbaa6f95e57 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/safe_uint/safe_uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
index d41b51107e8..f31c2c03258 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/uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
index 921f5cbc0e6..a609935c200 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);