chore: Remove usage of ComposerHelper and use CircuitBuilder from the API

barretenberg.code-workspace

@@ -156,5 +156,6 @@
             "-g"
         ],
         "cmake.useCMakePresets": "auto",
+        "editor.inlayHints.enabled": "offUnlessPressed"
     },
 }

cpp/.aztec-packages-commit

@@ -1 +1 @@
-64c8ba700b75df07a8452a6f2eae3d23cf7625a6
+master

cpp/src/barretenberg/barretenberg.hpp

@@ -21,11 +21,11 @@
 #include "ecc/curves/grumpkin/grumpkin.hpp"
 #include "numeric/random/engine.hpp"
 #include "numeric/uint256/uint256.hpp"
-#include "proof_system/circuit_constructors/turbo_circuit_constructor.hpp"
-#include "proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
+#include "proof_system/circuit_builder/turbo_circuit_builder.hpp"
+#include "proof_system/circuit_builder/ultra_circuit_builder.hpp"
 #include "plonk/proof_system/types/proof.hpp"
 #include "plonk/proof_system/verification_key/verification_key.hpp"
-#include "proof_system/types/composer_type.hpp"
+#include "proof_system/types/circuit_type.hpp"
 // TODO(https://github.com/AztecProtocol/barretenberg/issues/491):
 //     consider helper header(s) for serialization and other non-stdlib includes
 //         - possibly: common, serialize, srs, transcript

cpp/src/barretenberg/benchmark/honk_bench/benchmark_utilities.hpp

