Step 1: Convert Number to use 128-bit numbers internally

- Update the conversion points between Number and *Amount & STNumber.
- Tests probably don't pass.

include/xrpl/basics/Number.h

@@ -1,8 +1,13 @@
 #ifndef XRPL_BASICS_NUMBER_H_INCLUDED
 #define XRPL_BASICS_NUMBER_H_INCLUDED
 
+#ifdef _MSC_VER
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
 #include <cstdint>
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <string>
 
@@ -13,21 +18,66 @@ class Number;
 std::string
 to_string(Number const& amount);
 
+template <typename T>
+constexpr std::optional<int>
+logTen(T value)
+{
+    int power = 0;
+    while (value >= 10 && value % 10 == 0)
+    {
+        value /= 10;
+        ++power;
+    }
+    if (value == 1)
+        return power;
+    return std::nullopt;
+}
+
+template <typename T>
+constexpr bool
+isPowerOfTen(T value)
+{
+    return logTen(value).has_value();
+}
+
+#ifdef _MSC_VER
+using numberuint128 = boost::multiprecision::uint128_t;
+using numberint128 = boost::multiprecision::int128_t;
+#else   // !defined(_MSC_VER)
+using numberuint128 = __uint128_t;
+using numberint128 = __int128_t;
+#endif  // !defined(_MSC_VER)
+
+struct MantissaRange
+{
+    using rep = numberint128;
+
+    explicit constexpr MantissaRange(rep min_)
+        : min(min_), max(min_ * 10 - 1), power(logTen(min).value_or(-1))
+    {
+    }
+
+    rep min;
+    rep max;
+    int power;
+};
+
 class Number
 {
+    using uint128_t = numberuint128;
+    using int128_t = numberint128;
+
     using rep = std::int64_t;
-    rep mantissa_{0};
+    using internalrep = MantissaRange::rep;
+    internalrep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
 
 public:
-    // The range for the mantissa when normalized
-    constexpr static std::int64_t minMantissa = 1'000'000'000'000'000LL;
-    constexpr static std::int64_t maxMantissa = 9'999'999'999'999'999LL;
-
     // The range for the exponent when normalized
     constexpr static int minExponent = -32768;
     constexpr static int maxExponent = 32768;
 
+    // May need to make unchecked private
     struct unchecked
     {
         explicit unchecked() = default;
@@ -37,9 +87,12 @@ public:
 
     Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
-    explicit constexpr Number(rep mantissa, int exponent, unchecked) noexcept;
+    explicit constexpr Number(
+        internalrep mantissa,
+        int exponent,
+        unchecked) noexcept;
 
-    constexpr rep
+    constexpr internalrep
     mantissa() const noexcept;
     constexpr int
     exponent() const noexcept;
@@ -68,11 +121,11 @@ public:
     operator/=(Number const& x);
 
     static constexpr Number
-    min() noexcept;
+    min(MantissaRange const& range) noexcept;
     static constexpr Number
-    max() noexcept;
+    max(MantissaRange const& range) noexcept;
     static constexpr Number
-    lowest() noexcept;
+    lowest(MantissaRange const& range) noexcept;
 
     /** Conversions to Number are implicit and conversions away from Number
      *  are explicit. This design encourages and facilitates the use of Number
@@ -181,18 +234,86 @@ public:
     static rounding_mode
     setround(rounding_mode mode);
 
+    static void
+    setLargeMantissa(bool large);
+
+    inline static internalrep
+    minMantissa()
+    {
+        return range_.get().min;
+    }
+
+    inline static internalrep
+    maxMantissa()
+    {
+        return range_.get().max;
+    }
+
+    inline static internalrep
+    mantissaPower()
+    {
+        return range_.get().power;
+    }
+
+    constexpr static Number
+    oneSmall();
+    constexpr static Number
+    oneLarge();
+
+    static Number
+    one();
+
+    template <class T>
+    [[nodiscard]]
+    std::pair<T, int>
+    normalizeToRange(T minMantissa, T maxMantissa) const;
+
 private:
     static thread_local rounding_mode mode_;
+    // The available ranges for mantissa
+
+    constexpr static MantissaRange smallRange{1'000'000'000'000'000LL};
+    static_assert(isPowerOfTen(smallRange.min));
+    static_assert(smallRange.max == 9'999'999'999'999'999LL);
+    // maxint64                               9,223,372,036,854,775,808
+    constexpr static MantissaRange largeRange{1'000'000'000'000'000'000LL};
+    static_assert(isPowerOfTen(largeRange.min));
+    static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
+    static_assert(largeRange.min < std::numeric_limits<std::int64_t>::max());
+    static_assert(largeRange.max > std::numeric_limits<std::int64_t>::max());
+
+    // The range for the mantissa when normalized.
+    // Use reference_wrapper to avoid making copies, and prevent accidentally
+    // changing the values inside the range.
+    static thread_local std::reference_wrapper<MantissaRange const> range_;
 
     void
     normalize();
+
+    static void
+    normalize(
+        internalrep& mantissa,
+        int& exponent,
+        internalrep const& minMantissa,
+        internalrep const& maxMantissa);
+
     constexpr bool
-    isnormal() const noexcept;
+    isnormal(MantissaRange const& range) const noexcept;
+
+    explicit Number(internalrep mantissa, int exponent);
+
+    friend Number
+    root(Number f, unsigned d);
+    friend Number
+    root2(Number f);
 
     class Guard;
 };
 
-inline constexpr Number::Number(rep mantissa, int exponent, unchecked) noexcept
+inline constexpr Number::Number(
+    internalrep mantissa,
+    int exponent,
+    unchecked) noexcept
     : mantissa_{mantissa}, exponent_{exponent}
 {
 }
@@ -203,11 +324,17 @@ inline Number::Number(rep mantissa, int exponent)
     normalize();
 }
 
+inline Number::Number(internalrep mantissa, int exponent)
+    : mantissa_{mantissa}, exponent_{exponent}
+{
+    normalize();
+}
+
 inline Number::Number(rep mantissa) : Number{mantissa, 0}
 {
 }
 
-inline constexpr Number::rep
+inline constexpr Number::internalrep
 Number::mantissa() const noexcept
 {
     return mantissa_;
@@ -302,31 +429,42 @@ operator/(Number const& x, Number const& y)
 }
 
 inline constexpr Number
-Number::min() noexcept
+Number::min(MantissaRange const& range) noexcept
 {
-    return Number{minMantissa, minExponent, unchecked{}};
+    return Number{range.min, minExponent, unchecked{}};
 }
 
 inline constexpr Number
-Number::max() noexcept
+Number::max(MantissaRange const& range) noexcept
 {
-    return Number{maxMantissa, maxExponent, unchecked{}};
+    return Number{range.max, maxExponent, unchecked{}};
 }
 
 inline constexpr Number
-Number::lowest() noexcept
+Number::lowest(MantissaRange const& range) noexcept
 {
-    return -Number{maxMantissa, maxExponent, unchecked{}};
+    return -Number{range.max, maxExponent, unchecked{}};
 }
 
 inline constexpr bool
-Number::isnormal() const noexcept
+Number::isnormal(MantissaRange const& range) const noexcept
 {
     auto const abs_m = mantissa_ < 0 ? -mantissa_ : mantissa_;
-    return minMantissa <= abs_m && abs_m <= maxMantissa &&
+    return range.min <= abs_m && abs_m <= range.max &&
         minExponent <= exponent_ && exponent_ <= maxExponent;
 }
 
+template <class T>
+std::pair<T, int>
+Number::normalizeToRange(T minMantissa, T maxMantissa) const
+{
+    internalrep mantissa = mantissa_;
+    int exponent = exponent_;
+    Number::normalize(mantissa, exponent, minMantissa, maxMantissa);
+
+    return std::make_pair(static_cast<T>(mantissa), exponent);
+}
+
 inline constexpr Number
 abs(Number x) noexcept
 {

include/xrpl/protocol/AmountConversions.h

@@ -122,7 +122,7 @@ toAmount(
     {
         if (isXRP(issue))
             return STAmount(issue, static_cast<std::int64_t>(n));
-        return STAmount(issue, n.mantissa(), n.exponent());
+        return STAmount(issue, n);
     }
     else
     {

include/xrpl/protocol/Asset.h

@@ -84,6 +84,12 @@ public:
         return holds<Issue>() && get<Issue>().native();
     }
 
+    bool
+    integral() const
+    {
+        return !holds<Issue>() || get<Issue>().native();
+    }
+
     friend constexpr bool
     operator==(Asset const& lhs, Asset const& rhs);
 

include/xrpl/protocol/IOUAmount.h

@@ -26,8 +26,10 @@ class IOUAmount : private boost::totally_ordered<IOUAmount>,
                   private boost::additive<IOUAmount>
 {
 private:
-    std::int64_t mantissa_;
-    int exponent_;
+    using mantissa_type = std::int64_t;
+    using exponent_type = int;
+    mantissa_type mantissa_;
+    exponent_type exponent_;
 
     /** Adjusts the mantissa and exponent to the proper range.
 
@@ -38,11 +40,19 @@ private:
     void
     normalize();
 
+    IOUAmount(std::pair<mantissa_type, exponent_type> parts)
+        : IOUAmount(parts.first, parts.second)
+    {
+    }
+
+    static std::pair<mantissa_type, exponent_type>
+    scaleNumber(Number const& number);
+
 public:
     IOUAmount() = default;
     explicit IOUAmount(Number const& other);
     IOUAmount(beast::Zero);
-    IOUAmount(std::int64_t mantissa, int exponent);
+    IOUAmount(mantissa_type mantissa, exponent_type exponent);
 
     IOUAmount& operator=(beast::Zero);
 
@@ -71,10 +81,10 @@ public:
     int
     signum() const noexcept;
 
-    int
+    exponent_type
     exponent() const noexcept;
 
-    std::int64_t
+    mantissa_type
     mantissa() const noexcept;
 
     static IOUAmount
@@ -92,7 +102,7 @@ inline IOUAmount::IOUAmount(beast::Zero)
     *this = beast::zero;
 }
 
-inline IOUAmount::IOUAmount(std::int64_t mantissa, int exponent)
+inline IOUAmount::IOUAmount(mantissa_type mantissa, exponent_type exponent)
     : mantissa_(mantissa), exponent_(exponent)
 {
     normalize();
@@ -149,13 +159,13 @@ IOUAmount::signum() const noexcept
     return (mantissa_ < 0) ? -1 : (mantissa_ ? 1 : 0);
 }
 
-inline int
+inline IOUAmount::exponent_type
 IOUAmount::exponent() const noexcept
 {
     return exponent_;
 }
 
-inline std::int64_t
+inline IOUAmount::mantissa_type
 IOUAmount::mantissa() const noexcept
 {
     return mantissa_;

include/xrpl/protocol/Issue.h

@@ -37,6 +37,9 @@ public:
     bool
     native() const;
 
+    bool
+    integral() const;
+
     friend constexpr std::weak_ordering
     operator<=>(Issue const& lhs, Issue const& rhs);
 };

include/xrpl/protocol/MPTIssue.h

@@ -46,6 +46,12 @@ public:
     {
         return false;
     }
+
+    bool
+    integral() const
+    {
+        return true;
+    }
 };
 
 constexpr bool

include/xrpl/protocol/STAmount.h

@@ -47,9 +47,11 @@ public:
     static int const cMaxOffset = 80;
 
     // Maximum native value supported by the code
-    static std::uint64_t const cMinValue = 1000000000000000ull;
-    static std::uint64_t const cMaxValue = 9999999999999999ull;
-    static std::uint64_t const cMaxNative = 9000000000000000000ull;
+    constexpr static std::uint64_t cMinValue = 1'000'000'000'000'000ull;
+    static_assert(isPowerOfTen(cMinValue));
+    constexpr static std::uint64_t cMaxValue = cMinValue * 10 - 1;
+    static_assert(cMaxValue == 9'999'999'999'999'999ull);
+    static std::uint64_t const cMaxNative = 9'000'000'000'000'000'000ull;
 
     // Max native value on network.
     static std::uint64_t const cMaxNativeN = 100000000000000000ull;
@@ -136,7 +138,7 @@ public:
 
     template <AssetType A>
     STAmount(A const& asset, Number const& number)
-        : STAmount(asset, number.mantissa(), number.exponent())
+        : STAmount(asset, scaleNumber(asset, number))
     {
     }
 
@@ -155,6 +157,9 @@ public:
     int
     exponent() const noexcept;
 
+    bool
+    integral() const noexcept;
+
     bool
     native() const noexcept;
 
@@ -277,6 +282,22 @@ public:
     mpt() const;
 
 private:
+    template <AssetType A>
+    STAmount(
+        A const& asset,
+        std::tuple<mantissa_type, exponent_type, bool> parts)
+        : STAmount(
+              asset,
+              std::get<mantissa_type>(parts),
+              std::get<exponent_type>(parts),
+              std::get<bool>(parts))
+    {
+    }
+
+    template <AssetType A>
+    static std::tuple<mantissa_type, exponent_type, bool>
+    scaleNumber(A const& asset, Number const& number);
+
     static std::unique_ptr<STAmount>
     construct(SerialIter&, SField const& name);
 
@@ -435,6 +456,12 @@ STAmount::exponent() const noexcept
     return mOffset;
 }
 
+inline bool
+STAmount::integral() const noexcept
+{
+    return mAsset.integral();
+}
+
 inline bool
 STAmount::native() const noexcept
 {
@@ -531,12 +558,29 @@ STAmount::operator=(XRPAmount const& amount)
     return *this;
 }
 
+template <AssetType A>
+inline std::tuple<STAmount::mantissa_type, STAmount::exponent_type, bool>
+STAmount::scaleNumber(A const& asset, Number const& number)
+{
+    bool const negative = number.mantissa() < 0;
+    if (asset.integral())
+    {
+        return std::make_tuple(std::int64_t(number), 0, negative);
+    }
+    else
+    {
+        Number const working{negative ? -number : number};
+        auto const [mantissa, exponent] =
+            working.normalizeToRange(cMinValue, cMaxValue);
+
+        return std::make_tuple(mantissa, exponent, negative);
+    }
+}
+
 inline STAmount&
 STAmount::operator=(Number const& number)
 {
-    mIsNegative = number.mantissa() < 0;
-    mValue = mIsNegative ? -number.mantissa() : number.mantissa();
-    mOffset = number.exponent();
+    std::tie(mValue, mOffset, mIsNegative) = scaleNumber(mAsset, number);
     canonicalize();
     return *this;
 }
@@ -553,7 +597,7 @@ STAmount::clear()
 {
     // The -100 is used to allow 0 to sort less than a small positive values
     // which have a negative exponent.
-    mOffset = native() ? 0 : -100;
+    mOffset = integral() ? 0 : -100;
     mValue = 0;
     mIsNegative = false;
 }

include/xrpl/protocol/STObject.h

@@ -482,6 +482,8 @@ public:
     value_type
     operator*() const;
 
+    /// Do not use operator->() unless the field is required, or you've checked
+    /// that it's set.
     T const*
     operator->() const;
 
@@ -718,6 +720,8 @@ STObject::Proxy<T>::operator*() const -> value_type
     return this->value();
 }
 
+/// Do not use operator->() unless the field is required, or you've checked that
+/// it's set.
 template <class T>
 T const*
 STObject::Proxy<T>::operator->() const

include/xrpl/protocol/SystemParameters.h

@@ -23,6 +23,7 @@ systemName()
 
 /** Number of drops in the genesis account. */
 constexpr XRPAmount INITIAL_XRP{100'000'000'000 * DROPS_PER_XRP};
+static_assert(INITIAL_XRP.drops() == 100'000'000'000'000'000);
 
 /** Returns true if the amount does not exceed the initial XRP in existence. */
 inline bool

include/xrpl/protocol/detail/ledger_entries.macro

@@ -479,10 +479,10 @@ LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
     {sfAccount,              soeREQUIRED},
     {sfData,                 soeOPTIONAL},
     {sfAsset,                soeREQUIRED},
-    {sfAssetsTotal,          soeREQUIRED},
-    {sfAssetsAvailable,      soeREQUIRED},
+    {sfAssetsTotal,          soeDEFAULT},
+    {sfAssetsAvailable,      soeDEFAULT},
     {sfAssetsMaximum,        soeDEFAULT},
-    {sfLossUnrealized,       soeREQUIRED},
+    {sfLossUnrealized,       soeDEFAULT},
     {sfShareMPTID,           soeREQUIRED},
     {sfWithdrawalPolicy,     soeREQUIRED},
     {sfScale,                soeDEFAULT},