api_avm.cpp

Go to the documentation of this file.

#include "api_avm.hpp"
 
#include <filesystem>
 
#include "barretenberg/api/api_avm.hpp"
#include "barretenberg/api/file_io.hpp"
#include "barretenberg/common/map.hpp"
#include "barretenberg/vm2/avm_api.hpp"
#include "barretenberg/vm2/common/constants.hpp"
#include "barretenberg/vm2/tooling/stats.hpp"
 
namespace bb {
 
// AVM is enabled in this build
const bool avm_enabled = true;
 
namespace {
 
void print_avm_stats()
{
#ifdef AVM_TRACK_STATS
    info("------- STATS -------");
    const auto& stats = ::bb::avm2::Stats::get();
    const int levels = std::getenv("AVM_STATS_DEPTH") != nullptr ? std::stoi(std::getenv("AVM_STATS_DEPTH")) : 2;
    info(stats.to_string(levels));
#endif
}
 
} // namespace
 
void avm_prove(const std::filesystem::path& inputs_path, const std::filesystem::path& output_path)
{
    avm2::AvmAPI avm;
    auto inputs = avm2::AvmAPI::ProvingInputs::from(read_file(inputs_path));
    auto proof = avm.prove(inputs);
 
    // NOTE: As opposed to other proof systems, the public inputs are NOT part of the proof.
    write_file(output_path / "proof", to_buffer(proof));
 
    print_avm_stats();
 
    // NOTE: Temporarily we also verify after proving.
    // The reasoning is that proving will always pass unless it crashes.
    // We want to return an exit code != 0 if the proof is invalid so that the prover client saves the inputs.
    info("verifying...");
    bool res = avm.verify(proof, inputs.public_inputs);
    info("verification: ", res ? "success" : "failure");
    if (!res) {
        throw std::runtime_error("Generated proof is invalid!!!!!");
    }
}
 
void avm_check_circuit(const std::filesystem::path& inputs_path)
{
    avm2::AvmAPI avm;
    auto inputs = avm2::AvmAPI::ProvingInputs::from(read_file(inputs_path));
 
    bool res = avm.check_circuit(inputs);
    info("circuit check: ", res ? "success" : "failure");
 
    print_avm_stats();
}
 
// NOTE: The proof should NOT include the public inputs.
bool avm_verify(const std::filesystem::path& proof_path, const std::filesystem::path& public_inputs_path)
{
    const auto proof = many_from_buffer<fr>(read_file(proof_path));
    auto public_inputs = avm2::PublicInputs::from(read_file(public_inputs_path));
 
    avm2::AvmAPI avm;
    bool res = avm.verify(proof, public_inputs);
    info("verification: ", res ? "success" : "failure");
 
    print_avm_stats();
    return res;
}
 
void avm_simulate(const std::filesystem::path& inputs_path)
{
    // This includes input deserialization as well.
    AVM_TRACK_TIME("command/avm_simulate", {
        avm2::AvmAPI avm;
        auto inputs = avm2::AvmAPI::ProvingInputs::from(read_file(inputs_path));
        avm.simulate_with_hinted_dbs(inputs);
    });
 
    print_avm_stats();
}
 
void avm_write_verification_key(const std::filesystem::path& output_path)
{
    avm2::AvmAPI avm;
    auto vk = avm.get_verification_key();
    info("Writing AVM verification key to: ", output_path / "vk");
    write_file(output_path / "vk", vk);
}
 
AvmProveResult avm_prove_from_bytes(std::vector<uint8_t> inputs)
{
    avm2::AvmAPI avm;
    auto proving_inputs = avm2::AvmAPI::ProvingInputs::from(inputs);
    auto proof = avm.prove(proving_inputs);
 
    print_avm_stats();
 
    return AvmProveResult{ .proof = std::move(proof) };
}
 
bool avm_verify_from_bytes(std::vector<bb::fr> proof, std::vector<uint8_t> public_inputs)
{
    auto pi = avm2::PublicInputs::from(public_inputs);
 
    avm2::AvmAPI avm;
    bool res = avm.verify(proof, pi);
    info("verification: ", res ? "success" : "failure");
 
    print_avm_stats();
    return res;
}
 
bool avm_check_circuit_from_bytes(std::vector<uint8_t> inputs)
{
    avm2::AvmAPI avm;
    auto proving_inputs = avm2::AvmAPI::ProvingInputs::from(inputs);
 
    bool res = avm.check_circuit(proving_inputs);
    info("circuit check: ", res ? "success" : "failure");
 
    print_avm_stats();
    return res;
}
 
} // namespace bb