refactor!: Use circuit builders

circuits/cpp/src/aztec3/circuits/abis/.test.cpp

@@ -9,7 +9,7 @@
 
 namespace {
 // Composer
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 
 // Types
 using CT = aztec3::utils::types::CircuitTypes<Composer>;

circuits/cpp/src/aztec3/circuits/apps/.test.cpp

@@ -25,7 +25,7 @@
 
 namespace {
 // Composer
-using C = plonk::UltraPlonkComposer;
+using C = UltraCircuitConstructor;
 
 // Types
 using CT = aztec3::utils::types::CircuitTypes<C>;

circuits/cpp/src/aztec3/circuits/apps/test_apps/basic_contract_deployment/init.hpp

@@ -14,7 +14,7 @@
 namespace aztec3::circuits::apps::test_apps::basic_contract_deployment {
 
 // Composer
-using C = plonk::UltraPlonkComposer;
+using C = UltraCircuitConstructor;
 
 // Native and circuit types
 using CT = aztec3::utils::types::CircuitTypes<C>;

circuits/cpp/src/aztec3/circuits/apps/test_apps/escrow/.test.cpp

@@ -56,9 +56,9 @@ TEST_F(escrow_tests, circuit_deposit)
     // info("witness: ", composer.witness);
     // info("constant variables: ", composer.constant_variables);
     // info("variables: ", composer.variables);
-    info("failed?: ", composer.circuit_constructor.failed());
-    info("err: ", composer.circuit_constructor.err());
-    info("n: ", composer.circuit_constructor.num_gates);
+    info("failed?: ", composer.failed());
+    info("err: ", composer.err());
+    info("n: ", composer.num_gates);
 }
 
 TEST_F(escrow_tests, circuit_transfer)
@@ -81,9 +81,9 @@ TEST_F(escrow_tests, circuit_transfer)
     // info("witness: ", composer.witness);
     // info("constant variables: ", composer.constant_variables);
     // info("variables: ", composer.variables);
-    info("failed?: ", composer.circuit_constructor.failed());
-    info("err: ", composer.circuit_constructor.err());
-    info("n: ", composer.circuit_constructor.num_gates);
+    info("failed?: ", composer.failed());
+    info("err: ", composer.err());
+    info("n: ", composer.num_gates);
 }
 
 TEST_F(escrow_tests, circuit_withdraw)
@@ -105,9 +105,9 @@ TEST_F(escrow_tests, circuit_withdraw)
     // info("witness: ", composer.witness);
     // info("constant variables: ", composer.constant_variables);
     // info("variables: ", composer.variables);
-    info("failed?: ", composer.circuit_constructor.failed());
-    info("err: ", composer.circuit_constructor.err());
-    info("n: ", composer.circuit_constructor.num_gates);
+    info("failed?: ", composer.failed());
+    info("err: ", composer.err());
+    info("n: ", composer.num_gates);
 }
 
 }  // namespace aztec3::circuits::apps::test_apps::escrow

circuits/cpp/src/aztec3/circuits/apps/test_apps/escrow/init.hpp

@@ -14,7 +14,7 @@
 namespace aztec3::circuits::apps::test_apps::escrow {
 
 // Composer
-using C = plonk::UltraPlonkComposer;
+using C = UltraCircuitConstructor;
 
 // Native and circuit types
 using CT = aztec3::utils::types::CircuitTypes<C>;

circuits/cpp/src/aztec3/circuits/apps/test_apps/private_to_private_function_call/.test.cpp

@@ -54,9 +54,9 @@ TEST(private_to_private_function_call_tests, circuit_private_to_private_function
     // info("witness: ", fn1_composer.witness);
     // info("constant variables: ", fn1_composer.constant_variables);
     // info("variables: ", fn1_composer.variables);
-    info("failed?: ", fn1_composer.circuit_constructor.failed());
-    info("err: ", fn1_composer.circuit_constructor.err());
-    info("n: ", fn1_composer.circuit_constructor.num_gates);
+    info("failed?: ", fn1_composer.failed());
+    info("err: ", fn1_composer.err());
+    info("n: ", fn1_composer.num_gates);
 }
 
 }  // namespace aztec3::circuits::apps::test_apps::private_to_private_function_call

circuits/cpp/src/aztec3/circuits/apps/test_apps/private_to_private_function_call/init.hpp

@@ -13,7 +13,7 @@
 namespace aztec3::circuits::apps::test_apps::private_to_private_function_call {
 
 // Composer
-using C = plonk::UltraPlonkComposer;
+using C = UltraCircuitConstructor;
 
 // Native and circuit types
 using CT = aztec3::utils::types::CircuitTypes<C>;

circuits/cpp/src/aztec3/circuits/kernel/private/.test.cpp

@@ -49,11 +49,11 @@ TEST_F(private_kernel_tests, basic)
         false, deposit, { amount, asset_id, memo }, encrypted_logs_hash, encrypted_log_preimages_length, true);
 
     // Execute and prove the first kernel iteration
