client_ivc_recursive_verifier.test.cpp

Go to the documentation of this file.

#include "barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp"
#include "barretenberg/circuit_checker/circuit_checker.hpp"
#include "barretenberg/client_ivc/client_ivc.hpp"
#include "barretenberg/client_ivc/test_bench_shared.hpp"
#include "barretenberg/common/test.hpp"
#include "barretenberg/stdlib/honk_verifier/ultra_verification_keys_comparator.hpp"
 
namespace bb::stdlib::recursion::honk {
class ClientIVCRecursionTests : public testing::Test {
  public:
    using Builder = UltraCircuitBuilder;
    using ClientIVCVerifier = ClientIVCRecursiveVerifier;
    using Proof = ClientIVC::Proof;
    using StdlibProof = ClientIVCVerifier::StdlibProof;
    using RollupFlavor = UltraRollupRecursiveFlavor_<Builder>;
    using NativeFlavor = RollupFlavor::NativeFlavor;
    using UltraRecursiveVerifier = UltraRecursiveVerifier_<RollupFlavor>;
    using MockCircuitProducer = PrivateFunctionExecutionMockCircuitProducer;
    using IVCVerificationKey = ClientIVC::VerificationKey;
    using PairingAccumulator = PairingPoints<Builder>;
 
    static constexpr TraceSettings trace_settings{ AZTEC_TRACE_STRUCTURE };
 
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
 
    struct ClientIVCProverOutput {
        Proof proof;
        IVCVerificationKey ivc_vk;
    };
 
