flavor.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#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/transcript/transcript.hpp"
 
#include <array>
#include <concepts>
#include <cstddef>
#include <numeric>
#include <utility>
#include <vector>
 
namespace bb {
 
enum class VKSerializationMode : std::uint8_t {
    FULL,       // Serialize all metadata (log_circuit_size, num_public_inputs, pub_inputs_offset)
    NO_METADATA // Serialize only commitments, no metadata
};
 
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 HashType, typename HardcodedVKAndHash>
class FixedVKAndHash_ : public PrecomputedCommitments {
  public:
    using Commitment = typename PrecomputedCommitments::DataType;
 
    bool operator==(const FixedVKAndHash_&) const = default;
 
    // Default construct the fixed VK from hardcoded commitments and precomputed hash
    FixedVKAndHash_()
        : hash(HardcodedVKAndHash::vk_hash())
    {
        for (auto [vk_commitment, fixed_commitment] : zip_view(this->get_all(), HardcodedVKAndHash::get_all())) {
            vk_commitment = fixed_commitment;
        }
    }
 
    HashType get_hash() const { return hash; }
 
  private:
    HashType hash{};
};
 
template <typename PrecomputedCommitments,
          typename Codec,
          typename HashFunction,
          typename CommitmentKey = void,
          VKSerializationMode SerializeMetadata = VKSerializationMode::FULL>
class NativeVerificationKey_ : public PrecomputedCommitments {
  public:
    using Commitment = typename PrecomputedCommitments::DataType;
    using DataType = typename Codec::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;
 
#ifndef NDEBUG
    template <size_t NUM_PRECOMPUTED_ENTITIES, typename StringType>
    bool compare(const NativeVerificationKey_& other,
                 RefArray<StringType, NUM_PRECOMPUTED_ENTITIES> commitment_labels) const
    {
        bool is_equal = true;
 
        if (this->log_circuit_size != other.log_circuit_size) {
            info("Log circuit size mismatch: ", this->log_circuit_size, " vs ", other.log_circuit_size);
            is_equal = false;
        }
 
        if (this->num_public_inputs != other.num_public_inputs) {
            info("Num public inputs mismatch: ", this->num_public_inputs, " vs ", other.num_public_inputs);
            is_equal = false;
        }
 
        if (this->pub_inputs_offset != other.pub_inputs_offset) {
            info("Pub inputs offset mismatch: ", this->pub_inputs_offset, " vs ", other.pub_inputs_offset);
            is_equal = false;
        }
 
        for (auto [this_comm, other_comm, label] : zip_view(this->get_all(), other.get_all(), commitment_labels)) {
            if (this_comm != other_comm) {
                info("Commitment mismatch: ", label);
                is_equal = false;
            }
        }
        return is_equal;
    }
#endif
 
    virtual ~NativeVerificationKey_() = default;
    NativeVerificationKey_() = default;
    NativeVerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
        : log_circuit_size(numeric::get_msb(circuit_size))
        , num_public_inputs(num_public_inputs) {};
 
    template <typename PrecomputedData>
        requires(!std::is_void_v<CommitmentKey>)
    explicit NativeVerificationKey_(const PrecomputedData& precomputed)
        : log_circuit_size(numeric::get_msb(precomputed.metadata.dyadic_size))
        , num_public_inputs(precomputed.metadata.num_public_inputs)
        , pub_inputs_offset(precomputed.metadata.pub_inputs_offset)
    {
        CommitmentKey commitment_key{ precomputed.metadata.dyadic_size };
        for (auto [polynomial, commitment] : zip_view(precomputed.polynomials, this->get_all())) {
            commitment = commitment_key.commit(polynomial);
        }
    }
 
    static size_t calc_num_data_types()
    {
        // Create a temporary instance to get the number of precomputed entities
        size_t commitments_size = PrecomputedCommitments::size() * Codec::template calc_num_fields<Commitment>();
        size_t metadata_size = 0;
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            // 3 metadata fields + commitments
            metadata_size = 3 * Codec::template calc_num_fields<uint64_t>();
        }
        // else NO_METADATA: metadata_size remains 0
        return metadata_size + commitments_size;
    }
 
