field_conversion.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/polynomials/univariate.hpp"
#include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
#include "barretenberg/stdlib/primitives/bigfield/goblin_field.hpp"
#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
#include "barretenberg/stdlib/primitives/field/field_utils.hpp"
#include "barretenberg/stdlib/primitives/group/cycle_group.hpp"
 
namespace bb::stdlib {
 
template <typename Field> class StdlibCodec {
  public:
    using DataType = Field;
    using Builder = typename Field::Builder;
    using fr = field_t<Builder>;
    using fq = bigfield<Builder, bb::Bn254FqParams>;
    using bn254_element = element<Builder, fq, fr, curve::BN254::Group>;
    using grumpkin_element = cycle_group<Builder>;
 
    template <typename T> static bool_t<Builder> check_point_at_infinity(std::span<const fr> fr_vec)
    {
        if constexpr (IsAnyOf<T, bn254_element>) {
            // Sum the limbs and check whether the sum is 0
            return (fr::accumulate(std::vector<fr>(fr_vec.begin(), fr_vec.end())).is_zero());
        } else {
            // Efficiently compute ((x^2 + 5 y^2) == 0)
            const fr x_sqr = fr_vec[0].sqr();
            const fr y = fr_vec[1];
            const fr five_y = y * bb::fr(5);
            return (y.madd(five_y, x_sqr).is_zero());
        }
    }
 
    template <typename T> static T convert_challenge(const fr& challenge)
    {
        if constexpr (std::is_same_v<T, fr>) {
            return challenge;
        } else if constexpr (std::is_same_v<T, fq>) {
            // Sanity check that the input challenge fits into the first 2 bigfield limbs.
            BB_ASSERT_LT(static_cast<uint256_t>(challenge.get_value()).get_msb(),
                         T::NUM_LIMB_BITS * 2,
                         "field_conversion: convert_challenge");
            Builder* builder = challenge.get_context();
            // All challenges must be circuit witnesses.
            ASSERT(builder);
            ASSERT(!challenge.is_constant());
            return T(challenge, fr::from_witness_index(builder, builder->zero_idx()));
        }
    }
 
    static std::vector<fr> convert_goblin_fr_to_bn254_frs(const goblin_field<Builder>& input)
    {
        return { input.limbs[0], input.limbs[1] };
    }
 
    static std::vector<fr> convert_grumpkin_fr_to_bn254_frs(const fq& input)
    {
        static constexpr uint64_t NUM_LIMB_BITS = fq::NUM_LIMB_BITS;
 
        static constexpr bb::fr shift(static_cast<uint256_t>(1) << NUM_LIMB_BITS);
        std::vector<fr> result(2);
        result[0] = input.binary_basis_limbs[0].element + (input.binary_basis_limbs[1].element * shift);
        result[1] = input.binary_basis_limbs[2].element + (input.binary_basis_limbs[3].element * shift);
        return result;
    }
 
    template <typename T> static constexpr size_t calc_num_fields()
    {
        if constexpr (IsAnyOf<T, fr>) {
            return Bn254FrParams::NUM_BN254_SCALARS;
        } else if constexpr (IsAnyOf<T, fq, goblin_field<Builder>>) {
            return Bn254FqParams::NUM_BN254_SCALARS;
        } else if constexpr (IsAnyOf<T, bn254_element, grumpkin_element>) {
            return 2 * calc_num_fields<typename T::BaseField>();
        } else {
            // Array or Univariate
            return calc_num_fields<typename T::value_type>() * (std::tuple_size<T>::value);
        }
    }
 
    template <typename T> static T deserialize_from_fields(std::span<const fr> fr_vec)
    {
        using field_ct = fr;
        using bigfield_ct = fq;
 
        constexpr size_t expected_size = calc_num_fields<T>();
        BB_ASSERT_EQ(fr_vec.size(), expected_size);
 
        ASSERT(validate_context<Builder>(fr_vec));
 
        if constexpr (IsAnyOf<T, field_ct>) {
            // Case 1: input type matches the output type
            return fr_vec[0];
        } else if constexpr (IsAnyOf<T, bigfield_ct, goblin_field<Builder>>) {
            // Cases 2 and 3: a bigfield/goblin_field element is reconstructed from low and high limbs.
            return T(fr_vec[0], fr_vec[1]);
        } else if constexpr (IsAnyOf<T, bn254_element, grumpkin_element>) {
            // Case 4 and 5: Convert a vector of frs to a group element
            using Basefield = typename T::BaseField;
 
            constexpr size_t base_field_frs = expected_size / 2;
 
            Basefield x = deserialize_from_fields<Basefield>(fr_vec.subspan(0, base_field_frs));
            Basefield y = deserialize_from_fields<Basefield>(fr_vec.subspan(base_field_frs, base_field_frs));
 
            T out(x, y, check_point_at_infinity<T>(fr_vec));
            // Note that in the case of bn254 with Mega arithmetization, the check is delegated to ECCVM, see
            // `on_curve_check` in `ECCVMTranscriptRelationImpl`.
            out.validate_on_curve();
            return out;
        } else {
            // Case 6: Array or Univariate
            T val;
            using element_type = typename T::value_type;
            const size_t scalar_frs = calc_num_fields<element_type>();
 
            size_t i = 0;
            for (auto& x : val) {
                x = deserialize_from_fields<element_type>(fr_vec.subspan(scalar_frs * i, scalar_frs));
                ++i;
            }
            return val;
        }
    }
 
    template <typename T> static std::vector<fr> serialize_to_fields(const T& val)
    {
        using field_ct = fr;
        using bigfield_ct = fq;
 
        if constexpr (IsAnyOf<T, field_ct>) {
            return std::vector<T>{ val };
        } else if constexpr (IsAnyOf<T, bigfield_ct>) {
            return convert_grumpkin_fr_to_bn254_frs(val);
        } else if constexpr (IsAnyOf<T, goblin_field<Builder>>) {
            return convert_goblin_fr_to_bn254_frs(val);
        } else if constexpr (IsAnyOf<T, bn254_element, grumpkin_element>) {
            using BaseField = typename T::BaseField;
 
            std::vector<field_ct> fr_vec_x = serialize_to_fields<BaseField>(val.x);
            std::vector<field_ct> fr_vec_y = serialize_to_fields<BaseField>(val.y);
            std::vector<field_ct> fr_vec(fr_vec_x.begin(), fr_vec_x.end());
            fr_vec.insert(fr_vec.end(), fr_vec_y.begin(), fr_vec_y.end());
            return fr_vec;
        } else {
            // Array or Univariate
            std::vector<field_ct> fr_vec;
            for (auto& x : val) {
                auto tmp_vec = serialize_to_fields<typename T::value_type>(x);
                fr_vec.insert(fr_vec.end(), tmp_vec.begin(), tmp_vec.end());
            }
            return fr_vec;
        }
    }
    static std::array<fr, 2> split_challenge(const fr& challenge)
    {
        const size_t lo_bits = fr::native::Params::MAX_BITS_PER_ENDOMORPHISM_SCALAR;
        // Constuct a unique lo/hi decomposition of the challenge (hi_bits will be 254 - 128 = 126)
        const auto [lo, hi] = split_unique(challenge, lo_bits);
        return std::array<fr, 2>{ lo, hi };
    }
 
    template <typename TargetType> static TargetType deserialize_from_frs(std::span<fr> elements, size_t& num_frs_read)
    {
        constexpr size_t num_frs = calc_num_fields<TargetType>();
        BB_ASSERT_GTE(elements.size(), num_frs_read + num_frs);
        TargetType result = deserialize_from_fields<TargetType>(elements.subspan(num_frs_read, num_frs));
        num_frs_read += num_frs;
        return result;
    }
};
} // namespace bb::stdlib