utils.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Completed, auditors: [Federico], commit: d4aff8893338c31425565db5a5a560048c33f27a}
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/dsl/acir_format/acir_format.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
#include <vector>
 
namespace acir_format {
 
using namespace bb;
using namespace bb::stdlib;
 
 
 
template <typename Builder>
std::vector<field_t<Builder>> fields_from_witnesses(Builder& builder, std::span<const uint32_t> witness_indices);
 
template <typename Builder>
byte_array<Builder> fields_to_bytes(Builder& builder, std::vector<field_t<Builder>>& fields);
 
std::vector<uint32_t> add_public_inputs_to_proof(const std::vector<uint32_t>& proof_in,
                                                 const std::vector<uint32_t>& public_inputs);
 
 
 
RecursionConstraint recursion_data_to_recursion_constraint(std::vector<bb::fr>& witness,
                                                           const std::vector<bb::fr>& proof,
                                                           const std::vector<bb::fr>& key,
                                                           const bb::fr& key_hash,
                                                           const bb::fr& predicate,
                                                           const size_t num_public_inputs_to_extract,
                                                           const uint32_t proof_type);
 
template <typename T>
std::vector<uint32_t> add_to_witness_and_track_indices(std::vector<bb::fr>& witness, const T& input)
{
    std::vector<uint32_t> indices;
 
    if constexpr (std::is_same_v<T, bb::grumpkin::g1::affine_element>) {
        indices.emplace_back(witness.size());
        witness.emplace_back(input.x);
        indices.emplace_back(witness.size());
        witness.emplace_back(input.y);
    } else if constexpr (requires {
                             input.data();
                             input.size();
                         }) {
        // T is a span or span-like container of values
        indices.reserve(input.size());
        auto witness_idx = static_cast<uint32_t>(witness.size());
        for (const auto& value : input) {
            witness.push_back(bb::fr(value));
            indices.push_back(witness_idx++);
        }
    } else {
        bb::assert_failure("Unsupported type for add_to_witness_and_track_indices");
    }
 
    return indices;
}
 
inline uint32_t add_to_witness_and_track_indices(std::vector<bb::fr>& witness, const bb::fr& input)
{
    uint32_t index = static_cast<uint32_t>(witness.size());
    witness.emplace_back(input);
 
    return index;
}
 
template <typename T, size_t N>
std::array<uint32_t, N> add_to_witness_and_track_indices(std::vector<bb::fr>& witness, const T& input)
{
    std::vector<uint32_t> tracked_indices = add_to_witness_and_track_indices(witness, input);
    BB_ASSERT_LTE(tracked_indices.size(), N, "Number of witnesses added is greater than the size of the output array.");
 
    std::array<uint32_t, N> indices{}; // Initialization needed for GCC
    std::ranges::copy(tracked_indices, indices.begin());
    return indices;
}
 
 
 
template <typename Builder>
void populate_fields(Builder& builder, const std::vector<field_t<Builder>>& fields, const std::vector<bb::fr>& values);
 
} // namespace acir_format