    virtual std::vector<DataType> to_field_elements() const
    {
 
        auto serialize = [](const auto& input, std::vector<DataType>& buffer) {
            std::vector<DataType> input_fields = Codec::serialize_to_fields(input);
            buffer.insert(buffer.end(), input_fields.begin(), input_fields.end());
        };
 
        std::vector<DataType> elements;
 
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            serialize(this->log_circuit_size, elements);
            serialize(this->num_public_inputs, elements);
            serialize(this->pub_inputs_offset, elements);
        }
        // else NO_METADATA: skip metadata serialization
 
        for (const Commitment& commitment : this->get_all()) {
            serialize(commitment, elements);
        }
 
        return elements;
    };
 
    size_t from_field_elements(const std::span<const DataType>& elements)
    {
 
        size_t idx = 0;
        auto deserialize = [&idx, &elements]<typename T>(T& target) {
            size_t size = Codec::template calc_num_fields<T>();
            target = Codec::template deserialize_from_fields<T>(elements.subspan(idx, size));
            idx += size;
        };
 
        if constexpr (SerializeMetadata == VKSerializationMode::FULL) {
            deserialize(this->log_circuit_size);
            deserialize(this->num_public_inputs);
            deserialize(this->pub_inputs_offset);
        }
        // else NO_METADATA: skip metadata deserialization
 
        for (Commitment& commitment : this->get_all()) {
            deserialize(commitment);
        }
        return idx;
    }
 
    fr hash() const
    {
        fr vk_hash = HashFunction::hash(this->to_field_elements());
        return vk_hash;
    }
 
    virtual DataType hash_with_origin_tagging(const OriginTag& tag) const
    {
        static constexpr bool in_circuit = InCircuit<DataType>;
        std::vector<DataType> vk_elements;
 
        // Tag, serialize, and append to vk_elements
        auto tag_and_append = [&]<typename T>(const T& component) {
            auto frs = bb::tag_and_serialize<in_circuit, Codec>(component, tag);
            vk_elements.insert(vk_elements.end(), frs.begin(), frs.end());
        };
 
        // Tag and serialize VK metadata
        tag_and_append(this->log_circuit_size);
        tag_and_append(this->num_public_inputs);
        tag_and_append(this->pub_inputs_offset);
 
        // Tag and serialize VK commitments
        for (const Commitment& commitment : this->get_all()) {
            tag_and_append(commitment);
        }
 
        // Sanitize free witness tags before hashing
        bb::unset_free_witness_tags<in_circuit, DataType>(vk_elements);
 
        // Hash the tagged elements directly
        return HashFunction::hash(vk_elements);
    }
 
    template <typename Transcript> DataType hash_with_origin_tagging(const Transcript& transcript) const
    {
        const OriginTag tag = bb::extract_transcript_tag(transcript);
        return hash_with_origin_tagging(tag);
    }
};
 
template <typename Builder_, typename PrecomputedCommitments, typename NativeVerificationKey>
class FixedStdlibVKAndHash_ : public PrecomputedCommitments {
  public:
    using Builder = Builder_;
    using Commitment = typename PrecomputedCommitments::DataType;
    using FF = stdlib::field_t<Builder>;
 
    bool operator==(const FixedStdlibVKAndHash_&) const = default;
    FixedStdlibVKAndHash_() = default;
 
    FixedStdlibVKAndHash_(Builder* builder, const std::shared_ptr<NativeVerificationKey>& native_key)
        : hash(FF::from_witness(builder, native_key->get_hash()))
    {
        for (auto [native_comm, comm] : zip_view(native_key->get_all(), this->get_all())) {
            comm = Commitment::from_witness(builder, native_comm);
        }
        // Fix all witnesses since fixed VKs are always constant
        hash.fix_witness();
        for (Commitment& commitment : this->get_all()) {
            commitment.fix_witness();
        }
    }
 
    FF get_hash() const { return hash; }
 
  private:
    FF hash;
};
 
template <typename Builder_,
          typename PrecomputedCommitments,
          typename NativeVerificationKey_ = void,
          VKSerializationMode SerializeMetadata = VKSerializationMode::FULL>