@@ -180,15 +180,15 @@ template <typename Builder> void generate_merkle_membership_test_circuit(Builder
  */
 template <typename Composer>
 void construct_proof_with_specified_num_gates(State& state,
-                                              void (*test_circuit_function)(typename Composer::CircuitConstructor&,
+                                              void (*test_circuit_function)(typename Composer::CircuitBuilder&,
                                                                             size_t)) noexcept
 {
     barretenberg::srs::init_crs_factory("../srs_db/ignition");
     auto num_gates = static_cast<size_t>(1 << (size_t)state.range(0));
     for (auto _ : state) {
         // Constuct circuit and prover; don't include this part in measurement
         state.PauseTiming();
-        auto builder = typename Composer::CircuitConstructor();
+        auto builder = typename Composer::CircuitBuilder();
         test_circuit_function(builder, num_gates);
 
         auto composer = Composer();
@@ -212,15 +212,15 @@ void construct_proof_with_specified_num_gates(State& state,
  */
 template <typename Composer>
 void construct_proof_with_specified_num_iterations(State& state,
-                                                   void (*test_circuit_function)(typename Composer::CircuitConstructor&,
+                                                   void (*test_circuit_function)(typename Composer::CircuitBuilder&,
                                                                                  size_t)) noexcept
 {
     barretenberg::srs::init_crs_factory("../srs_db/ignition");
     auto num_iterations = static_cast<size_t>(state.range(0));
     for (auto _ : state) {
         // Constuct circuit and prover; don't include this part in measurement
         state.PauseTiming();
-        auto builder = typename Composer::CircuitConstructor();
+        auto builder = typename Composer::CircuitBuilder();
         test_circuit_function(builder, num_iterations);
 
         auto composer = Composer();

cpp/src/barretenberg/benchmark/honk_bench/honk.bench.cpp

@@ -1,6 +1,6 @@
 #include <benchmark/benchmark.h>
 #include <cstddef>
-#include "barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.hpp"
+#include "barretenberg/honk/composer/standard_composer.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
 #include "barretenberg/stdlib/primitives/witness/witness.hpp"
 
@@ -9,8 +9,8 @@ using namespace proof_system::plonk::stdlib;
 
 namespace standard_honk_bench {
 
-using Builder = proof_system::StandardCircuitConstructor;
-using Composer = proof_system::honk::StandardHonkComposerHelper;
+using Builder = proof_system::StandardCircuitBuilder;
+using Composer = proof_system::honk::StandardComposer;
 
 constexpr size_t MIN_LOG_NUM_GATES = 16;
 constexpr size_t MAX_LOG_NUM_GATES = 16;

cpp/src/barretenberg/benchmark/honk_bench/standard_honk.bench.cpp

@@ -1,13 +1,13 @@
 #include "barretenberg/benchmark/honk_bench/benchmark_utilities.hpp"
-#include "barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.hpp"
-#include "barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.hpp"
+#include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
+#include "barretenberg/honk/composer/standard_composer.hpp"
 
 using namespace benchmark;
 
 namespace standard_honk_bench {
 
-using StandardBuilder = proof_system::StandardCircuitConstructor;
-using StandardHonk = proof_system::honk::StandardHonkComposerHelper;
+using StandardBuilder = proof_system::StandardCircuitBuilder;
+using StandardHonk = proof_system::honk::StandardComposer;
 
 // Log number of gates for test circuit
 constexpr size_t MIN_LOG_NUM_GATES = bench_utils::BenchParams::MIN_LOG_NUM_GATES;

cpp/src/barretenberg/benchmark/honk_bench/standard_plonk.bench.cpp

@@ -1,13 +1,13 @@
 #include "barretenberg/benchmark/honk_bench/benchmark_utilities.hpp"
-#include "barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.hpp"
-#include "barretenberg/plonk/composer/composer_helper/standard_plonk_composer_helper.hpp"
+#include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
 
 using namespace benchmark;
 
 namespace standard_plonk_bench {
 
-using StandardBuilder = proof_system::StandardCircuitConstructor;
-using StandardPlonk = proof_system::plonk::StandardPlonkComposerHelper;
+using StandardBuilder = proof_system::StandardCircuitBuilder;
+using StandardPlonk = proof_system::plonk::StandardComposer;
 
 // Log number of gates for test circuit
 constexpr size_t MIN_LOG_NUM_GATES = bench_utils::BenchParams::MIN_LOG_NUM_GATES;

cpp/src/barretenberg/benchmark/honk_bench/ultra_honk.bench.cpp

@@ -1,16 +1,16 @@
 #include <benchmark/benchmark.h>
 
-#include "barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
-#include "barretenberg/honk/composer/composer_helper/ultra_honk_composer_helper.hpp"
+#include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
+#include "barretenberg/honk/composer/ultra_composer.hpp"
 #include "barretenberg/benchmark/honk_bench/benchmark_utilities.hpp"
 
 using namespace benchmark;
 using namespace proof_system::plonk;
 
 namespace ultra_honk_bench {
 
-using UltraBuilder = proof_system::UltraCircuitConstructor;
-using UltraHonk = proof_system::honk::UltraHonkComposerHelper;
+using UltraBuilder = proof_system::UltraCircuitBuilder;
+using UltraHonk = proof_system::honk::UltraComposer;
 
 // Number of times to perform operation of interest in the benchmark circuits, e.g. # of hashes to perform
 constexpr size_t MIN_NUM_ITERATIONS = bench_utils::BenchParams::MIN_NUM_ITERATIONS;

cpp/src/barretenberg/benchmark/honk_bench/ultra_plonk.bench.cpp

@@ -1,13 +1,13 @@
 #include "barretenberg/benchmark/honk_bench/benchmark_utilities.hpp"
-#include "barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp"
-#include "barretenberg/plonk/composer/composer_helper/ultra_plonk_composer_helper.hpp"
+#include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 
 using namespace benchmark;
 
 namespace ultra_plonk_bench {
 
-using UltraBuilder = proof_system::UltraCircuitConstructor;
-using UltraPlonk = proof_system::plonk::UltraPlonkComposerHelper;
+using UltraBuilder = proof_system::UltraCircuitBuilder;
+using UltraPlonk = proof_system::plonk::UltraComposer;
 
 // Number of times to perform operation of interest in the benchmark circuits, e.g. # of hashes to perform
 constexpr size_t MIN_NUM_ITERATIONS = bench_utils::BenchParams::MIN_NUM_ITERATIONS;

cpp/src/barretenberg/benchmark/plonk_bench/plonk.bench.cpp

@@ -1,6 +1,6 @@
 #include <benchmark/benchmark.h>
-#include "barretenberg/proof_system/circuit_constructors/standard_circuit_constructor.hpp"
-#include "barretenberg/plonk/composer/composer_helper/standard_plonk_composer_helper.hpp"
+#include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
 
 using namespace benchmark;
@@ -12,8 +12,8 @@ constexpr size_t START = (MAX_GATES) >> (NUM_CIRCUITS - 1);
 // constexpr size_t MAX_HASH_ROUNDS = 8192;
 // constexpr size_t START_HASH_ROUNDS = 64;
 
-using Builder = proof_system::StandardCircuitConstructor;
-using Composer = proof_system::plonk::StandardPlonkComposerHelper;
+using Builder = proof_system::StandardCircuitBuilder;
+using Composer = proof_system::plonk::StandardComposer;
 
 void generate_test_plonk_circuit(Builder& builder, size_t num_gates)
 {

cpp/src/barretenberg/common/fuzzer.hpp

@@ -1,6 +1,6 @@
 #pragma once
-#include "barretenberg/plonk/composer/standard_plonk_composer.hpp"
-#include "barretenberg/plonk/composer/turbo_plonk_composer.hpp"
+#include "barretenberg/plonk/composer/standard_composer.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
 #include <concepts>
 
 #define PARENS ()

cpp/src/barretenberg/common/fuzzer_constants.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 
-enum ComposerType : uint64_t {
+enum CircuitType : uint64_t {
     Standard = 1 << 0,
     Turbo = 1 << 1,
 };

cpp/src/barretenberg/dsl/acir_format/recursion_constraint.cpp

@@ -43,8 +43,8 @@ void create_recursion_constraints(Builder& builder,
     // on-curve errors and inverting-zero errors
     {
         // get a fake key/proof that satisfies on-curve + inversion-zero checks
-        const std::vector<fr> dummy_key = export_dummy_key_in_recursion_format(PolynomialManifest(Builder::type),
-                                                                               inner_proof_contains_recursive_proof);
+        const std::vector<fr> dummy_key = export_dummy_key_in_recursion_format(
+            PolynomialManifest(Builder::CIRCUIT_TYPE), inner_proof_contains_recursive_proof);
         const auto manifest = Composer::create_manifest(input.public_inputs.size());
         const std::vector<barretenberg::fr> dummy_proof =
             export_dummy_transcript_in_recursion_format(manifest, inner_proof_contains_recursive_proof);
@@ -180,7 +180,7 @@ std::vector<barretenberg::fr> export_key_in_recursion_format(std::shared_ptr<ver
     }
 
     verification_key_data vkey_data{
-        .composer_type = vkey->composer_type,
+        .circuit_type = static_cast<uint32_t>(vkey->circuit_type),
         .circuit_size = static_cast<uint32_t>(vkey->circuit_size),
         .num_public_inputs = static_cast<uint32_t>(vkey->num_public_inputs),
         .commitments = vkey->commitments,

cpp/src/barretenberg/dsl/types.hpp

@@ -1,8 +1,8 @@
 #pragma once
-#include "barretenberg/plonk/composer/composer_helper/turbo_plonk_composer_helper.hpp"
-#include "barretenberg/plonk/composer/composer_helper/ultra_plonk_composer_helper.hpp"
+#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/plonk/composer/ultra_composer.hpp"
 
-#include "barretenberg/proof_system/circuit_constructors/turbo_circuit_constructor.hpp"
+#include "barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp"
 #include "barretenberg/plonk/proof_system/prover/prover.hpp"
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
 #include "barretenberg/stdlib/primitives/biggroup/biggroup.hpp"
@@ -28,18 +28,18 @@
 
 namespace acir_format {
 
-using Builder = proof_system::UltraCircuitConstructor;
-using Composer = plonk::UltraPlonkComposerHelper;
+using Builder = proof_system::UltraCircuitBuilder;
+using Composer = plonk::UltraComposer;
 
 using Prover = std::conditional_t<
-    std::same_as<Composer, plonk::UltraPlonkComposerHelper>,
+    std::same_as<Composer, plonk::UltraComposer>,
     plonk::UltraWithKeccakProver,
-    std::conditional_t<std::same_as<Composer, plonk::TurboPlonkComposerHelper>, plonk::TurboProver, plonk::Prover>>;
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboProver, plonk::Prover>>;
 
 using Verifier = std::conditional_t<
-    std::same_as<Composer, plonk::UltraPlonkComposerHelper>,
+    std::same_as<Composer, plonk::UltraComposer>,
     plonk::UltraWithKeccakVerifier,
-    std::conditional_t<std::same_as<Composer, plonk::TurboPlonkComposerHelper>, plonk::TurboVerifier, plonk::Verifier>>;
+    std::conditional_t<std::same_as<Composer, plonk::TurboComposer>, plonk::TurboVerifier, plonk::Verifier>>;
 
 using RecursiveProver = plonk::UltraProver;
 

cpp/src/barretenberg/honk/composer/composer_helper/standard_honk_composer_helper.cpp → cpp/src/barretenberg/honk/composer/standard_composer.cpp

@@ -1,4 +1,4 @@
-#include "standard_honk_composer_helper.hpp"
+#include "standard_composer.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/honk/pcs/commitment_key.hpp"
 #include "barretenberg/numeric/bitop/get_msb.hpp"
@@ -23,13 +23,13 @@ namespace proof_system::honk {
  * @return Pointer to the initialized proving key updated with selector polynomials.
  * */
 template <StandardFlavor Flavor>
-std::shared_ptr<typename Flavor::ProvingKey> StandardHonkComposerHelper_<Flavor>::compute_proving_key_base(
-    const CircuitConstructor& constructor, const size_t minimum_circuit_size, const size_t num_randomized_gates)
+std::shared_ptr<typename Flavor::ProvingKey> StandardComposer_<Flavor>::compute_proving_key_base(
+    const CircuitBuilder& constructor, const size_t minimum_circuit_size, const size_t num_randomized_gates)
 {
     // Initialize proving_key
     // TODO(#392)(Kesha): replace composer types.
-    proving_key = initialize_proving_key<Flavor>(
-        constructor, crs_factory_.get(), minimum_circuit_size, num_randomized_gates, ComposerType::STANDARD_HONK);
+    proving_key =
+        initialize_proving_key<Flavor>(constructor, crs_factory_.get(), minimum_circuit_size, num_randomized_gates);
     // Compute lagrange selectors
     construct_selector_polynomials<Flavor>(constructor, proving_key.get());
 
@@ -46,8 +46,8 @@ std::shared_ptr<typename Flavor::ProvingKey> StandardHonkComposerHelper_<Flavor>
  * @tparam Program settings needed to establish if w_4 is being used.
  * */
 template <StandardFlavor Flavor>
-void StandardHonkComposerHelper_<Flavor>::compute_witness(const CircuitConstructor& circuit_constructor,
-                                                          const size_t minimum_circuit_size)
+void StandardComposer_<Flavor>::compute_witness(const CircuitBuilder& circuit_constructor,
+                                                const size_t minimum_circuit_size)
 {
     if (computed_witness) {
         return;
@@ -70,15 +70,14 @@ void StandardHonkComposerHelper_<Flavor>::compute_witness(const CircuitConstruct
  * */
 
 template <StandardFlavor Flavor>
-std::shared_ptr<typename Flavor::ProvingKey> StandardHonkComposerHelper_<Flavor>::compute_proving_key(
-    const CircuitConstructor& circuit_constructor)
+std::shared_ptr<typename Flavor::ProvingKey> StandardComposer_<Flavor>::compute_proving_key(
+    const CircuitBuilder& circuit_constructor)
 {
     if (proving_key) {
         return proving_key;
     }
     // Compute q_l, q_r, q_o, etc polynomials
-    StandardHonkComposerHelper_::compute_proving_key_base(
-        circuit_constructor, /*minimum_circuit_size=*/0, NUM_RESERVED_GATES);
+    StandardComposer_::compute_proving_key_base(circuit_constructor, /*minimum_circuit_size=*/0, NUM_RESERVED_GATES);
 
     // Compute sigma polynomials (we should update that late)
     compute_standard_honk_sigma_permutations<Flavor>(circuit_constructor, proving_key.get());
@@ -95,15 +94,15 @@ std::shared_ptr<typename Flavor::ProvingKey> StandardHonkComposerHelper_<Flavor>
  * @return Pointer to created circuit verification key.
  * */
 template <StandardFlavor Flavor>
-std::shared_ptr<typename Flavor::VerificationKey> StandardHonkComposerHelper_<Flavor>::compute_verification_key(
-    const CircuitConstructor& circuit_constructor)
+std::shared_ptr<typename Flavor::VerificationKey> StandardComposer_<Flavor>::compute_verification_key(
+    const CircuitBuilder& circuit_constructor)
 {
     if (verification_key) {
         return verification_key;
     }
 
-    verification_key = std::make_shared<typename Flavor::VerificationKey>(
-        proving_key->circuit_size, proving_key->num_public_inputs, proving_key->composer_type);
+    verification_key =
+        std::make_shared<typename Flavor::VerificationKey>(proving_key->circuit_size, proving_key->num_public_inputs);
 
     // Compute and store commitments to all precomputed polynomials
     verification_key->q_m = commitment_key->commit(proving_key->q_m);
@@ -120,14 +119,11 @@ std::shared_ptr<typename Flavor::VerificationKey> StandardHonkComposerHelper_<Fl
     verification_key->lagrange_first = commitment_key->commit(proving_key->lagrange_first);
     verification_key->lagrange_last = commitment_key->commit(proving_key->lagrange_last);
 
-    verification_key->composer_type = proving_key->composer_type;
-
     return verification_key;
 }
 
 template <StandardFlavor Flavor>
-StandardVerifier_<Flavor> StandardHonkComposerHelper_<Flavor>::create_verifier(
-    const CircuitConstructor& circuit_constructor)
+StandardVerifier_<Flavor> StandardComposer_<Flavor>::create_verifier(const CircuitBuilder& circuit_constructor)
 {
     compute_verification_key(circuit_constructor);
     StandardVerifier_<Flavor> output_state(verification_key);
@@ -141,8 +137,7 @@ StandardVerifier_<Flavor> StandardHonkComposerHelper_<Flavor>::create_verifier(
 }
 
 template <StandardFlavor Flavor>
-StandardProver_<Flavor> StandardHonkComposerHelper_<Flavor>::create_prover(
-    const CircuitConstructor& circuit_constructor)
+StandardProver_<Flavor> StandardComposer_<Flavor>::create_prover(const CircuitBuilder& circuit_constructor)
 {
     compute_proving_key(circuit_constructor);
     compute_witness(circuit_constructor);
@@ -154,6 +149,6 @@ StandardProver_<Flavor> StandardHonkComposerHelper_<Flavor>::create_prover(
     return output_state;
 }
 
-template class StandardHonkComposerHelper_<honk::flavor::Standard>;
-template class StandardHonkComposerHelper_<honk::flavor::StandardGrumpkin>;
+template class StandardComposer_<honk::flavor::Standard>;
+template class StandardComposer_<honk::flavor::StandardGrumpkin>;
 } // namespace proof_system::honk