feat: merge-train/barretenberg

barretenberg/cpp/CLAUDE.md

@@ -32,11 +32,17 @@ Bootstrap modes:
   ninja <test>
   NOTE: DO NOT add the -j flag, default is optimal.
   where test is based on what you're working on:
-  - `./bin/ultra_honk_tests` - Ultra Honk circuit tests
-  - `./bin/chonk_tests` - Chonk tests
-  - `./bin/api_tests` - API/CLI tests
-  - `./bin/stdlib_*_tests` - Standard library tests
-  - `./bin/crypto_*_tests` - Cryptographic primitive tests
+  - `ultra_honk_tests` - Ultra Honk circuit tests
+  - `chonk_tests` - Chonk tests
+  - `dsl_tests` - ACIR/DSL tests (acir_format/, mock_verifier_inputs)
+  - `hypernova_tests` - HyperNova folding tests
+  - `eccvm_tests` - ECCVM circuit tests
+  - `translator_vm_tests` - Translator circuit tests
+  - `goblin_tests` - Goblin tests
+  - `stdlib_*_tests` - Standard library tests
+  - `crypto_*_tests` - Cryptographic primitive tests
+
+  To find test targets: `ninja -t targets | grep "_tests:" | grep -v cmake`
 
 ### Barretenberg module components:
 

barretenberg/cpp/scripts/test_chonk_standalone_vks_havent_changed.sh

@@ -13,7 +13,7 @@ cd ..
 # - Generate a hash for versioning: sha256sum bb-chonk-inputs.tar.gz
 # - Upload the compressed results: aws s3 cp bb-chonk-inputs.tar.gz s3://aztec-ci-artifacts/protocol/bb-chonk-inputs-[hash(0:8)].tar.gz
 # Note: In case of the "Test suite failed to run ... Unexpected token 'with' " error, need to run: docker pull aztecprotocol/build:3.0
-pinned_short_hash="e3757861"
+pinned_short_hash="474b8a97"
 pinned_chonk_inputs_url="https://aztec-ci-artifacts.s3.us-east-2.amazonaws.com/protocol/bb-chonk-inputs-${pinned_short_hash}.tar.gz"
 
 script_path="$(cd "$(dirname "${BASH_SOURCE[0]}")/scripts" && pwd)/$(basename "${BASH_SOURCE[0]}")"

barretenberg/cpp/src/barretenberg/chonk/chonk_proof.cpp