class StdlibVerificationKey_ : public PrecomputedCommitments {
  public:
    using Builder = Builder_;
    using FF = stdlib::field_t<Builder>;
    using Commitment = typename PrecomputedCommitments::DataType;
    using Transcript = StdlibTranscript<Builder>;
    using NativeVerificationKey = NativeVerificationKey_;
    FF log_circuit_size;
    FF num_public_inputs;
    FF pub_inputs_offset = 0;
 
    bool operator==(const StdlibVerificationKey_&) const = default;
    virtual ~StdlibVerificationKey_() = default;
    StdlibVerificationKey_() = default;
 
    template <typename T = NativeVerificationKey_>
        requires(!std::is_void_v<T>)
    StdlibVerificationKey_(Builder* builder, const std::shared_ptr<T>& native_key)
        : log_circuit_size(FF::from_witness(builder, typename FF::native(native_key->log_circuit_size)))
        , num_public_inputs(FF::from_witness(builder, typename FF::native(native_key->num_public_inputs)))
        , pub_inputs_offset(FF::from_witness(builder, typename FF::native(native_key->pub_inputs_offset)))
    {
 
        for (auto [commitment, native_commitment] : zip_view(this->get_all(), native_key->get_all())) {
            commitment = Commitment::from_witness(builder, native_commitment);
        }
    }
 
    explicit StdlibVerificationKey_(std::span<FF> elements)
    {
        using Codec = stdlib::StdlibCodec<FF>;
 
        size_t num_frs_read = 0;
 
        this->log_circuit_size = Codec::template deserialize_from_frs<FF>(elements, num_frs_read);
        this->num_public_inputs = Codec::template deserialize_from_frs<FF>(elements, num_frs_read);
        this->pub_inputs_offset = Codec::template deserialize_from_frs<FF>(elements, num_frs_read);
 
        for (Commitment& commitment : this->get_all()) {
            commitment = Codec::template deserialize_from_frs<Commitment>(elements, num_frs_read);
        }
    }
 
    static StdlibVerificationKey_ from_witness_indices(Builder& builder,
                                                       const std::span<const uint32_t>& witness_indices)
    {
        std::vector<FF> vk_fields;
        vk_fields.reserve(witness_indices.size());
        for (const auto& idx : witness_indices) {
            vk_fields.emplace_back(FF::from_witness_index(&builder, idx));
        }
        return StdlibVerificationKey_(vk_fields);
    }
 
    void fix_witness()
    {
        this->log_circuit_size.fix_witness();
        this->num_public_inputs.fix_witness();
        this->pub_inputs_offset.fix_witness();
        for (Commitment& commitment : this->get_all()) {
            commitment.fix_witness();
        }
    }
 
#ifndef NDEBUG
    template <typename T = NativeVerificationKey_>
        requires(!std::is_void_v<T>)
    T get_value() const
    {
        T native_vk;
        native_vk.log_circuit_size = static_cast<uint64_t>(this->log_circuit_size.get_value());
        native_vk.num_public_inputs = static_cast<uint64_t>(this->num_public_inputs.get_value());
        native_vk.pub_inputs_offset = static_cast<uint64_t>(this->pub_inputs_offset.get_value());
        for (auto [commitment, native_commitment] : zip_view(this->get_all(), native_vk.get_all())) {
            native_commitment = commitment.get_value();
        }
        return native_vk;
    }
#endif
 
    virtual FF hash_with_origin_tagging(const OriginTag& tag) const
    {
        using Codec = stdlib::StdlibCodec<FF>;
        static constexpr bool in_circuit = true; // StdlibVerificationKey_ is always in-circuit
        std::vector<FF> vk_elements;
 
        // Tag, serialize, and append to vk_elements
        auto append_tagged = [&]<typename T>(const T& component) {
            auto frs = bb::tag_and_serialize<in_circuit, Codec>(component, tag);
            vk_elements.insert(vk_elements.end(), frs.begin(), frs.end());
        };
 
        // Tag and serialize VK metadata
        append_tagged(this->log_circuit_size);
        append_tagged(this->num_public_inputs);
        append_tagged(this->pub_inputs_offset);
 
        // Tag and serialize VK commitments
        for (const Commitment& commitment : this->get_all()) {
            append_tagged(commitment);
        }
 
        // Sanitize free witness tags before hashing
        bb::unset_free_witness_tags<in_circuit, FF>(vk_elements);
 
        // Hash the tagged elements directly
        return stdlib::poseidon2<Builder>::hash(vk_elements);
    }
 
