refactor!: Use circuit builders

cpp/src/barretenberg/grumpkin_srs_gen/grumpkin_srs_gen.cpp

@@ -7,6 +7,7 @@
 #include "barretenberg/common/net.hpp"
 
 const std::string protocol_name = "BARRETENBERG_GRUMPKIN_IPA_CRS";
+// WORKTODO: this is incorrect now right?
 /* Generates a monomial basis Grumpkin SRS for testing purposes.
    We only provide functionality create a single transcript file.
    The SRS has the form [1]_1, [x]_1, [x^2]_1, ... where x = 2. */

cpp/src/barretenberg/proof_system/circuit_constructors/ultra_circuit_constructor.hpp

@@ -1184,7 +1184,7 @@ class UltraCircuitConstructor : public CircuitConstructorBase<arithmetization::U
                                      fr alpha_base,
                                      fr alpha) const;
 
-    void update_circuit_in_the_head();
+    void update_circuit_in_the_head(); // WORKTODO: declared but not defined
     bool check_circuit();
 };
 } // namespace proof_system

cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_tables.hpp

@@ -416,6 +416,10 @@ element<C, Fq, Fr, G> element<C, Fq, Fr, G>::lookup_table_plookup<length, X>::ge
         accumulators.emplace_back(field_t<C>(bits[i]) * (1ULL << i));
     }
     field_t<C> index = field_t<C>::accumulate(accumulators);
+    if (bits._M_elems[0].context->circuit_constructor.num_gates == 25122) {
+        bits._M_elems[0].context->circuit_constructor.check_circuit();
+        info("Executed check of partial circuit.");
+    }
     return read_group_element_rom_tables<table_size>(coordinates, index, limb_max);
 }
 

cpp/src/barretenberg/stdlib/recursion/aggregation_state/aggregation_state.hpp

@@ -33,7 +33,7 @@ template <typename Curve> struct aggregation_state {
      * independently track `proof_witness_indices` and whether object has been assigned to public inputs)
      *
      */
-    void add_proof_outputs_as_public_inputs()
+    void add_proof_outputs_as_public_inputs() // WORKTODO: This is not used anywhere.
     {
         auto* context = P0.get_context();
         context->add_recursive_proof(proof_witness_indices);
@@ -70,6 +70,8 @@ template <typename Curve> struct aggregation_state {
 
         auto* context = P0.get_context();
 
+        context->check_circuit();
+        info("checked circuit before add_recursive_proof");
         context->add_recursive_proof(proof_witness_indices);
     }
 };

cpp/src/barretenberg/stdlib/recursion/verifier/verifier.test.cpp

@@ -53,6 +53,8 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
                                           fr_ct(witness_ct(&composer, 0)));
 
         big_a* big_b;
+
+        info("Inner circuit size: ", composer.num_gates);
     };
 
     /**
@@ -136,7 +138,8 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             verification_key_pt::from_witness(&outer_composer, verification_key_native);
 
         info("Constructing the ultra (inner) proof ...");
-        plonk::proof recursive_proof = prover.construct_proof();
+        plonk::proof recursive_proof =
+            prover.construct_proof(); // WORKTODO: this is the proof that the outer circuit verifies
 
         {
             // Native check is mainly for comparison vs circuit version of the verifier.
@@ -150,7 +153,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
             }
 
             info("Verifying the ultra (inner) proof natively...");
-            auto native_result = native_verifier.verify_proof(recursive_proof);
+            auto native_result = native_verifier.verify_proof(recursive_proof); // WORKTODO
 
             info("Native result: ", native_result);
         }
@@ -289,6 +292,9 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         auto circuit_output = create_outer_circuit(inner_composer, outer_composer);
 
+        outer_composer.circuit_constructor.check_circuit();
+        info("Checked circuit after creating outer circuit");
+
         g1::affine_element P[2];
         P[0].x = barretenberg::fq(circuit_output.aggregation_state.P0.x.get_value().lo);
         P[0].y = barretenberg::fq(circuit_output.aggregation_state.P0.y.get_value().lo);
@@ -307,21 +313,23 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
 
         EXPECT_EQ(outer_composer.failed(), false);
 
-        info("creating prover for outer circuit");
-        info("composer gates = ", outer_composer.get_num_gates());
-        auto prover = outer_composer.create_prover();
-        info("created prover for outer circuit");
+        info("Executing check of full circuit:");
+        bool result = outer_composer.circuit_constructor.check_circuit();
+        // info("creating prover for outer circuit");
+        // info("composer gates = ", outer_composer.get_num_gates());
+        // auto prover = outer_composer.create_prover();
+        // info("created prover for outer circuit");
 
-        info("creating verifier for outer proof");
-        auto verifier = outer_composer.create_verifier();
+        // info("creating verifier for outer proof");
+        // auto verifier = outer_composer.create_verifier();
 
-        info("creating outer proof for outer circuit");
-        plonk::proof proof = prover.construct_proof();
-        info("created outer proof");
+        // info("creating outer proof for outer circuit");
+        // plonk::proof proof = prover.construct_proof();
+        // info("created outer proof");
 
-        info("verifying the outer proof");
-        bool result = verifier.verify_proof(proof);
-        info("Outer proof verification result: ", result);
+        // info("verifying the outer proof");
+        // bool result = verifier.verify_proof(proof); // WORKTODO
+        // info("Outer proof verification result: ", result);
 
         EXPECT_EQ(result, true);
     }
@@ -365,7 +373,7 @@ template <typename OuterComposer> class stdlib_verifier : public testing::Test {
         info("created outer proof");
 
         info("verifying the outer proof");
-        bool result = verifier.verify_proof(proof);
+        bool result = verifier.verify_proof(proof); // WORKTODO
         info("Outer proof verification result: ", result);
 
         EXPECT_EQ(result, true);