flavor.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/ref_vector.hpp"
#include "barretenberg/common/std_array.hpp"
#include "barretenberg/common/std_vector.hpp"
#include "barretenberg/common/tuple.hpp"
#include "barretenberg/common/zip_view.hpp"
#include "barretenberg/constants.hpp"
#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
#include "barretenberg/ecc/fields/field_conversion.hpp"
#include "barretenberg/honk/types/circuit_type.hpp"
#include "barretenberg/polynomials/barycentric.hpp"
#include "barretenberg/polynomials/evaluation_domain.hpp"
#include "barretenberg/polynomials/univariate.hpp"
#include "barretenberg/public_input_component/public_component_key.hpp"
#include "barretenberg/srs/global_crs.hpp"
#include "barretenberg/stdlib/hash/poseidon2/poseidon2.hpp"
#include "barretenberg/stdlib/primitives/field/field_conversion.hpp"
#include "barretenberg/stdlib/transcript/transcript.hpp"
#include "barretenberg/transcript/transcript.hpp"
 
#include <array>
#include <concepts>
#include <cstddef>
#include <numeric>
#include <utility>
#include <vector>
 
namespace bb {
 
// Specifies the regions of the execution trace containing non-trivial wire values
struct ActiveRegionData {
    void add_range(const size_t start, const size_t end)
    {
        BB_ASSERT_GTE(start, current_end, "Ranges should be non-overlapping and increasing.");
        ranges.emplace_back(start, end);
        for (size_t i = start; i < end; ++i) {
            idxs.push_back(i);
        }
        current_end = end;
    }
 
    std::vector<std::pair<size_t, size_t>> get_ranges() const { return ranges; }
    size_t get_idx(const size_t idx) const { return idxs[idx]; }
    std::pair<size_t, size_t> get_range(const size_t idx) const { return ranges.at(idx); }
    size_t size() const { return idxs.size(); }
    size_t num_ranges() const { return ranges.size(); }
 
  private:
    std::vector<std::pair<size_t, size_t>> ranges; // active ranges [start_i, end_i) of the execution trace
    std::vector<size_t> idxs;                      // full set of poly indices corresposponding to active ranges
    size_t current_end{ 0 };                       // end of last range; for ensuring monotonicity of ranges
};
 
struct MetaData {
    size_t dyadic_size = 0; // power-of-2 size of the execution trace
    size_t num_public_inputs = 0;
    size_t pub_inputs_offset = 0;
};
 
template <typename Polynomial, size_t NUM_PRECOMPUTED_ENTITIES> struct PrecomputedData_ {
    RefArray<Polynomial, NUM_PRECOMPUTED_ENTITIES> polynomials; // polys whose commitments comprise the VK
    MetaData metadata;                                          // execution trace metadata
};
 
template <typename PrecomputedCommitments, typename Transcript>
class NativeVerificationKey_ : public PrecomputedCommitments {
  public:
    using Commitment = typename PrecomputedCommitments::DataType;
    uint64_t log_circuit_size = 0;
    uint64_t num_public_inputs = 0;
    uint64_t pub_inputs_offset = 0;
 
    bool operator==(const NativeVerificationKey_&) const = default;
    virtual ~NativeVerificationKey_() = default;
    NativeVerificationKey_() = default;
    NativeVerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
    };
 
    virtual std::vector<typename Transcript::DataType> to_field_elements() const
    {
        using namespace bb::field_conversion;
 
        auto serialize = [](const auto& input, std::vector<typename Transcript::DataType>& buffer) {
            std::vector<typename Transcript::DataType> input_fields = Transcript::serialize(input);
            buffer.insert(buffer.end(), input_fields.begin(), input_fields.end());
        };
 
        std::vector<typename Transcript::DataType> elements;
 
        serialize(this->log_circuit_size, elements);
        serialize(this->num_public_inputs, elements);
        serialize(this->pub_inputs_offset, elements);
 
        for (const Commitment& commitment : this->get_all()) {
            serialize(commitment, elements);
        }
 
        return elements;
    };
 
    fr hash() const
    {
        // TODO(https://github.com/AztecProtocol/barretenberg/issues/1498): should hash be dependent on transcript?
        fr vk_hash = Transcript::hash(this->to_field_elements());
        return vk_hash;
    }
 
    virtual typename Transcript::DataType hash_through_transcript(const std::string& domain_separator,
                                                                  Transcript& transcript) const
    {
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_log_circuit_size", this->log_circuit_size);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_num_public_inputs", this->num_public_inputs);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_pub_inputs_offset", this->pub_inputs_offset);
 
        for (const Commitment& commitment : this->get_all()) {
            transcript.add_to_independent_hash_buffer(domain_separator + "vk_commitment", commitment);
        }
 
        return transcript.hash_independent_buffer();
    }
};
 
template <typename Builder_, typename PrecomputedCommitments>
class StdlibVerificationKey_ : public PrecomputedCommitments {
  public:
    using Builder = Builder_;
    using FF = stdlib::field_t<Builder>;
    using Commitment = typename PrecomputedCommitments::DataType;
    using Transcript = BaseTranscript<stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
    FF log_circuit_size;
    FF num_public_inputs;
    FF pub_inputs_offset = 0;
 
