feat: merge-train/barretenberg

barretenberg/cpp/format.sh

@@ -10,7 +10,7 @@ if [ "$1" == "staged" ]; then
   files=$(git diff-index --diff-filter=d --relative --cached --name-only HEAD | grep -e '\.\(cpp\|hpp\|tcc\)$')
   format_files "$files"
   if [ -n "$files" ]; then
-    git add "$files"
+    echo "$files" | xargs -r git add
   fi
 elif [ "$1" == "changed" ]; then
   echo Formatting barretenberg changed files...

barretenberg/cpp/scripts/test_chonk_standalone_vks_havent_changed.sh

@@ -57,7 +57,18 @@ fi
 export inputs_tmp_dir=$(mktemp -d)
 trap 'rm -rf "$inputs_tmp_dir" bb-chonk-inputs.tar.gz' EXIT SIGINT
 
-curl -s -f "$pinned_chonk_inputs_url" | tar -xzf - -C "$inputs_tmp_dir" &>/dev/null
+echo "Downloading pinned IVC inputs from: $pinned_chonk_inputs_url"
+if ! curl -s -f "$pinned_chonk_inputs_url" -o bb-chonk-inputs.tar.gz; then
+    echo_stderr "Error: Failed to download pinned IVC inputs from $pinned_chonk_inputs_url"
+    echo_stderr "The pinned short hash '$pinned_short_hash' may be invalid or the file may not exist in S3."
+    exit 1
+fi
+
+echo "Extracting IVC inputs..."
+if ! tar -xzf bb-chonk-inputs.tar.gz -C "$inputs_tmp_dir"; then
+    echo_stderr "Error: Failed to extract IVC inputs archive"
+    exit 1
+fi
 
 function check_circuit_vks {
   set -eu

barretenberg/cpp/src/barretenberg/bbapi/bbapi_ecc.cpp

@@ -11,11 +11,7 @@ GrumpkinMul::Response GrumpkinMul::execute(BBApiRequest& request) &&
     if (!point.on_curve()) {
         BBAPI_ERROR(request, "Input point must be on the curve");
     }
-    auto result = point * scalar;
-    if (!result.on_curve()) {
-        BBAPI_ERROR(request, "Output point must be on the curve");
-    }
-    return { result };
+    return { point * scalar };
 }
 
 GrumpkinAdd::Response GrumpkinAdd::execute(BBApiRequest& request) &&
@@ -26,11 +22,7 @@ GrumpkinAdd::Response GrumpkinAdd::execute(BBApiRequest& request) &&
     if (!point_b.on_curve()) {
         BBAPI_ERROR(request, "Input point_b must be on the curve");
     }
-    auto result = point_a + point_b;
-    if (!result.on_curve()) {
-        BBAPI_ERROR(request, "Output point must be on the curve");
-    }
-    return { result };
+    return { point_a + point_b };
 }
 
 GrumpkinBatchMul::Response GrumpkinBatchMul::execute(BBApiRequest& request) &&
@@ -41,11 +33,6 @@ GrumpkinBatchMul::Response GrumpkinBatchMul::execute(BBApiRequest& request) &&
         }
     }
     auto output = grumpkin::g1::element::batch_mul_with_endomorphism(points, scalar);
-    for (const auto& p : output) {
-        if (!p.on_curve()) {
-            BBAPI_ERROR(request, "Output point must be on the curve");
-        }
-    }
     return { std::move(output) };
 }
 
@@ -67,11 +54,7 @@ Secp256k1Mul::Response Secp256k1Mul::execute(BBApiRequest& request) &&
     if (!point.on_curve()) {
         BBAPI_ERROR(request, "Input point must be on the curve");
     }
-    auto result = point * scalar;
-    if (!result.on_curve()) {
-        BBAPI_ERROR(request, "Output point must be on the curve");
-    }
-    return { result };
+    return { point * scalar };
 }
 
 Secp256k1GetRandomFr::Response Secp256k1GetRandomFr::execute(BB_UNUSED BBApiRequest& request) &&

barretenberg/cpp/src/barretenberg/benchmark/ultra_bench/mock_circuits.hpp

