cycle_scalar.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/stdlib/primitives/bigfield/bigfield.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
#include "barretenberg/transcript/origin_tag.hpp"
 
namespace bb::stdlib {
 
// Forward declaration
template <typename Builder> class cycle_group;
 
template <typename Builder> class cycle_scalar {
  public:
    using field_t = stdlib::field_t<Builder>;
    using Curve = typename Builder::EmbeddedCurve;
    using ScalarField = typename Curve::ScalarField;
    using BigScalarField = stdlib::bigfield<Builder, typename ScalarField::Params>;
 
    static constexpr size_t NUM_BITS = ScalarField::modulus.get_msb() + 1; // equivalent for both bn254 and grumpkin
    static constexpr size_t LO_BITS = field_t::native::Params::MAX_BITS_PER_ENDOMORPHISM_SCALAR;
    static constexpr size_t HI_BITS = NUM_BITS - LO_BITS;
 
    // Enforce the architectural constraint that cycle_scalar is hardcoded for 254-bit scalars
    static_assert(NUM_BITS == 254);
    static_assert(LO_BITS == 128 && HI_BITS == 126);
 
    enum class SkipValidation { FLAG };
 
  private:
    field_t _lo; // LO_BITS of the scalar
    field_t _hi; // Remaining HI_BITS of the scalar
 
    static std::pair<uint256_t, uint256_t> decompose_into_lo_hi_u256(const uint256_t& value)
    {
        return { value.slice(0, LO_BITS), value.slice(LO_BITS, NUM_BITS) };
    }
 
    cycle_scalar(const field_t& lo, const field_t& hi, SkipValidation flag);
 
    void validate_scalar_is_in_field() const;
 
  public:
    cycle_scalar(const ScalarField& in = 0);
    cycle_scalar(const field_t& lo, const field_t& hi);
    static cycle_scalar from_witness(Builder* context, const ScalarField& value);
    explicit cycle_scalar(BigScalarField& scalar);
 
    [[nodiscard]] bool is_constant() const;
    ScalarField get_value() const;
    Builder* get_context() const { return _lo.get_context() != nullptr ? _lo.get_context() : _hi.get_context(); }
 
    const field_t& lo() const { return _lo; }
    const field_t& hi() const { return _hi; }
 
    OriginTag get_origin_tag() const { return OriginTag(_lo.get_origin_tag(), _hi.get_origin_tag()); }
    void set_origin_tag(const OriginTag& tag)
    {
        _lo.set_origin_tag(tag);
        _hi.set_origin_tag(tag);
    }
    void set_free_witness_tag()
    {
        _lo.set_free_witness_tag();
        _hi.set_free_witness_tag();
    }
    void unset_free_witness_tag()
    {
        _lo.unset_free_witness_tag();
        _hi.unset_free_witness_tag();
    }
};
 
} // namespace bb::stdlib