    bool operator==(const StdlibVerificationKey_&) const = default;
    virtual ~StdlibVerificationKey_() = default;
    StdlibVerificationKey_() = default;
    StdlibVerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
    };
 
    virtual std::vector<FF> to_field_elements() const
    {
        using namespace bb::stdlib::field_conversion;
 
        auto serialize_to_field_buffer = []<typename T>(const T& input, std::vector<FF>& buffer) {
            std::vector<FF> input_fields = convert_to_bn254_frs<Builder, T>(input);
            buffer.insert(buffer.end(), input_fields.begin(), input_fields.end());
        };
 
        std::vector<FF> elements;
 
        serialize_to_field_buffer(this->log_circuit_size, elements);
        serialize_to_field_buffer(this->num_public_inputs, elements);
        serialize_to_field_buffer(this->pub_inputs_offset, elements);
 
        for (const Commitment& commitment : this->get_all()) {
            serialize_to_field_buffer(commitment, elements);
        }
 
        return elements;
    };
 
    FF hash(Builder& builder)
    {
        FF vk_hash = stdlib::poseidon2<Builder>::hash(builder, to_field_elements());
        return vk_hash;
    }
 
    virtual FF hash_through_transcript(const std::string& domain_separator, Transcript& transcript) const
    {
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_log_circuit_size", this->log_circuit_size);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_num_public_inputs", this->num_public_inputs);
        transcript.add_to_independent_hash_buffer(domain_separator + "vk_pub_inputs_offset", this->pub_inputs_offset);
        for (const Commitment& commitment : this->get_all()) {
            transcript.add_to_independent_hash_buffer(domain_separator + "vk_commitment", commitment);
        }
        return transcript.hash_independent_buffer();
    }
};
 
template <typename FF, typename VerificationKey> class VKAndHash_ {
  public:
    using Builder = VerificationKey::Builder;
    using NativeVerificationKey = VerificationKey::NativeVerificationKey;
 
    VKAndHash_() = default;
    VKAndHash_(const std::shared_ptr<VerificationKey>& vk)
        : vk(vk)
        , hash(vk->hash())
    {}
 
    VKAndHash_(const std::shared_ptr<VerificationKey>& vk, const FF& hash)
        : vk(vk)
        , hash(hash)
    {}
 
    VKAndHash_(Builder& builder, const std::shared_ptr<NativeVerificationKey>& native_vk)
        : vk(std::make_shared<VerificationKey>(&builder, native_vk))
        , hash(FF::from_witness(&builder, native_vk->hash()))
    {}
    std::shared_ptr<VerificationKey> vk;
    FF hash;
};
 
// Because of how Gemini is written, it is important to put the polynomials out in this order.
auto get_unshifted_then_shifted(const auto& all_entities)
{
    return concatenate(all_entities.get_unshifted(), all_entities.get_shifted());
};
 
template <typename Tuple> constexpr size_t compute_max_partial_relation_length()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::max({ std::tuple_element_t<Is, Tuple>::RELATION_LENGTH... });
    }(seq);
}
 
template <typename Tuple> constexpr size_t compute_max_total_relation_length()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::max({ std::tuple_element_t<Is, Tuple>::TOTAL_RELATION_LENGTH... });
    }(seq);
}
 
template <typename Tuple> constexpr size_t compute_number_of_subrelations()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<std::size_t... I>(std::index_sequence<I...>) {
        return (0 + ... + std::tuple_element_t<I, Tuple>::SUBRELATION_PARTIAL_LENGTHS.size());
    }(seq);
}
 
template <typename Tuple, size_t NUM_KEYS, bool optimized = false>
constexpr auto create_protogalaxy_tuple_of_tuples_of_univariates()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<Tuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        if constexpr (optimized) {
            return flat_tuple::make_tuple(
                typename std::tuple_element_t<I, Tuple>::template ProtogalaxyTupleOfUnivariatesOverSubrelations<
                    NUM_KEYS>{}...);
        } else {
            return flat_tuple::make_tuple(
                typename std::tuple_element_t<I, Tuple>::
                    template ProtogalaxyTupleOfUnivariatesOverSubrelationsNoOptimisticSkipping<NUM_KEYS>{}...);
        }
    }(seq);
}
 
template <typename RelationsTuple> constexpr auto create_sumcheck_tuple_of_tuples_of_univariates()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<RelationsTuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        return flat_tuple::make_tuple(
            typename std::tuple_element_t<I, RelationsTuple>::SumcheckTupleOfUnivariatesOverSubrelations{}...);
    }(seq);
}
 
template <typename RelationsTuple> constexpr auto create_tuple_of_arrays_of_values()
{
    constexpr auto seq = std::make_index_sequence<std::tuple_size_v<RelationsTuple>>();
    return []<size_t... I>(std::index_sequence<I...>) {
        return flat_tuple::make_tuple(
            typename std::tuple_element_t<I, RelationsTuple>::SumcheckArrayOfValuesOverSubrelations{}...);
    }(seq);
}
 
} // namespace bb
 
// Forward declare honk flavors
namespace bb {
class UltraFlavor;
class UltraZKFlavor;
class UltraRollupFlavor;
class ECCVMFlavor;
class UltraKeccakFlavor;
#ifdef STARKNET_GARAGA_FLAVORS
class UltraStarknetFlavor;
class UltraStarknetZKFlavor;
#endif
class UltraKeccakZKFlavor;
class MegaFlavor;
class MegaZKFlavor;
class TranslatorFlavor;
class ECCVMRecursiveFlavor;
class TranslatorRecursiveFlavor;
class AvmRecursiveFlavor;
 
template <typename BuilderType> class UltraRecursiveFlavor_;
template <typename BuilderType> class UltraZKRecursiveFlavor_;
template <typename BuilderType> class UltraRollupRecursiveFlavor_;
template <typename BuilderType> class MegaRecursiveFlavor_;
template <typename BuilderType> class MegaZKRecursiveFlavor_;
 
namespace avm2 {
class AvmRecursiveFlavor;
}
 
} // namespace bb