chonk_transcript_invariants.test.cpp

Go to the documentation of this file.

 
#include "barretenberg/chonk/chonk.hpp"
#include "barretenberg/chonk/chonk_verifier.hpp"
#include "barretenberg/chonk/mock_circuit_producer.hpp"
#include "barretenberg/common/test.hpp"
#include "barretenberg/goblin/merge_prover.hpp"
#include "barretenberg/goblin/merge_verifier.hpp"
#include "barretenberg/goblin/mock_circuits.hpp"
#include "barretenberg/hypernova/hypernova_decider_prover.hpp"
#include "barretenberg/hypernova/hypernova_decider_verifier.hpp"
#include "barretenberg/hypernova/hypernova_prover.hpp"
#include "barretenberg/hypernova/hypernova_verifier.hpp"
#include "barretenberg/multilinear_batching/multilinear_batching_prover.hpp"
#include "barretenberg/multilinear_batching/multilinear_batching_verifier.hpp"
#include "barretenberg/stdlib_circuit_builders/mega_circuit_builder.hpp"
#include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp"
#include "barretenberg/transcript/transcript_manifest.hpp"
#include "barretenberg/ultra_honk/prover_instance.hpp"
#include <gtest/gtest.h>
 
using namespace bb;
 
class ChonkTranscriptInvariantTests : public ::testing::Test {
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
};
 
TEST_F(ChonkTranscriptInvariantTests, AccumulationTranscriptCount)
{
    // Pinned expected transcript count for 2 app circuits
    constexpr size_t EXPECTED_TOTAL_TRANSCRIPTS = 12;
    constexpr size_t EXPECTED_NUM_CIRCUITS = 7;
    constexpr std::array<size_t, EXPECTED_NUM_CIRCUITS> EXPECTED_CIRCUIT_TRANSCRIPTS = { 0, 2, 0, 3, 2, 2, 3 };
 
    // Record transcript index before IVC
    size_t index_before_ivc = bb::unique_transcript_index.load();
 
    // Track indices at each circuit accumulation
    std::vector<size_t> indices_before_accumulation;
    std::vector<size_t> indices_after_accumulation;
 
    // Create IVC with 2 app circuits
    constexpr size_t NUM_APP_CIRCUITS = 2;
    PrivateFunctionExecutionMockCircuitProducer circuit_producer(NUM_APP_CIRCUITS);
    const size_t num_circuits = circuit_producer.total_num_circuits;
    ASSERT_EQ(num_circuits, EXPECTED_NUM_CIRCUITS) << "Circuit count mismatch - test assumptions invalid";
 
    Chonk ivc{ num_circuits };
 
    for (size_t j = 0; j < num_circuits; ++j) {
        indices_before_accumulation.push_back(bb::unique_transcript_index.load());
        circuit_producer.construct_and_accumulate_next_circuit(ivc);
        indices_after_accumulation.push_back(bb::unique_transcript_index.load());
    }
 
    size_t index_after_ivc = bb::unique_transcript_index.load();
    size_t total_transcripts = index_after_ivc - index_before_ivc;
 
    // Pin the total number of transcripts created during accumulation
    EXPECT_EQ(total_transcripts, EXPECTED_TOTAL_TRANSCRIPTS)
        << "Total transcript count during 2-app IVC accumulation changed. "
        << "If intentional, update EXPECTED_TOTAL_TRANSCRIPTS. "
        << "Unexpected changes may indicate security-relevant transcript isolation issues.";
 
    // Pin per-circuit transcript counts
    for (size_t i = 0; i < num_circuits; ++i) {
        size_t circuit_transcripts = indices_after_accumulation[i] - indices_before_accumulation[i];
        EXPECT_EQ(circuit_transcripts, EXPECTED_CIRCUIT_TRANSCRIPTS[i])
            << "Circuit " << i << " transcript count changed from " << EXPECTED_CIRCUIT_TRANSCRIPTS[i] << " to "
            << circuit_transcripts;
    }
 
    // Generate and verify proof
    auto proof = ivc.prove();
    auto vk_and_hash = ivc.get_hiding_kernel_vk_and_hash();
    ChonkNativeVerifier verifier(vk_and_hash);
    EXPECT_TRUE(verifier.verify(proof)) << "IVC proof should verify";
}
 
TEST_F(ChonkTranscriptInvariantTests, RecursiveVerificationTranscriptCount)
{
    using RecursiveVerifier = ChonkRecursiveVerifier;
 
    // Create a minimal IVC and generate proof
    constexpr size_t NUM_APP_CIRCUITS = 1;
    PrivateFunctionExecutionMockCircuitProducer circuit_producer(NUM_APP_CIRCUITS);
    const size_t num_circuits = circuit_producer.total_num_circuits;
    Chonk ivc{ num_circuits };
 
    for (size_t j = 0; j < num_circuits; ++j) {
        circuit_producer.construct_and_accumulate_next_circuit(ivc);
    }
 
    auto proof = ivc.prove();
    auto vk_and_hash = ivc.get_hiding_kernel_vk_and_hash();
 
    // Perform recursive verification and track transcript creation
    // unique_transcript_index is only incremented for in-circuit transcripts (in_circuit == true)
    UltraCircuitBuilder builder;
    size_t index_before_verify = bb::unique_transcript_index.load();
 
    // Create stdlib VK and hash from native VK
    auto stdlib_vk_and_hash = std::make_shared<RecursiveVerifier::VKAndHash>(builder, vk_and_hash->vk);
 
    RecursiveVerifier verifier(stdlib_vk_and_hash);
    ChonkStdlibProof stdlib_proof(builder, proof);
    [[maybe_unused]] auto output = verifier.verify(stdlib_proof);
 
    size_t index_after_verify = bb::unique_transcript_index.load();
    size_t transcripts_created = index_after_verify - index_before_verify;
 
    // Pin the exact number of transcripts created during recursive verification
    constexpr size_t EXPECTED_TRANSCRIPTS_DURING_RECURSIVE_VERIFY = 2;
    EXPECT_EQ(transcripts_created, EXPECTED_TRANSCRIPTS_DURING_RECURSIVE_VERIFY)
        << "ChonkRecursiveVerifier transcript count changed. "
        << "If intentional, update EXPECTED_TRANSCRIPTS_DURING_RECURSIVE_VERIFY. "
        << "Unexpected changes may indicate security-relevant transcript isolation issues.";
}