-    Composer private_kernel_composer("../barretenberg/cpp/srs_db/ignition");
+    Composer private_kernel_composer;
     auto const& public_inputs = private_kernel_circuit(private_kernel_composer, private_inputs, true);
 
     // Check the private kernel circuit
-    EXPECT_TRUE(private_kernel_composer.circuit_constructor.check_circuit());
+    EXPECT_TRUE(private_kernel_composer.check_circuit());
 }
 
 /**
@@ -96,7 +96,7 @@ TEST_F(private_kernel_tests, circuit_cbinds)
     std::vector<uint8_t> private_constructor_call_vec;
     write(private_constructor_call_vec, private_inputs.private_call);
 
-    uint8_t const* proof_data_buf = nullptr;
+    // uint8_t const* proof_data_buf = nullptr;
     uint8_t const* public_inputs_buf = nullptr;
     size_t public_inputs_size = 0;
     // info("Simulating to generate public inputs...");

circuits/cpp/src/aztec3/circuits/kernel/private/c_bind.cpp

@@ -9,7 +9,7 @@
 #include <barretenberg/barretenberg.hpp>
 
 namespace {
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 using NT = aztec3::utils::types::NativeTypes;
 using DummyComposer = aztec3::utils::DummyComposer;
 using aztec3::circuits::abis::PreviousKernelData;

circuits/cpp/src/aztec3/circuits/kernel/private/init.hpp

@@ -9,7 +9,7 @@
 
 namespace aztec3::circuits::kernel::private_kernel {
 
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 
 using Aggregator = aztec3::circuits::recursion::Aggregator;
 

circuits/cpp/src/aztec3/circuits/kernel/private/private_kernel_circuit.cpp

@@ -27,22 +27,16 @@ using aztec3::circuits::silo_nullifier;
 
 // TODO: NEED TO RECONCILE THE `proof`'s public inputs (which are uint8's) with the
 // private_call.call_stack_item.public_inputs!
-CT::AggregationObject verify_proofs(Composer& composer,
-                                    PrivateKernelInputsInner<CT> const& private_inputs,
-                                    size_t const& num_private_call_public_inputs,
-                                    size_t const& num_private_kernel_public_inputs)
+CT::AggregationObject verify_proofs(Composer& composer, PrivateKernelInputsInner<CT> const& private_inputs)
 {
     // compute P0, P1 for private function proof
-    CT::AggregationObject aggregation_object = Aggregator::aggregate(
-        &composer, private_inputs.private_call.vk, private_inputs.private_call.proof, num_private_call_public_inputs);
+    CT::AggregationObject aggregation_object =
+        Aggregator::aggregate(&composer, private_inputs.private_call.vk, private_inputs.private_call.proof);
 
     // computes P0, P1 for previous kernel proof
     // AND accumulates all of it in P0_agg, P1_agg
-    Aggregator::aggregate(&composer,
-                          private_inputs.previous_kernel.vk,
-                          private_inputs.previous_kernel.proof,
-                          num_private_kernel_public_inputs,
-                          aggregation_object);
+    Aggregator::aggregate(
+        &composer, private_inputs.previous_kernel.vk, private_inputs.previous_kernel.proof, aggregation_object);
 
     return aggregation_object;
 }
@@ -334,10 +328,7 @@ KernelCircuitPublicInputs<NT> private_kernel_circuit(Composer& composer,
 
     update_end_values(private_inputs, public_inputs);
 
-    auto aggregation_object = verify_proofs(composer,
-                                            private_inputs,
-                                            _private_inputs.private_call.vk->num_public_inputs,
-                                            _private_inputs.previous_kernel.vk->num_public_inputs);
+    auto aggregation_object = verify_proofs(composer, private_inputs);
 
     // TODO: kernel vk membership check!
 

circuits/cpp/src/aztec3/circuits/kernel/private/utils.cpp

@@ -113,7 +113,7 @@ PreviousKernelData<NT> dummy_previous_kernel(bool real_vk_proof = false)
     PreviousKernelData<NT> const init_previous_kernel{};
 
     auto crs_factory = barretenberg::srs::get_crs_factory();
-    Composer mock_kernel_composer = Composer(crs_factory);
+    Composer mock_kernel_composer;
     auto mock_kernel_public_inputs = mock_kernel_circuit(mock_kernel_composer, init_previous_kernel.public_inputs);
 
     NT::Proof const mock_kernel_proof =

circuits/cpp/src/aztec3/circuits/kernel/public/.test.cpp

@@ -361,12 +361,12 @@ PublicKernelInputs<NT> get_kernel_inputs_with_previous_kernel(NT::boolean privat
         .bytecode_hash = 1234567,
     };
 
-    CombinedHistoricTreeRoots<NT> const historic_tree_roots = { .private_historic_tree_roots = {
-                                                                    .private_data_tree_root = 1000,
-                                                                    .contract_tree_root = 2000,
-                                                                    .l1_to_l2_messages_tree_root = 3000,
-                                                                    .private_kernel_vk_tree_root = 4000,
-                                                                } };
+    // CombinedHistoricTreeRoots<NT> const historic_tree_roots = { .private_historic_tree_roots = {
+    //                                                                 .private_data_tree_root = 1000,
+    //                                                                 .contract_tree_root = 2000,
+    //                                                                 .l1_to_l2_messages_tree_root = 3000,
+    //                                                                 .private_kernel_vk_tree_root = 4000,
+    //                                                             } };
 
     CombinedConstantData<NT> const end_constants = {
         .historic_tree_roots =

circuits/cpp/src/aztec3/circuits/kernel/public/c_bind.cpp

@@ -12,7 +12,7 @@
 #include <barretenberg/barretenberg.hpp>
 
 namespace {
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 using NT = aztec3::utils::types::NativeTypes;
 using DummyComposer = aztec3::utils::DummyComposer;
 using aztec3::circuits::abis::KernelCircuitPublicInputs;

circuits/cpp/src/aztec3/circuits/kernel/public/init.hpp

@@ -10,7 +10,7 @@
 
 namespace aztec3::circuits::kernel::public_kernel {
 
-using Composer = plonk::UltraPlonkComposer;
+using Composer = proof_system::UltraCircuitConstructor;
 
 using Aggregator = aztec3::circuits::recursion::Aggregator;
 

circuits/cpp/src/aztec3/circuits/mock/mock_kernel_circuit.hpp

@@ -43,7 +43,7 @@ KernelCircuitPublicInputs<NT> mock_kernel_circuit(Composer& composer,
     // We still add dummy witness indices in the recursive proof indices just so that we don't trigger an assertion in
     // while setting recursion elements as public inputs. These dummy indices would not be used as we're setting
     // contains_recursive_proof to be false.
-    composer.circuit_constructor.contains_recursive_proof = false;
+    composer.contains_recursive_proof = false;
 
     plonk::stdlib::pedersen_commitment<Composer>::compress(fr(witness_t(&composer, 1)), fr(witness_t(&composer, 1)));
     return public_inputs.template to_native_type<Composer>();

circuits/cpp/src/aztec3/circuits/recursion/aggregator.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include "init.hpp"
 
+#include "barretenberg/plonk/flavor/flavor.hpp"
+
 namespace aztec3::circuits::recursion {
 
 class Aggregator {
@@ -9,13 +11,10 @@ class Aggregator {
         Composer* composer,
         const std::shared_ptr<CT::VK>& vk,
         const NT::Proof& proof,
-        const size_t& num_public_inputs,
         const CT::AggregationObject& previous_aggregation_output = CT::AggregationObject())
     {
-        const Manifest recursive_manifest = Composer::create_manifest(num_public_inputs);
-
-        CT::AggregationObject result = verify_proof<CT::bn254, CT::recursive_inner_verifier_settings>(
-            composer, vk, recursive_manifest, proof, previous_aggregation_output);
+        CT::AggregationObject result =
+            verify_proof<plonk::flavor::Ultra>(composer, vk, proof, previous_aggregation_output);
 
         return result;
     }

circuits/cpp/src/aztec3/circuits/recursion/init.hpp

@@ -7,7 +7,7 @@
 
 namespace aztec3::circuits::recursion {
 // Composer
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 
 // Generic types:
 using CT = aztec3::utils::types::CircuitTypes<Composer>;

circuits/cpp/src/aztec3/circuits/rollup/base/c_bind.cpp

@@ -11,7 +11,7 @@
 #include <barretenberg/barretenberg.hpp>
 
 namespace {
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 using NT = aztec3::utils::types::NativeTypes;
 using DummyComposer = aztec3::utils::DummyComposer;
 using aztec3::circuits::abis::BaseOrMergeRollupPublicInputs;

circuits/cpp/src/aztec3/circuits/rollup/root/c_bind.cpp

@@ -9,7 +9,7 @@
 #include <barretenberg/barretenberg.hpp>
 
 namespace {
-using Composer = plonk::UltraPlonkComposer;
+using Composer = UltraCircuitConstructor;
 using NT = aztec3::utils::types::NativeTypes;
 using DummyComposer = aztec3::utils::DummyComposer;
 using aztec3::circuits::rollup::native_root_rollup::root_rollup_circuit;

circuits/cpp/src/aztec3/utils/types/circuit_types.hpp

@@ -42,10 +42,7 @@ template <typename Composer> struct CircuitTypes {
     using ecdsa_signature = stdlib::ecdsa::signature<Composer>;
 
     using AggregationObject = stdlib::recursion::aggregation_state<bn254>;
-    using recursive_inner_verifier_settings =
-        std::conditional_t<std::same_as<Composer, plonk::TurboPlonkComposer>,
-                           stdlib::recursion::recursive_turbo_verifier_settings<bn254>,
-                           stdlib::recursion::recursive_ultra_verifier_settings<bn254>>;
+    using recursive_inner_verifier_settings = stdlib::recursion::recursive_ultra_verifier_settings<bn254>;
     using VK = stdlib::recursion::verification_key<bn254>;
     // Notice: no CircuitType for a Proof: we only ever handle native; the verify_proof() function swallows the
     // 'circuit-type-ness' of the proof.