    static ClientIVCProverOutput construct_client_ivc_prover_output(const size_t num_app_circuits = 1)
    {
        // Construct and accumulate a series of mocked private function execution circuits
        MockCircuitProducer circuit_producer{ num_app_circuits };
        const size_t NUM_CIRCUITS = circuit_producer.total_num_circuits;
        ClientIVC ivc{ NUM_CIRCUITS, trace_settings };
 
        for (size_t idx = 0; idx < NUM_CIRCUITS; ++idx) {
            circuit_producer.construct_and_accumulate_next_circuit(ivc);
        }
 
        return { ivc.prove(), ivc.get_vk() };
    }
};
 
TEST_F(ClientIVCRecursionTests, NativeVerification)
{
    auto [proof, vk] = construct_client_ivc_prover_output();
 
    // Confirm that the IVC proof can be natively verified
    EXPECT_TRUE(ClientIVC::verify(proof, vk));
}
 
TEST_F(ClientIVCRecursionTests, Basic)
{
    using CIVCRecVerifierOutput = ClientIVCRecursiveVerifier::Output;
 
    // Generate a genuine ClientIVC prover output
    auto [proof, vk] = construct_client_ivc_prover_output();
 
    // Construct the ClientIVC recursive verifier
    Builder builder;
    ClientIVCVerifier verifier{ &builder, vk.mega };
 
    // Generate the recursive verification circuit
    StdlibProof stdlib_proof(builder, proof);
    CIVCRecVerifierOutput output = verifier.verify(stdlib_proof);
 
    EXPECT_EQ(builder.failed(), false) << builder.err();
 
    EXPECT_TRUE(CircuitChecker::check(builder));
 
    // Print the number of gates post finalization
    info("Recursive Verifier: finalized num gates = ", builder.num_gates);
}
 
TEST_F(ClientIVCRecursionTests, ClientTubeBase)
{
    using CIVCRecVerifierOutput = ClientIVCRecursiveVerifier::Output;
 
    // Generate a genuine ClientIVC prover output
    auto [proof, vk] = construct_client_ivc_prover_output();
 
    // Construct the ClientIVC recursive verifier
    Builder tube_builder;
    ClientIVCVerifier verifier{ &tube_builder, vk.mega };
 
    // Generate the recursive verification circuit
    StdlibProof stdlib_proof(tube_builder, proof);
    CIVCRecVerifierOutput client_ivc_rec_verifier_output = verifier.verify(stdlib_proof);
 
    {
        // IO
        RollupIO inputs;
        inputs.pairing_inputs = client_ivc_rec_verifier_output.points_accumulator;
        inputs.ipa_claim = client_ivc_rec_verifier_output.opening_claim;
        inputs.set_public();
    }
 
    // The tube only calls an IPA recursive verifier once, so we can just add this IPA proof
    tube_builder.ipa_proof = client_ivc_rec_verifier_output.ipa_proof.get_value();
 
    info("ClientIVC Recursive Verifier: num prefinalized gates = ", tube_builder.num_gates);
 
    EXPECT_EQ(tube_builder.failed(), false) << tube_builder.err();
 
    // EXPECT_TRUE(CircuitChecker::check(tube_builder));
 
    // Construct and verify a proof for the ClientIVC Recursive Verifier circuit
    auto proving_key = std::make_shared<DeciderProvingKey_<NativeFlavor>>(tube_builder);
    auto native_vk_with_ipa = std::make_shared<NativeFlavor::VerificationKey>(proving_key->get_precomputed());
    UltraProver_<NativeFlavor> tube_prover{ proving_key, native_vk_with_ipa };
    // Prove the CIVCRecursiveVerifier circuit
    auto native_tube_proof = tube_prover.construct_proof();
 
    // Natively verify the tube proof
    VerifierCommitmentKey<curve::Grumpkin> ipa_verification_key(1 << CONST_ECCVM_LOG_N);
    UltraVerifier_<NativeFlavor> native_verifier(native_vk_with_ipa, ipa_verification_key);
    bool native_result =
        native_verifier.template verify_proof<bb::RollupIO>(native_tube_proof, tube_prover.proving_key->ipa_proof)
            .result;
    EXPECT_TRUE(native_result);
 
    // Construct a base rollup circuit that recursively verifies the tube proof and forwards the IPA proof.
    Builder base_builder;
    auto tube_vk = std::make_shared<NativeFlavor::VerificationKey>(proving_key->get_precomputed());
    auto stdlib_tube_vk_and_hash = std::make_shared<RollupFlavor::VKAndHash>(base_builder, tube_vk);
    stdlib::Proof<Builder> base_tube_proof(base_builder, native_tube_proof);
    UltraRecursiveVerifier base_verifier{ &base_builder, stdlib_tube_vk_and_hash };
    UltraRecursiveVerifierOutput<Builder> output = base_verifier.template verify_proof<RollupIO>(base_tube_proof);
    info("Tube UH Recursive Verifier: num prefinalized gates = ", base_builder.num_gates);
 
    {
        // IO
        RollupIO inputs;
        inputs.pairing_inputs = output.points_accumulator;
        inputs.ipa_claim = output.ipa_claim;
        inputs.set_public();
    }
 
    base_builder.ipa_proof = tube_prover.proving_key->ipa_proof;
    EXPECT_EQ(base_builder.failed(), false) << base_builder.err();
    EXPECT_TRUE(CircuitChecker::check(base_builder));
 
    // Natively verify the IPA proof for the base rollup circuit
    auto base_proving_key = std::make_shared<DeciderProvingKey_<NativeFlavor>>(base_builder);
    auto ipa_transcript = std::make_shared<NativeTranscript>();
    ipa_transcript->load_proof(base_proving_key->ipa_proof);
    IPA<curve::Grumpkin>::reduce_verify(
        ipa_verification_key, output.ipa_claim.get_native_opening_claim(), ipa_transcript);
}
 
// Ensure that the Client IVC Recursive Verifier Circuit does not depend on the Client IVC input
TEST_F(ClientIVCRecursionTests, TubeVKIndependentOfInputCircuits)
{
    // Retrieves the trace blocks (each consisting of a specific gate) from the recursive verifier circuit
    auto get_blocks = [](size_t num_app_circuits)
        -> std::tuple<typename Builder::ExecutionTrace, std::shared_ptr<NativeFlavor::VerificationKey>> {
        auto [proof, ivc_vk] = construct_client_ivc_prover_output(num_app_circuits);
 
        Builder tube_builder;
        ClientIVCVerifier verifier{ &tube_builder, ivc_vk.mega };
 
        StdlibProof stdlib_proof(tube_builder, proof);
        auto client_ivc_rec_verifier_output = verifier.verify(stdlib_proof);
 
        // IO
        RollupIO inputs;
        inputs.pairing_inputs = client_ivc_rec_verifier_output.points_accumulator;
        inputs.ipa_claim = client_ivc_rec_verifier_output.opening_claim;
        inputs.set_public();
 
        // The tube only calls an IPA recursive verifier once, so we can just add this IPA proof
        tube_builder.ipa_proof = client_ivc_rec_verifier_output.ipa_proof.get_value();
 
        info("ClientIVC Recursive Verifier: num prefinalized gates = ", tube_builder.num_gates);
 
        EXPECT_EQ(tube_builder.failed(), false) << tube_builder.err();
 
        // Construct and verify a proof for the ClientIVC Recursive Verifier circuit
        auto proving_key = std::make_shared<DeciderProvingKey_<NativeFlavor>>(tube_builder);
 
        auto tube_vk = std::make_shared<NativeFlavor::VerificationKey>(proving_key->get_precomputed());
 
        return { tube_builder.blocks, tube_vk };
    };
 
    auto [blocks_4, verification_key_4] = get_blocks(/*num_app_circuits=*/1);
    auto [blocks_5, verification_key_5] = get_blocks(/*num_app_circuits=*/2);
 
    compare_ultra_blocks_and_verification_keys<NativeFlavor>({ blocks_4, blocks_5 },
                                                             { verification_key_4, verification_key_5 });
}
} // namespace bb::stdlib::recursion::honk