@@ -26,7 +26,9 @@ template <typename Builder> void generate_basic_arithmetic_circuit(Builder& buil
     // Ensure the circuit is filled but finalisation doesn't make the circuit size go to the next power of two
     size_t target_gate_count = (1UL << log2_num_gates);
     const size_t GATE_COUNT_BUFFER = 1000; // Since we're using an estimate, let's add an error term in case.
-    size_t passes = (target_gate_count - builder.get_estimated_num_finalized_gates() - GATE_COUNT_BUFFER) / 4;
+    size_t passes = (target_gate_count - builder.get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false) -
+                     GATE_COUNT_BUFFER) /
+                    4;
     if (static_cast<int>(passes) <= 0) {
         throw_or_abort("We don't support low values of log2_num_gates.");
     }
@@ -38,7 +40,7 @@ template <typename Builder> void generate_basic_arithmetic_circuit(Builder& buil
         b = c * c;
     }
 
-    size_t est_gate_count = builder.get_estimated_num_finalized_gates();
+    size_t est_gate_count = builder.get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false);
     BB_ASSERT_LTE(est_gate_count,
                   (1UL << log2_num_gates) - GATE_COUNT_BUFFER,
                   "Check that the finalized gate count won't exceed the desired gate count.");

barretenberg/cpp/src/barretenberg/boomerang_value_detection/graph_description_goblin.test.cpp

@@ -85,7 +85,11 @@ TEST_F(BoomerangGoblinRecursiveVerifierTests, graph_description_basic)
 
     GoblinRecursiveVerifier verifier{ &builder, verifier_input };
     GoblinRecursiveVerifierOutput output = verifier.verify(proof, recursive_merge_commitments, MergeSettings::APPEND);
-    output.points_accumulator.set_public();
+
+    stdlib::recursion::honk::DefaultIO<Builder> inputs;
+    inputs.pairing_inputs = output.points_accumulator;
+    inputs.set_public();
+
     // Construct and verify a proof for the Goblin Recursive Verifier circuit
     {
         auto prover_instance = std::make_shared<OuterProverInstance>(builder);

barretenberg/cpp/src/barretenberg/boomerang_value_detection/graph_description_ultra_recursive_verifier.test.cpp

@@ -128,7 +128,7 @@ template <typename RecursiveFlavor> class BoomerangRecursiveVerifierTest : publi
             output.ipa_claim.set_public();
             outer_circuit.ipa_proof = output.ipa_proof.get_value();
         }
-        info("Recursive Verifier: num gates = ", outer_circuit.get_estimated_num_finalized_gates());
+        info("Recursive Verifier: num gates = ", outer_circuit.get_num_finalized_gates_inefficient());
 
         // Check for a failure flag in the recursive verifier circuit
         EXPECT_EQ(outer_circuit.failed(), false) << outer_circuit.err();

barretenberg/cpp/src/barretenberg/circuit_checker/ultra_circuit_builder.test.cpp

@@ -39,7 +39,7 @@ TEST(UltraCircuitBuilder, CopyConstructor)
 
     UltraCircuitBuilder duplicate_builder{ builder };
 
-    EXPECT_EQ(duplicate_builder.get_estimated_num_finalized_gates(), builder.get_estimated_num_finalized_gates());
+    EXPECT_EQ(duplicate_builder.get_num_finalized_gates_inefficient(), builder.get_num_finalized_gates_inefficient());
     EXPECT_TRUE(CircuitChecker::check(duplicate_builder));
 }
 
@@ -935,7 +935,7 @@ TEST(UltraCircuitBuilder, Ram)
     // Test the builder copy constructor for a circuit with RAM gates
     UltraCircuitBuilder duplicate_builder{ builder };
 
-    EXPECT_EQ(duplicate_builder.get_estimated_num_finalized_gates(), builder.get_estimated_num_finalized_gates());
+    EXPECT_EQ(duplicate_builder.get_num_finalized_gates_inefficient(), builder.get_num_finalized_gates_inefficient());
     EXPECT_TRUE(CircuitChecker::check(duplicate_builder));
 }
 

barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp

@@ -10,6 +10,7 @@
 #include "barretenberg/stdlib/primitives/curves/bn254.hpp"
 #include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
 #include "barretenberg/stdlib/primitives/padding_indicator_array/padding_indicator_array.hpp"
+#include "barretenberg/stdlib/primitives/pairing_points.hpp"
 #include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
 #include <gtest/gtest.h>
