fix tests

Author: iakovenkos

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 = 12986977;
+inline constexpr size_t ROOT_ROLLUP_GATE_COUNT = 12995065;
 
 template <typename RecursiveFlavor>
 constexpr std::tuple<size_t, size_t> HONK_RECURSION_CONSTANTS(
@@ -67,26 +67,26 @@ 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(722844, 0);
+            return std::make_tuple(726842, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(723995, 0);
+            return std::make_tuple(727993, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraZKRecursiveFlavor_<UltraCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(766262, 0);
+            return std::make_tuple(770506, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(767515, 0);
+            return std::make_tuple(771759, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraRollupRecursiveFlavor_<UltraCircuitBuilder>>) {
         switch (mode) {
         case PredicateTestCase::ConstantTrue:
-            return std::make_tuple(723163, 0);
+            return std::make_tuple(727160, 0);
         case PredicateTestCase::WitnessTrue:
         case PredicateTestCase::WitnessFalse:
-            return std::make_tuple(724462, 0);
+            return std::make_tuple(728459, 0);
         }
     } else if constexpr (std::is_same_v<RecursiveFlavor, bb::UltraRecursiveFlavor_<MegaCircuitBuilder>>) {
         switch (mode) {
@@ -108,7 +108,7 @@ constexpr std::tuple<size_t, size_t> HONK_RECURSION_CONSTANTS(
         if (mode != PredicateTestCase::ConstantTrue) {
             bb::assert_failure("Unhandled mode in MegaZKRecursiveFlavor.");
         }
-        return std::make_tuple(814519, 0);
+        return std::make_tuple(817287, 0);
     } else {
         bb::assert_failure("Unhandled recursive flavor.");
     }
@@ -119,7 +119,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 = 2368439;
+inline constexpr size_t CHONK_RECURSION_GATES = 2385506;
 
 // ========================================
 // Hypernova Recursion Constants
@@ -153,7 +153,7 @@ inline constexpr size_t HIDING_KERNEL_ULTRA_OPS = 124;
 // ========================================
 
 // Gate count for ECCVM recursive verifier (Ultra-arithmetized)
-inline constexpr size_t ECCVM_RECURSIVE_VERIFIER_GATE_COUNT = 214950;
+inline constexpr size_t ECCVM_RECURSIVE_VERIFIER_GATE_COUNT = 220455;
 
 // ========================================
 // Goblin AVM Recursive Verifier Constants

barretenberg/cpp/src/barretenberg/eccvm/eccvm_transcript.test.cpp

@@ -135,9 +135,7 @@ class ECCVMTranscriptTests : public ::testing::Test {
         manifest_expected.add_entry(round, "LOOKUP_INVERSES", frs_per_G);
         manifest_expected.add_entry(round, "Z_PERM", frs_per_G);
         manifest_expected.add_challenge(round, "Sumcheck:alpha");
-
         for (size_t i = 0; i < CONST_ECCVM_LOG_N; i++) {
-            round++;
             std::string label = "Sumcheck:gate_challenge_" + std::to_string(i);
             manifest_expected.add_challenge(round, label);
         }

barretenberg/cpp/src/barretenberg/goblin/merge.test.cpp

@@ -542,29 +542,25 @@ class MergeTranscriptTests : public ::testing::Test {
 
         size_t round = 0;
 
-        // Round 0: Prover sends shift_size and merged table commitments
+        // Round 0: Prover sends shift_size and merged table commitments, gets degree check challenges
         manifest_expected.add_entry(round, "shift_size", frs_per_uint32);
         for (size_t idx = 0; idx < NUM_WIRES; ++idx) {
             manifest_expected.add_entry(round, "MERGED_TABLE_" + std::to_string(idx), frs_per_G);
         }
-        // Verifier generates degree check challenges
         manifest_expected.add_challenge(round, "LEFT_TABLE_DEGREE_CHECK_0");
         manifest_expected.add_challenge(round, "LEFT_TABLE_DEGREE_CHECK_1");
         manifest_expected.add_challenge(round, "LEFT_TABLE_DEGREE_CHECK_2");
         manifest_expected.add_challenge(round, "LEFT_TABLE_DEGREE_CHECK_3");
 
-        // Round 1: Verifier generates Shplonk batching challenges, Prover sends degree check polynomial commitment
+        // Round 1: Batching challenges + kappa, then send batched polynomial commitment
         round++;
         for (size_t idx = 0; idx < 13; ++idx) {
             manifest_expected.add_challenge(round, "SHPLONK_MERGE_BATCHING_CHALLENGE_" + std::to_string(idx));
         }
-        manifest_expected.add_entry(round, "REVERSED_BATCHED_LEFT_TABLES", frs_per_G);
-
-        // Round 2: Verifier generates evaluation challenge kappa
-        round++;
         manifest_expected.add_challenge(round, "kappa");
+        manifest_expected.add_entry(round, "REVERSED_BATCHED_LEFT_TABLES", frs_per_G);
 
-        // Round 3: Verifier generates Shplonk opening challenge, Prover sends all evaluations and quotient
+        // Round 2: Shplonk opening challenge, then send all evaluations and quotient
         round++;
         manifest_expected.add_challenge(round, "shplonk_opening_challenge");
         for (size_t idx = 0; idx < NUM_WIRES; ++idx) {
@@ -579,7 +575,7 @@ class MergeTranscriptTests : public ::testing::Test {
         manifest_expected.add_entry(round, "REVERSED_BATCHED_LEFT_TABLES_EVAL", frs_per_Fr);
         manifest_expected.add_entry(round, "SHPLONK_BATCHED_QUOTIENT", frs_per_G);
 
-        // Round 4: KZG opening proof with masking challenge
+        // Round 3: KZG masking challenge, then send W commitment
         round++;
         manifest_expected.add_challenge(round, "KZG:masking_challenge");
         manifest_expected.add_entry(round, "KZG:W", frs_per_G);

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

@@ -50,44 +50,47 @@ class HypernovaDeciderVerifierTests : public ::testing::Test {
 
     /**
      * @brief Build the expected transcript manifest for HyperNova decider
-     * @details Manifest tracking is enabled after folding (which uses 50 rounds), so only
-     * decider rounds are tracked. Round numbers continue from folding:
-     * - Round 50: rho challenge (batching for Gemini)
-     * - Round 51: Gemini FOLD commitments -> Gemini:r challenge
-     * - Round 52: Gemini evaluations -> Shplonk:nu challenge
-     * - Round 53: Shplonk:Q commitment -> Shplonk:z challenge
-     * - Round 54: KZG:W commitment -> KZG:masking_challenge
+     * @details Manifest tracking is enabled after folding (which uses 48 rounds, 0-47), so only
+     * decider rounds are tracked. Since folding ends with a challenge (claim_batching_challenge)
+     * at round 47, and the decider starts with a challenge (rho), they are in the same round:
+     * - Round 47: rho challenge (same round as folding's claim_batching_challenge)
+     * - Round 48: Gemini FOLD commitments -> Gemini:r challenge
+     * - Round 49: Gemini evaluations -> Shplonk:nu challenge
+     * - Round 50: Shplonk:Q commitment -> Shplonk:z challenge
+     * - Round 51: KZG:W commitment -> KZG:masking_challenge
      */
     static TranscriptManifest build_expected_decider_manifest()
     {
         TranscriptManifest manifest;
         constexpr size_t frs_per_G = FrCodec::calc_num_fields<curve::BN254::AffineElement>();
         constexpr size_t NUM_GEMINI_FOLDS = NativeFlavor::VIRTUAL_LOG_N - 1; // 20
         constexpr size_t NUM_GEMINI_EVALS = NativeFlavor::VIRTUAL_LOG_N;     // 21
-        constexpr size_t FOLDING_ROUNDS = 50;                                // Rounds used by folding verifier
+        // Folding uses 48 rounds (0-47). The last round (47) ends with claim_batching_challenge.
+        // Since rho is also a challenge with no data between, it stays in round 47.
+        constexpr size_t LAST_FOLDING_ROUND = 47;
 
-        // Round 50: rho challenge
-        manifest.add_challenge(FOLDING_ROUNDS, "rho");
+        // Round 47: rho challenge (same round as folding's claim_batching_challenge)
+        manifest.add_challenge(LAST_FOLDING_ROUND, "rho");
 
-        // Round 51: Gemini FOLD commitments -> Gemini:r
+        // Round 48: Gemini FOLD commitments -> Gemini:r
         for (size_t i = 1; i <= NUM_GEMINI_FOLDS; ++i) {
-            manifest.add_entry(FOLDING_ROUNDS + 1, "Gemini:FOLD_" + std::to_string(i), frs_per_G);
+            manifest.add_entry(LAST_FOLDING_ROUND + 1, "Gemini:FOLD_" + std::to_string(i), frs_per_G);
         }
-        manifest.add_challenge(FOLDING_ROUNDS + 1, "Gemini:r");
+        manifest.add_challenge(LAST_FOLDING_ROUND + 1, "Gemini:r");
 
-        // Round 52: Gemini evaluations -> Shplonk:nu
+        // Round 49: Gemini evaluations -> Shplonk:nu
         for (size_t i = 1; i <= NUM_GEMINI_EVALS; ++i) {
-            manifest.add_entry(FOLDING_ROUNDS + 2, "Gemini:a_" + std::to_string(i), 1);
+            manifest.add_entry(LAST_FOLDING_ROUND + 2, "Gemini:a_" + std::to_string(i), 1);
         }
-        manifest.add_challenge(FOLDING_ROUNDS + 2, "Shplonk:nu");
+        manifest.add_challenge(LAST_FOLDING_ROUND + 2, "Shplonk:nu");
 
-        // Round 53: Shplonk:Q -> Shplonk:z
-        manifest.add_entry(FOLDING_ROUNDS + 3, "Shplonk:Q", frs_per_G);
-        manifest.add_challenge(FOLDING_ROUNDS + 3, "Shplonk:z");
+        // Round 50: Shplonk:Q -> Shplonk:z
+        manifest.add_entry(LAST_FOLDING_ROUND + 3, "Shplonk:Q", frs_per_G);
+        manifest.add_challenge(LAST_FOLDING_ROUND + 3, "Shplonk:z");
 
-        // Round 54: KZG:W -> KZG:masking_challenge
-        manifest.add_entry(FOLDING_ROUNDS + 4, "KZG:W", frs_per_G);
-        manifest.add_challenge(FOLDING_ROUNDS + 4, "KZG:masking_challenge");
+        // Round 51: KZG:W -> KZG:masking_challenge
+        manifest.add_entry(LAST_FOLDING_ROUND + 4, "KZG:W", frs_per_G);
+        manifest.add_challenge(LAST_FOLDING_ROUND + 4, "KZG:masking_challenge");
 
         return manifest;
     }

barretenberg/cpp/src/barretenberg/hypernova/hypernova_verifier.test.cpp

@@ -168,77 +168,82 @@ class HypernovaFoldingVerifierTests : public ::testing::Test {
         constexpr size_t frs_per_G = FrCodec::calc_num_fields<curve::BN254::AffineElement>();
         constexpr size_t NUM_SUMCHECK_UNIVARIATES = NativeFlavor::VIRTUAL_LOG_N; // 21
 
-        // Round 0: Oink preamble + wires + ECC ops + databus
-        manifest.add_entry(0, "vk_hash", 1);
+        size_t round = 0;
+
+        // Round 0: Oink preamble + wires + ECC ops + databus -> eta challenges
+        manifest.add_challenge(round, std::array{ "eta", "eta_two", "eta_three" });
+        manifest.add_entry(round, "vk_hash", 1);
         for (size_t i = 0; i < 4; ++i) {
-            manifest.add_entry(0, "public_input_" + std::to_string(i), 1);
+            manifest.add_entry(round, "public_input_" + std::to_string(i), 1);
         }
         for (const auto& wire : { "W_L", "W_R", "W_O" }) {
-            manifest.add_entry(0, wire, frs_per_G);
+            manifest.add_entry(round, wire, frs_per_G);
         }
         for (const auto& wire : { "ECC_OP_WIRE_1", "ECC_OP_WIRE_2", "ECC_OP_WIRE_3", "ECC_OP_WIRE_4" }) {
-            manifest.add_entry(0, wire, frs_per_G);
+            manifest.add_entry(round, wire, frs_per_G);
         }
         for (const auto& bus : { "CALLDATA", "SECONDARY_CALLDATA", "RETURN_DATA" }) {
-            manifest.add_entry(0, bus, frs_per_G);
-            manifest.add_entry(0, std::string(bus) + "_READ_COUNTS", frs_per_G);
-            manifest.add_entry(0, std::string(bus) + "_READ_TAGS", frs_per_G);
+            manifest.add_entry(round, bus, frs_per_G);
+            manifest.add_entry(round, std::string(bus) + "_READ_COUNTS", frs_per_G);
+            manifest.add_entry(round, std::string(bus) + "_READ_TAGS", frs_per_G);
         }
-        manifest.add_challenge(0, std::array{ "eta", "eta_two", "eta_three" });
-
-        // Round 1: lookup + w_4
-        manifest.add_entry(1, "LOOKUP_READ_COUNTS", frs_per_G);
-        manifest.add_entry(1, "LOOKUP_READ_TAGS", frs_per_G);
-        manifest.add_entry(1, "W_4", frs_per_G);
-        manifest.add_challenge(1, std::array{ "beta", "gamma" });
-
-        // Round 2: inverses + z_perm
-        manifest.add_entry(2, "LOOKUP_INVERSES", frs_per_G);
-        manifest.add_entry(2, "CALLDATA_INVERSES", frs_per_G);
-        manifest.add_entry(2, "SECONDARY_CALLDATA_INVERSES", frs_per_G);
-        manifest.add_entry(2, "RETURN_DATA_INVERSES", frs_per_G);
-        manifest.add_entry(2, "Z_PERM", frs_per_G);
-        manifest.add_challenge(2, "alpha");
-
-        // Round 3: gate challenge
-        manifest.add_challenge(3, "HypernovaFoldingProver:gate_challenge");
-
-        // Rounds 4-24: main sumcheck univariates
+        round++;
+
+        // Round 1: lookup + w_4 -> beta, gamma challenges
+        manifest.add_challenge(round, std::array{ "beta", "gamma" });
+        manifest.add_entry(round, "LOOKUP_READ_COUNTS", frs_per_G);
+        manifest.add_entry(round, "LOOKUP_READ_TAGS", frs_per_G);
+        manifest.add_entry(round, "W_4", frs_per_G);
+        round++;
+
+        // Round 2: inverses + z_perm -> alpha + gate_challenge (consecutive challenges in same round)
+        manifest.add_challenge(round, "alpha");
+        manifest.add_challenge(round, "HypernovaFoldingProver:gate_challenge");
+        manifest.add_entry(round, "LOOKUP_INVERSES", frs_per_G);
+        manifest.add_entry(round, "CALLDATA_INVERSES", frs_per_G);
+        manifest.add_entry(round, "SECONDARY_CALLDATA_INVERSES", frs_per_G);
+        manifest.add_entry(round, "RETURN_DATA_INVERSES", frs_per_G);
+        manifest.add_entry(round, "Z_PERM", frs_per_G);
+        round++;
+
+        // Rounds 3-23: main sumcheck univariates (21 rounds)
         for (size_t i = 0; i < NUM_SUMCHECK_UNIVARIATES; ++i) {
-            manifest.add_entry(4 + i, "Sumcheck:univariate_" + std::to_string(i), 8);
-            manifest.add_challenge(4 + i, "Sumcheck:u_" + std::to_string(i));
+            manifest.add_challenge(round, "Sumcheck:u_" + std::to_string(i));
+            manifest.add_entry(round, "Sumcheck:univariate_" + std::to_string(i), 8);
+            round++;
         }
 
-        // Round 25: evaluations + unshifted batching challenges
-        manifest.add_entry(25, "Sumcheck:evaluations", 60);
+        // Round 24: evaluations + all batching challenges (unshifted + shifted in same round)
         for (size_t i = 0; i < 55; ++i) {
-            manifest.add_challenge(25, "unshifted_challenge_" + std::to_string(i));
+            manifest.add_challenge(round, "unshifted_challenge_" + std::to_string(i));
         }
-
-        // Round 26: shifted batching challenges
         for (size_t i = 0; i < 5; ++i) {
-            manifest.add_challenge(26, "shifted_challenge_" + std::to_string(i));
+            manifest.add_challenge(round, "shifted_challenge_" + std::to_string(i));
         }
+        manifest.add_entry(round, "Sumcheck:evaluations", 60);
+        round++;
 
-        // Round 27: MLB accumulator data
-        manifest.add_entry(27, "non_shifted_accumulator_commitment", frs_per_G);
-        manifest.add_entry(27, "shifted_accumulator_commitment", frs_per_G);
+        // Round 25: Sumcheck:alpha + MLB accumulator data (Sumcheck:alpha is consecutive challenge)
+        manifest.add_challenge(round, "Sumcheck:alpha");
+        manifest.add_entry(round, "non_shifted_accumulator_commitment", frs_per_G);
+        manifest.add_entry(round, "shifted_accumulator_commitment", frs_per_G);
         for (size_t i = 0; i < NUM_SUMCHECK_UNIVARIATES; ++i) {
-            manifest.add_entry(27, "accumulator_challenge_" + std::to_string(i), 1);
+            manifest.add_entry(round, "accumulator_challenge_" + std::to_string(i), 1);
         }
-        manifest.add_entry(27, "accumulator_evaluation_0", 1);
-        manifest.add_entry(27, "accumulator_evaluation_1", 1);
-        manifest.add_challenge(27, "Sumcheck:alpha");
+        manifest.add_entry(round, "accumulator_evaluation_0", 1);
+        manifest.add_entry(round, "accumulator_evaluation_1", 1);
+        round++;
 
-        // Rounds 28-48: MLB sumcheck univariates
+        // Rounds 26-46: MLB sumcheck univariates (21 rounds)
         for (size_t i = 0; i < NUM_SUMCHECK_UNIVARIATES; ++i) {
-            manifest.add_entry(28 + i, "Sumcheck:univariate_" + std::to_string(i), 4);
-            manifest.add_challenge(28 + i, "Sumcheck:u_" + std::to_string(i));
+            manifest.add_challenge(round, "Sumcheck:u_" + std::to_string(i));
+            manifest.add_entry(round, "Sumcheck:univariate_" + std::to_string(i), 4);
+            round++;
         }
 
-        // Round 49: final evaluations + claim_batching_challenge
-        manifest.add_entry(49, "Sumcheck:evaluations", 6);
-        manifest.add_challenge(49, "claim_batching_challenge");
+        // Round 47: final evaluations + claim_batching_challenge
+        manifest.add_challenge(round, "claim_batching_challenge");
+        manifest.add_entry(round, "Sumcheck:evaluations", 6);
 
         return manifest;
     }

barretenberg/cpp/src/barretenberg/stdlib/hash/poseidon2/poseidon2.circuit.failure.test.cpp

@@ -19,20 +19,6 @@ class Poseidon2FailureTests : public ::testing::Test {
     using SubrelationSeparator = Flavor::SubrelationSeparator;
     using RelationParameters = RelationParameters<FF>;
 
-    void modify_selector(auto& selector)
-    {
-        size_t start_idx = selector.start_index();
-        size_t end_idx = selector.end_index();
-
-        // Flip the first non-zero selector value.
-        for (size_t idx = start_idx; idx < end_idx; idx++) {
-            if (selector.at(idx) == 1) {
-                selector.at(idx) = 0;
-                break;
-            }
-        }
-    }
-
     void modify_witness(const auto& selector, auto& witness)
     {
         size_t start_idx = selector.start_index();
@@ -108,7 +94,7 @@ class Poseidon2FailureTests : public ::testing::Test {
                                        virtual_log_n);
         auto proof = sumcheck_prover.prove();
 
-        auto verifier_transcript = std::make_shared<Transcript>(prover_transcript->export_proof());
+        auto verifier_transcript = Transcript::verifier_init_empty(prover_transcript);
 
         SubrelationSeparator verifier_subrelation_separator =
             verifier_transcript->template get_challenge<FF>("Sumcheck:alpha");
@@ -140,34 +126,6 @@ TEST_F(Poseidon2FailureTests, ValidCircuitVerifies)
     prove_and_verify(prover_instance, true);
 }
 
-TEST_F(Poseidon2FailureTests, WrongSelectorValues)
-{
-    Builder builder;
-
-    // Construct a circuit that hashes a single witness field element.
-    hash_single_input(builder);
-
-    // Convert circuit to polynomials.
-    auto prover_instance = std::make_shared<ProverInstance_<Flavor>>(builder);
-    {
-        // Disable Poseidon2 External selector in the first active row.
-        // This UNDERCONSTRAINS the circuit, so verification still passes because all remaining constraints are
-        // satisfied on the valid witness data.
-        modify_selector(prover_instance->polynomials.q_poseidon2_external);
-
-        // Run sumcheck - it should PASS because we only removed a constraint
-        prove_and_verify(prover_instance, true);
-    }
-    {
-        // Disable Poseidon2 Internal selector in the first active row.
-        // Again, this underconstrains the circuit, so verification passes.
-        modify_selector(prover_instance->polynomials.q_poseidon2_internal);
-
-        // Run sumcheck - it should PASS because we only removed a constraint
-        prove_and_verify(prover_instance, true);
-    }
-}
-
 TEST_F(Poseidon2FailureTests, WrongWitnessValues)
 {
     Builder builder;