@@ -52,7 +52,7 @@ ChonkProof_<IsRecursive> ChonkProof_<IsRecursive>::from_field_elements(const std
 
     // ECCVM proof
     start_idx = end_idx;
-    end_idx += static_cast<std::ptrdiff_t>(ECCVMFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
+    end_idx += static_cast<std::ptrdiff_t>(ECCVMFlavor::PROOF_LENGTH);
     goblin_proof.eccvm_proof.insert(goblin_proof.eccvm_proof.end(), start_idx, end_idx);
 
     // IPA proof
@@ -62,7 +62,7 @@ ChonkProof_<IsRecursive> ChonkProof_<IsRecursive>::from_field_elements(const std
 
     // Translator proof
     start_idx = end_idx;
-    end_idx += static_cast<std::ptrdiff_t>(TranslatorFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
+    end_idx += static_cast<std::ptrdiff_t>(TranslatorFlavor::PROOF_LENGTH);
     goblin_proof.translator_proof.insert(goblin_proof.translator_proof.end(), start_idx, end_idx);
 
     return ChonkProof_{ std::move(mega_proof), std::move(goblin_proof) };

barretenberg/cpp/src/barretenberg/chonk/chonk_proof.hpp

@@ -9,6 +9,7 @@
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/common/streams.hpp"
 #include "barretenberg/goblin/goblin.hpp"
+#include "barretenberg/honk/proof_length.hpp"
 #include "barretenberg/serialize/msgpack_impl.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
 #include "barretenberg/stdlib_circuit_builders/mega_circuit_builder.hpp"
@@ -31,25 +32,26 @@ template <bool IsRecursive = false> struct ChonkProof_ {
     HonkProof mega_proof;     // MegaZK proof of the hiding kernel circuit
     GoblinProof goblin_proof; // Goblin proof (Merge + ECCVM + IPA + Translator)
 
+    // Hiding kernel proof length (MegaZK with fixed circuit size)
+    static constexpr size_t HIDING_KERNEL_PROOF_LENGTH_WITHOUT_PUBLIC_INPUTS =
+        ProofLength::Honk<MegaZKFlavor>::LENGTH_WITHOUT_PUB_INPUTS(MegaZKFlavor::VIRTUAL_LOG_N);
+
     /**
      * @brief The size of a Chonk proof without backend-added public inputs
      */
     static constexpr size_t PROOF_LENGTH_WITHOUT_PUB_INPUTS =
-        /*mega_proof*/ MegaZKFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS() +
+        /*mega_proof*/ HIDING_KERNEL_PROOF_LENGTH_WITHOUT_PUBLIC_INPUTS +
         /*merge_proof*/ MERGE_PROOF_SIZE +
-        /*eccvm proof*/ ECCVMFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS +
+        /*eccvm proof*/ ECCVMFlavor::PROOF_LENGTH +
         /*ipa proof*/ IPA_PROOF_LENGTH +
-        /*translator*/ TranslatorFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS;
+        /*translator*/ TranslatorFlavor::PROOF_LENGTH;
 
     /**
      * @brief The size of a Chonk proof with backend-added public inputs: HidingKernelIO
      */
     static constexpr size_t PROOF_LENGTH = PROOF_LENGTH_WITHOUT_PUB_INPUTS +
                                            /*public_inputs*/ bb::HidingKernelIO::PUBLIC_INPUTS_SIZE;
 
-    static constexpr size_t HIDING_KERNEL_PROOF_LENGTH_WITHOUT_PUBLIC_INPUTS =
-        MegaZKFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS();
-
     // Default constructor
     ChonkProof_() = default;
 

barretenberg/cpp/src/barretenberg/circuit_checker/ultra_circuit_checker.hpp

@@ -151,10 +151,10 @@ class UltraCircuitChecker {
      * @brief Struct for managing memory record data for ensuring RAM/ROM correctness
      */
     struct MemoryCheckData {
-        // randomness for constructing wire 4 mem records
+        // randomness for constructing wire 4 mem records (eta powers)
         FF eta = FF::random_element();
-        FF eta_two = FF::random_element();
-        FF eta_three = FF::random_element();
+        FF eta_two = eta * eta;       // eta²
+        FF eta_three = eta_two * eta; // eta³
 
         std::unordered_set<size_t> read_record_gates;  // row indices for gates containing RAM/ROM read mem record
         std::unordered_set<size_t> write_record_gates; // row indices for gates containing RAM/ROM write mem record

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

@@ -55,7 +55,7 @@ template <typename Builder> inline constexpr size_t ASSERT_EQUALITY = ZERO_GATE
 // Honk Recursion Constants
 // ========================================
 
-inline constexpr size_t ROOT_ROLLUP_GATE_COUNT = 12995063;
+inline constexpr size_t ROOT_ROLLUP_GATE_COUNT = 12994866;
 
 template <typename RecursiveFlavor>
 constexpr std::tuple<size_t, size_t> HONK_RECURSION_CONSTANTS(
@@ -67,48 +67,48 @@ constexpr std::tuple<size_t, size_t> HONK_RECURSION_CONSTANTS(
     if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraRecursiveFlavor_<UltraCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(726841, 0);
+            return std::make_tuple(726742, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(727992, 0);
+            return std::make_tuple(727893, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraZKRecursiveFlavor_<UltraCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(770505, 0);
+            return std::make_tuple(770407, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(771758, 0);
+            return std::make_tuple(771660, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraRollupRecursiveFlavor_<UltraCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(727159, 0);
+            return std::make_tuple(727060, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(728458, 0);
+            return std::make_tuple(728359, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraRecursiveFlavor_<MegaCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(23177, 76);
+            return std::make_tuple(23079, 76);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(24328, 76);
+            return std::make_tuple(24230, 76);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraZKRecursiveFlavor_<MegaCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(28048, 80);
+            return std::make_tuple(27951, 80);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(29301, 80);
+            return std::make_tuple(29204, 80);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::MegaZKRecursiveFlavor_<UltraCircuitBuilder>>) {
         if (mode != PredicateTestCase::ConstantTrue) {
             bb::assert_failure("Unhandled mode in MegaZKRecursiveFlavor.");
         }
-        return std::make_tuple(817286, 0);
+        return std::make_tuple(817187, 0);
     } else {
         bb::assert_failure("Unhandled recursive flavor.");
     }
@@ -121,7 +121,7 @@ constexpr std::tuple<size_t, size_t> HONK_RECURSION_CONSTANTS(
 // ========================================
 
 // Gate count for Chonk recursive verification (UltraRollup builder)
-inline constexpr size_t CHONK_RECURSION_GATES = 2385456;
+inline constexpr size_t CHONK_RECURSION_GATES = 2385358;
 
 // ========================================
 // Hypernova Recursion Constants
@@ -131,22 +131,22 @@ inline constexpr size_t CHONK_RECURSION_GATES = 2385456;
 inline constexpr size_t MSM_ROWS_OFFSET = 2;
 
 // Init kernel gate counts (verifies OINK proof)
-inline constexpr size_t INIT_KERNEL_GATE_COUNT = 25828;
+inline constexpr size_t INIT_KERNEL_GATE_COUNT = 25731;
 inline constexpr size_t INIT_KERNEL_ECC_ROWS = 848 + MSM_ROWS_OFFSET;
 inline constexpr size_t INIT_KERNEL_ULTRA_OPS = 89;
 
 // Inner kernel gate counts (verifies HN proof for previous kernel + HN for app)
-inline constexpr size_t INNER_KERNEL_GATE_COUNT_HN = 60601;
+inline constexpr size_t INNER_KERNEL_GATE_COUNT_HN = 60407;
 inline constexpr size_t INNER_KERNEL_ECC_ROWS = 1700 + MSM_ROWS_OFFSET;
 inline constexpr size_t INNER_KERNEL_ULTRA_OPS = 179;
 
 // Tail kernel gate counts (verifies HN_TAIL proof)
-inline constexpr size_t TAIL_KERNEL_GATE_COUNT = 33758;
+inline constexpr size_t TAIL_KERNEL_GATE_COUNT = 33660;
 inline constexpr size_t TAIL_KERNEL_ECC_ROWS = 914 + MSM_ROWS_OFFSET;
 inline constexpr size_t TAIL_KERNEL_ULTRA_OPS = 96;
 
 // Hiding kernel gate counts (verifies HN_FINAL proof)
-inline constexpr size_t HIDING_KERNEL_GATE_COUNT = 36897;
+inline constexpr size_t HIDING_KERNEL_GATE_COUNT = 36800;
 inline constexpr size_t HIDING_KERNEL_ECC_ROWS = 1341 + MSM_ROWS_OFFSET;
 inline constexpr size_t HIDING_KERNEL_ULTRA_OPS = 124;
 

barretenberg/cpp/src/barretenberg/dsl/acir_format/mock_verifier_inputs.cpp

@@ -80,14 +80,14 @@ HonkProof create_mock_multilinear_batch_proof()
     using FF = typename Flavor::FF;
     HonkProof proof;
 
-    // Populate mock witness accumulator commitments
-    populate_field_elements_for_mock_commitments(proof, Flavor::NUM_WITNESS_ENTITIES / 2);
+    // Populate mock accumulator commitments (non_shifted + shifted)
+    populate_field_elements_for_mock_commitments(proof, Flavor::NUM_ACCUMULATOR_COMMITMENTS);
 
     // Accumulator multivariate challenges
     populate_field_elements<FF>(proof, Flavor::VIRTUAL_LOG_N);
 
-    // Witness accumulator polynomial evaluations
-    populate_field_elements<FF>(proof, Flavor::NUM_WITNESS_ENTITIES / 2);
+    // Accumulator polynomial evaluations (non_shifted + shifted)
+    populate_field_elements<FF>(proof, Flavor::NUM_ACCUMULATOR_EVALUATIONS);
 
     // Sumcheck proof
     HonkProof sumcheck_proof = create_mock_sumcheck_proof<Flavor>();
@@ -428,7 +428,7 @@ HonkProof create_mock_eccvm_proof()
     // 27. Shplonk
     populate_field_elements_for_mock_commitments<curve::Grumpkin>(proof, /*num_commitments=*/1);
 
-    BB_ASSERT_EQ(proof.size(), ECCVMFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
+    BB_ASSERT_EQ(proof.size(), ECCVMFlavor::PROOF_LENGTH);
 
     return proof;
 }
@@ -468,7 +468,7 @@ HonkProof create_mock_translator_proof()
     HonkProof decider_proof = create_mock_decider_proof<TranslatorFlavor>();
     proof.insert(proof.end(), decider_proof.begin(), decider_proof.end());
 
-    BB_ASSERT_EQ(proof.size(), TranslatorFlavor::PROOF_LENGTH_WITHOUT_PUB_INPUTS);
+    BB_ASSERT_EQ(proof.size(), TranslatorFlavor::PROOF_LENGTH);
 
     return proof;
 }