composer.cpp.hbs

// AUTOGENERATED FILE
#include "barretenberg/vm/{{snakeCase name}}/generated/composer.hpp"

#include "barretenberg/plonk_honk_shared/composer/composer_lib.hpp"
#include "barretenberg/plonk_honk_shared/composer/permutation_lib.hpp"
#include "barretenberg/vm/{{snakeCase name}}/generated/circuit_builder.hpp"
#include "barretenberg/vm/{{snakeCase name}}/generated/verifier.hpp"

namespace bb {

using Flavor = {{name}}Flavor;
void {{name}}Composer::compute_witness(CircuitConstructor& circuit)
{
    if (computed_witness) {
        return;
    }

    auto polynomials = circuit.compute_polynomials();

    for (auto [key_poly, prover_poly] : zip_view(proving_key->get_all(), polynomials.get_unshifted())) {
        ASSERT(flavor_get_label(*proving_key, key_poly) == flavor_get_label(polynomials, prover_poly));
        key_poly = prover_poly;
    }

    computed_witness = true;
}

{{name}}Prover {{name}}Composer::create_prover(CircuitConstructor& circuit_constructor)
{
    compute_proving_key(circuit_constructor);
    compute_witness(circuit_constructor);
    compute_commitment_key(circuit_constructor.get_circuit_subgroup_size());

    {{name}}Prover output_state(proving_key, proving_key->commitment_key);

    return output_state;
}

{{name}}Verifier {{name}}Composer::create_verifier(CircuitConstructor& circuit_constructor)
{
    auto verification_key = compute_verification_key(circuit_constructor);
    return {{name}}Verifier(std::move(verification_key));
}

std::shared_ptr<Flavor::ProvingKey> {{name}}Composer::compute_proving_key(CircuitConstructor& circuit_constructor)
{
    if (proving_key) {
        return proving_key;
    }

    // Initialize proving_key
    {
        const size_t subgroup_size = circuit_constructor.get_circuit_subgroup_size();
        proving_key = std::make_shared<Flavor::ProvingKey>(subgroup_size, 0);
    }

    proving_key->contains_recursive_proof = false;

    return proving_key;
}

std::shared_ptr<Flavor::VerificationKey> {{name}}Composer::compute_verification_key(CircuitConstructor& circuit_constructor)
{
    if (verification_key) {
        return verification_key;
    }

    if (!proving_key) {
        compute_proving_key(circuit_constructor);
    }

    verification_key = std::make_shared<Flavor::VerificationKey>(proving_key);

    return verification_key;
}

} // namespace bb