fixed_base.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 "../types.hpp"
#include "./fixed_base_params.hpp"
#include "barretenberg/crypto/generators/generator_data.hpp"
#include "barretenberg/crypto/pedersen_hash/pedersen.hpp"
#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
#include "barretenberg/ecc/groups/precomputed_generators_grumpkin_impl.hpp"
 
namespace bb::plookup::fixed_base {
 
class table : public FixedBaseParams {
  public:
    using affine_element = grumpkin::g1::affine_element;
    using element = grumpkin::g1::element;
    using single_lookup_table = std::vector<affine_element>;
    using fixed_base_scalar_mul_tables = std::vector<single_lookup_table>;
    using all_multi_tables = std::array<fixed_base_scalar_mul_tables, NUM_FIXED_BASE_MULTI_TABLES>;
 
    static constexpr affine_element lhs_generator_point()
    {
        return crypto::generator_data<curve::Grumpkin>::precomputed_generators[0];
    }
    static constexpr affine_element rhs_generator_point()
    {
        return crypto::generator_data<curve::Grumpkin>::precomputed_generators[1];
    }
 
    inline static single_lookup_table generate_single_lookup_table(const affine_element& base_point,
                                                                   const affine_element& offset_generator);
    template <size_t num_bits> static fixed_base_scalar_mul_tables generate_tables(const affine_element& input);
 
    template <size_t num_table_bits> static affine_element generate_generator_offset(const affine_element& input);
 
    static constexpr uint256_t MAX_LO_SCALAR = uint256_t(1) << BITS_PER_LO_SCALAR;
    // We split each scalar mulitplier into BITS_PER_LO_SCALAR, BITS_PER_HI_SCALAR chunks and perform 2 scalar muls of
    // size BITS_PER_LO_SCALAR, BITS_PER_HI_SCALAR (see fixed_base_params.hpp for more details)
    // i.e. we treat 1 scalar mul as two independent scalar muls over (roughly) half-width input scalars.
    // The base_point members describe the fixed-base points that correspond to the two independent scalar muls,
    // for our two supported points
    static affine_element lhs_base_point_lo() { return lhs_generator_point(); };
    static affine_element lhs_base_point_hi()
    {
        static auto constant = element(lhs_base_point_lo()) * MAX_LO_SCALAR;
        return constant;
    };
    static affine_element rhs_base_point_lo() { return rhs_generator_point(); };
    static affine_element rhs_base_point_hi()
    {
        static auto constant = element(rhs_base_point_lo()) * MAX_LO_SCALAR;
        return constant;
    };
 
    // fixed_base_tables = lookup tables of precomputed base points required for our lookup arguments.
    // N.B. these "tables" are not plookup tables, just regular ol' software lookup tables.
    // Used to build the proper plookup table and in the `BasicTable::get_values_from_key` method
    static const all_multi_tables& fixed_base_tables();
 
    static const std::array<affine_element, table::NUM_FIXED_BASE_MULTI_TABLES>& fixed_base_table_offset_generators();
 
    static bool lookup_table_exists_for_point(const affine_element& input);
    static std::optional<std::array<MultiTableId, 2>> get_lookup_table_ids_for_point(const affine_element& input);
    static std::optional<affine_element> get_generator_offset_for_table_id(MultiTableId table_id);
 
    template <size_t multitable_index>
    static BasicTable generate_basic_fixed_base_table(BasicTableId id, size_t basic_table_index, size_t table_index);
    template <size_t multitable_index, size_t num_bits> static MultiTable get_fixed_base_table(MultiTableId id);
 
    template <size_t multitable_index, size_t table_index>
    static std::array<bb::fr, 2> get_basic_fixed_base_table_values(const std::array<uint64_t, 2> key)
    {
        static_assert(multitable_index < NUM_FIXED_BASE_MULTI_TABLES);
        static_assert(table_index < get_num_bits_of_multi_table<multitable_index>());
        const auto& basic_table = fixed_base_tables()[multitable_index][table_index];
        const auto index = static_cast<size_t>(key[0]);
        return { basic_table[index].x, basic_table[index].y };
    }
};
 
} // namespace bb::plookup::fixed_base