oink_prover.test.cpp

Go to the documentation of this file.

#include "barretenberg/ultra_honk/oink_prover.hpp"
#include "barretenberg/flavor/verifier_commitments.hpp"
#include "barretenberg/goblin/mock_circuits.hpp"
#include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp"
#include "barretenberg/ultra_honk/oink_verifier.hpp"
#include "barretenberg/ultra_honk/prover_instance.hpp"
 
#include <gtest/gtest.h>
 
using namespace bb;
 
class OinkTests : public ::testing::Test {
  public:
    using Flavor = MegaFlavor;
    using Transcript = Flavor::Transcript;
    using OinkProver = bb::OinkProver<Flavor>;
    using OinkVerifier = bb::OinkVerifier<Flavor>;
    using Builder = Flavor::CircuitBuilder;
    using ProverInstance = ProverInstance_<Flavor>;
    using VerificationKey = Flavor::VerificationKey;
    using VerifierInstance = VerifierInstance_<Flavor>;
 
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); };
};
 
TEST_F(OinkTests, OinkProverIsDeterministic)
{
    Builder circuit;
    GoblinMockCircuits::construct_simple_circuit(circuit);
    auto prover_instance = std::make_shared<ProverInstance>(circuit);
    auto verification_key = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
 
    {
        // Run OinkProver for the first time
        OinkProver prover(prover_instance, verification_key, std::make_shared<Transcript>());
        prover.prove();
    }
 
    // Store data generated by Oink prover
    auto alpha = prover_instance->alpha;
    auto gate_challenges = prover_instance->gate_challenges;
    auto w4 = prover_instance->polynomials.w_4();
    auto lookup_read_counts = prover_instance->polynomials.lookup_read_counts();
    auto lookup_read_tag = prover_instance->polynomials.lookup_read_tags();
    auto lookup_inverse = prover_instance->polynomials.lookup_inverses();
    auto z_perm = prover_instance->polynomials.z_perm();
    auto databus_inverses = prover_instance->polynomials.get_databus_inverses().get_copy();
 
    {
        // Run OinkProver for the second time
        OinkProver prover(prover_instance, verification_key, std::make_shared<Transcript>());
        prover.prove();
    }
 
    // Check that the data hasn't changed
    BB_ASSERT_EQ(prover_instance->alpha, alpha);
 
    for (auto [new_challenge, old_challenge] : zip_view(prover_instance->gate_challenges, gate_challenges)) {
        BB_ASSERT_EQ(new_challenge, old_challenge);
    };
    BB_ASSERT_EQ(prover_instance->polynomials.w_4(), w4);
    BB_ASSERT_EQ(prover_instance->polynomials.lookup_read_counts(), lookup_read_counts);
    BB_ASSERT_EQ(prover_instance->polynomials.lookup_read_tags(), lookup_read_tag);
    BB_ASSERT_EQ(prover_instance->polynomials.lookup_inverses(), lookup_inverse);
    BB_ASSERT_EQ(prover_instance->polynomials.z_perm(), z_perm);
    for (auto [new_databus, old_databus] :
         zip_view(prover_instance->polynomials.get_databus_inverses().get_copy(), databus_inverses)) {
        BB_ASSERT_EQ(new_databus, old_databus);
    };
}
 
TEST_F(OinkTests, OinkProverCommitments)
{
    Builder circuit;
    GoblinMockCircuits::construct_simple_circuit(circuit);
    auto prover_instance = std::make_shared<ProverInstance>(circuit);
    auto verification_key = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
    auto vk_and_hash = std::make_shared<typename Flavor::VKAndHash>(verification_key);
    auto verifier_instance = std::make_shared<VerifierInstance>(vk_and_hash);
 
    OinkProver prover(prover_instance, verification_key, std::make_shared<Transcript>());
    prover.prove();
    HonkProof proof = prover.export_proof();
 
    auto prover_commitments =
        VerifierCommitmentsConstructor<Flavor>::construct(verification_key, prover_instance->commitments);
 
    auto transcript = std::make_shared<Transcript>();
    transcript->load_proof(proof);
    OinkVerifier verifier(verifier_instance, transcript, verification_key->num_public_inputs);
    verifier.verify();
 
    auto verifier_commitments = VerifierCommitmentsConstructor<Flavor>::construct(
        verifier_instance->get_vk(), verifier_instance->witness_commitments);
 
    for (auto [prover_comm, verifier_comm, label] : zip_view(prover_commitments.get_all(),
                                                             verifier_commitments.get_all(),
                                                             decltype(prover_commitments)::get_labels())) {
        EXPECT_EQ(prover_comm, verifier_comm) << "Mismatch in commitments " << label;
    }
}