@@ -136,11 +137,12 @@ TEST(ShpleminiRecursionTest, ProveAndVerifySingle)
                                                                                   u_challenge_in_circuit,
                                                                                   Commitment::one(&builder),
                                                                                   stdlib_verifier_transcript);
-        auto pairing_points = KZG<Curve>::reduce_verify_batch_opening_claim(opening_claim, stdlib_verifier_transcript);
+        stdlib::recursion::PairingPoints<Builder> pairing_points(
+            KZG<Curve>::reduce_verify_batch_opening_claim(opening_claim, stdlib_verifier_transcript));
         EXPECT_TRUE(CircuitChecker::check(builder));
 
         VerifierCommitmentKey<NativeCurve> vk;
-        EXPECT_EQ(vk.pairing_check(pairing_points[0].get_value(), pairing_points[1].get_value()), true);
+        EXPECT_EQ(vk.pairing_check(pairing_points.P0.get_value(), pairing_points.P1.get_value()), true);
 
         // Return finalized number of gates;
         return builder.num_gates();

barretenberg/cpp/src/barretenberg/common/log.hpp

@@ -11,10 +11,11 @@
 #define BENCHMARK_INFO_SEPARATOR "#"
 #define BENCHMARK_INFO_SUFFIX "##BENCHMARK_INFO_SUFFIX##"
 
-#define BENCH_GATE_COUNT_START(builder, op_name) uint64_t __bench_before = builder.get_estimated_num_finalized_gates();
+#define BENCH_GATE_COUNT_START(builder, op_name)                                                                       \
+    uint64_t __bench_before = builder.get_num_finalized_gates_inefficient();
 
 #define BENCH_GATE_COUNT_END(builder, op_name)                                                                         \
-    uint64_t __bench_after = builder.get_estimated_num_finalized_gates();                                              \
+    uint64_t __bench_after = builder.get_num_finalized_gates_inefficient();                                            \
     std::cerr << "num gates with " << op_name << " = " << __bench_after - __bench_before << std::endl;                 \
     benchmark_info(Builder::NAME_STRING, "Bigfield", op_name, "Gate Count", __bench_after - __bench_before);
 

barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp

@@ -224,7 +224,7 @@ template <typename Builder> class GateCounter {
         if (!collect_gates_per_opcode) {
             return 0;
         }
-        size_t new_gate_count = builder->get_estimated_num_finalized_gates();
+        size_t new_gate_count = builder->get_num_finalized_gates_inefficient(/*ensure_nonzero=*/false);
         size_t diff = new_gate_count - prev_gate_count;
         prev_gate_count = new_gate_count;
         return diff;

barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_integration.test.cpp

@@ -51,7 +51,7 @@ class AcirIntegrationTest : public ::testing::Test {
         Prover prover{ prover_instance, verification_key };
 #ifdef LOG_SIZES
         builder.blocks.summarize();
-        info("num gates          = ", builder.get_estimated_num_finalized_gates());
+        info("num gates          = ", builder.get_num_finalized_gates_inefficient());
         info("total circuit size = ", builder.get_estimated_total_circuit_size());
         info("circuit size       = ", prover.prover_instance->dyadic_size());
         info("log circuit size   = ", prover.prover_instance->log_dyadic_size());

barretenberg/cpp/src/barretenberg/dsl/acir_format/chonk_recursion_constraints.test.cpp

@@ -88,8 +88,6 @@ class ChonkRecursionConstraintTest : public ::testing::Test {
         // Build constraints
         Builder builder = create_circuit(program, { .has_ipa_claim = true });
 
-        info("Estimate finalized number of gates: ", builder.get_estimated_num_finalized_gates());
-
         // Construct vk
         auto prover_instance = std::make_shared<ProverInstance>(builder);
 

barretenberg/cpp/src/barretenberg/dsl/acir_format/honk_recursion_constraint.test.cpp

@@ -276,7 +276,7 @@ TYPED_TEST(AcirHonkRecursionConstraint, TestBasicSingleHonkRecursionConstraint)
                                                                                        /*dummy_witnesses=*/false,
                                                                                        /*predicate_val=*/true);
 
-    info("estimate finalized circuit gates = ", layer_2_circuit.get_estimated_num_finalized_gates());
+    info("estimate finalized circuit gates = ", layer_2_circuit.get_num_finalized_gates_inefficient());
 
     auto prover_instance = std::make_shared<typename TestFixture::OuterProverInstance>(layer_2_circuit);
     auto verification_key =
@@ -298,7 +298,7 @@ TYPED_TEST(AcirHonkRecursionConstraint, TestBasicDoubleHonkRecursionConstraints)
     auto layer_2_circuit =
         TestFixture::template create_outer_circuit<typename TestFixture::OuterBuilder>(layer_1_circuits, false, false);
 
-    info("circuit gates = ", layer_2_circuit.get_estimated_num_finalized_gates());
+    info("circuit gates = ", layer_2_circuit.get_num_finalized_gates_inefficient());
 
     auto prover_instance = std::make_shared<typename TestFixture::OuterProverInstance>(layer_2_circuit);
     auto verification_key =
@@ -364,7 +364,7 @@ TYPED_TEST(AcirHonkRecursionConstraint, TestOneOuterRecursiveCircuit)
                                                                                        /*dummy_witnesses=*/false,
                                                                                        /*predicate_val=*/true);
     info("created second outer circuit");
-    info("number of gates in layer 3 = ", layer_3_circuit.get_estimated_num_finalized_gates());
+    info("number of gates in layer 3 = ", layer_3_circuit.get_num_finalized_gates_inefficient());
 
     auto prover_instance = std::make_shared<typename TestFixture::OuterProverInstance>(layer_3_circuit);
     auto verification_key =
@@ -421,7 +421,7 @@ TYPED_TEST(AcirHonkRecursionConstraint, TestFullRecursiveComposition)
                                                                                        /*dummy_witnesses=*/false,
                                                                                        /*predicate_val=*/true);
     info("created third outer circuit");