    template <typename Transcript> FF hash_with_origin_tagging(const Transcript& transcript) const
    {
        const OriginTag tag = bb::extract_transcript_tag(transcript);
        return hash_with_origin_tagging(tag);
    }
};
 
template <typename FF, typename VerificationKey> class VKAndHash_ {
  public:
    template <typename T = VerificationKey>
    using Builder = typename std::enable_if_t<requires { typename T::Builder; }, T>::Builder;
 
    template <typename T = VerificationKey>
    using NativeVerificationKey =
        typename std::enable_if_t<requires { typename T::NativeVerificationKey; }, T>::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)
    {}
 
    template <typename VK = VerificationKey,
              typename B = typename VK::Builder,
              typename NVK = typename VK::NativeVerificationKey>
    VKAndHash_(B& builder, const std::shared_ptr<NVK>& 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;
};
 
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_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 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 ECCVMFlavor;
class UltraKeccakFlavor;
#ifdef STARKNET_GARAGA_FLAVORS
class UltraStarknetFlavor;
class UltraStarknetZKFlavor;
#endif
class UltraKeccakZKFlavor;
class MegaFlavor;
class MegaZKFlavor;
class MegaAvmFlavor;
class TranslatorFlavor;
class ECCVMRecursiveFlavor;
class TranslatorRecursiveFlavor;
class AvmRecursiveFlavor;
class MultilinearBatchingRecursiveFlavor;
 
template <typename BuilderType> class UltraRecursiveFlavor_;
template <typename BuilderType> class UltraZKRecursiveFlavor_;
template <typename BuilderType> class MegaRecursiveFlavor_;
template <typename BuilderType> class MegaZKRecursiveFlavor_;
template <typename BuilderType> class MegaAvmRecursiveFlavor_;
 
// Serialization methods for NativeVerificationKey_.
// These should cover all base classes that do not need additional members, as long as the appropriate SerializeMetadata
// is set in the template parameters.
template <typename PrecomputedCommitments,
          typename Codec,
          typename HashFunction,
          typename CommitmentKey,
          VKSerializationMode SerializeMetadata>
inline void read(
    uint8_t const*& it,
    NativeVerificationKey_<PrecomputedCommitments, Codec, HashFunction, CommitmentKey, SerializeMetadata>& vk)
{
    using serialize::read;
    using VK = NativeVerificationKey_<PrecomputedCommitments, Codec, HashFunction, CommitmentKey, SerializeMetadata>;
 
    // Get the size directly from the static method
    size_t num_frs = VK::calc_num_data_types();
 
    // Read exactly num_frs field elements from the buffer
    std::vector<typename Codec::DataType> field_elements(num_frs);
    for (auto& element : field_elements) {
        read(it, element);
    }
    // Then use from_field_elements to populate the verification key
    vk.from_field_elements(field_elements);
}
 
template <typename PrecomputedCommitments,
          typename Codec,
          typename HashFunction,
          typename CommitmentKey,
          VKSerializationMode SerializeMetadata>
inline void write(
    std::vector<uint8_t>& buf,
    NativeVerificationKey_<PrecomputedCommitments, Codec, HashFunction, CommitmentKey, SerializeMetadata> const& vk)
{
    using serialize::write;
    using VK = NativeVerificationKey_<PrecomputedCommitments, Codec, HashFunction, CommitmentKey, SerializeMetadata>;
 
    size_t before = buf.size();
    // Convert to field elements and write them directly without length prefix
    auto field_elements = vk.to_field_elements();
    for (const auto& element : field_elements) {
        write(buf, element);
    }
    size_t after = buf.size();
    size_t num_frs = VK::calc_num_data_types();
    BB_ASSERT_EQ(after - before, num_frs * sizeof(bb::fr), "VK serialization mismatch");
}
 
namespace avm2 {
class AvmRecursiveFlavor;
}
 
} // namespace bb