-    info("number of gates in layer 3 circuit = ", layer_3_circuit.get_estimated_num_finalized_gates());
+    info("number of gates in layer 3 circuit = ", layer_3_circuit.get_num_finalized_gates_inefficient());
 
     auto prover_instance = std::make_shared<typename TestFixture::OuterProverInstance>(layer_3_circuit);
     auto verification_key =

barretenberg/cpp/src/barretenberg/dsl/acir_format/test_class.hpp

@@ -190,7 +190,7 @@ template <TestBase Base> class TestClass {
         {
             AcirProgram program{ constraint_system, witness_values };
             auto builder = create_circuit<Builder>(program);
-            info("Num gates: ", builder.get_estimated_num_finalized_gates());
+            info("Num gates: ", builder.get_num_finalized_gates_inefficient());
 
             auto prover_instance = std::make_shared<ProverInstance>(builder);
             vk_from_witness = std::make_shared<VerificationKey>(prover_instance->get_precomputed());

barretenberg/cpp/src/barretenberg/dsl/acir_format/test_class_predicate.hpp

@@ -230,7 +230,7 @@ template <TestBaseWithPredicate Base> class TestClassWithPredicate {
             {
                 AcirProgram program{ constraint_system, witness_values };
                 auto builder = create_circuit<Builder>(program);
-                info("Num gates: ", builder.get_estimated_num_finalized_gates());
+                info("Num gates: ", builder.get_num_finalized_gates_inefficient());
 
                 auto prover_instance = std::make_shared<ProverInstance>(builder);
                 vk_from_witness = std::make_shared<VerificationKey>(prover_instance->get_precomputed());

barretenberg/cpp/src/barretenberg/hypernova/hypernova_decider_verifier.cpp

@@ -32,11 +32,11 @@ HypernovaDeciderVerifier<Flavor>::PairingPoints HypernovaDeciderVerifier<Flavor>
     const auto opening_claim = ShpleminiVerifier::compute_batch_opening_claim(
         padding_indicator_array, claim_batcher, accumulator.challenge, generator, transcript);
 
-    auto pairing_points = PCS::reduce_verify_batch_opening_claim(opening_claim, transcript);
-
     if constexpr (IsRecursiveFlavor<Flavor>) {
+        PairingPoints pairing_points(PCS::reduce_verify_batch_opening_claim(opening_claim, transcript));
         return pairing_points;
     } else {
+        auto pairing_points = PCS::reduce_verify_batch_opening_claim(opening_claim, transcript);
         // Native pairing points contain affine elements
         return { typename Curve::AffineElement(pairing_points[0]), typename Curve::AffineElement(pairing_points[1]) };
     }