Introduce MPT support (XLS-33d):

Builds/levelization/results/loops.txt

@@ -5,7 +5,7 @@ Loop: test.jtx test.unit_test
   test.unit_test == test.jtx
 
 Loop: xrpl.basics xrpl.json
-  xrpl.json ~= xrpl.basics
+  xrpl.json == xrpl.basics
 
 Loop: xrpld.app xrpld.core
   xrpld.app > xrpld.core

include/xrpl/basics/MPTAmount.h

@@ -0,0 +1,166 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2024 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_BASICS_MPTAMOUNT_H_INCLUDED
+#define RIPPLE_BASICS_MPTAMOUNT_H_INCLUDED
+
+#include <xrpl/basics/contract.h>
+#include <xrpl/basics/safe_cast.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/json/json_value.h>
+
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/operators.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <type_traits>
+
+namespace ripple {
+
+class MPTAmount : private boost::totally_ordered<MPTAmount>,
+                  private boost::additive<MPTAmount>,
+                  private boost::equality_comparable<MPTAmount, std::int64_t>,
+                  private boost::additive<MPTAmount, std::int64_t>
+{
+public:
+    using value_type = std::int64_t;
+
+protected:
+    value_type value_;
+
+public:
+    MPTAmount() = default;
+    constexpr MPTAmount(MPTAmount const& other) = default;
+    constexpr MPTAmount&
+    operator=(MPTAmount const& other) = default;
+
+    constexpr explicit MPTAmount(value_type value);
+
+    constexpr MPTAmount& operator=(beast::Zero);
+
+    MPTAmount&
+    operator+=(MPTAmount const& other);
+
+    MPTAmount&
+    operator-=(MPTAmount const& other);
+
+    MPTAmount
+    operator-() const;
+
+    bool
+    operator==(MPTAmount const& other) const;
+
+    bool
+    operator==(value_type other) const;
+
+    bool
+    operator<(MPTAmount const& other) const;
+
+    /** Returns true if the amount is not zero */
+    explicit constexpr
+    operator bool() const noexcept;
+
+    /** Return the sign of the amount */
+    constexpr int
+    signum() const noexcept;
+
+    /** Returns the underlying value. Code SHOULD NOT call this
+        function unless the type has been abstracted away,
+        e.g. in a templated function.
+    */
+    constexpr value_type
+    value() const;
+
+    static MPTAmount
+    minPositiveAmount();
+};
+
+constexpr MPTAmount::MPTAmount(value_type value) : value_(value)
+{
+}
+
+constexpr MPTAmount&
+MPTAmount::operator=(beast::Zero)
+{
+    value_ = 0;
+    return *this;
+}
+
+/** Returns true if the amount is not zero */
+constexpr MPTAmount::operator bool() const noexcept
+{
+    return value_ != 0;
+}
+
+/** Return the sign of the amount */
+constexpr int
+MPTAmount::signum() const noexcept
+{
+    return (value_ < 0) ? -1 : (value_ ? 1 : 0);
+}
+
+/** Returns the underlying value. Code SHOULD NOT call this
+    function unless the type has been abstracted away,
+    e.g. in a templated function.
+*/
+constexpr MPTAmount::value_type
+MPTAmount::value() const
+{
+    return value_;
+}
+
+inline std::string
+to_string(MPTAmount const& amount)
+{
+    return std::to_string(amount.value());
+}
+
+inline MPTAmount
+mulRatio(
+    MPTAmount const& amt,
+    std::uint32_t num,
+    std::uint32_t den,
+    bool roundUp)
+{
+    using namespace boost::multiprecision;
+
+    if (!den)
+        Throw<std::runtime_error>("division by zero");
+
+    int128_t const amt128(amt.value());
+    auto const neg = amt.value() < 0;
+    auto const m = amt128 * num;
+    auto r = m / den;
+    if (m % den)
+    {
+        if (!neg && roundUp)
+            r += 1;
+        if (neg && !roundUp)
+            r -= 1;
+    }
+    if (r > std::numeric_limits<MPTAmount::value_type>::max())
+        Throw<std::overflow_error>("MPT mulRatio overflow");
+    return MPTAmount(r.convert_to<MPTAmount::value_type>());
+}
+
+}  // namespace ripple
+
+#endif  // RIPPLE_BASICS_MPTAMOUNT_H_INCLUDED

include/xrpl/basics/Number.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_BASICS_NUMBER_H_INCLUDED
 #define RIPPLE_BASICS_NUMBER_H_INCLUDED
 
+#include <xrpl/basics/MPTAmount.h>
 #include <xrpl/basics/XRPAmount.h>
 #include <cstdint>
 #include <limits>
@@ -52,6 +53,7 @@ class Number
     explicit constexpr Number(rep mantissa, int exponent, unchecked) noexcept;
 
     Number(XRPAmount const& x);
+    Number(MPTAmount const& x);
 
     constexpr rep
     mantissa() const noexcept;
@@ -88,9 +90,16 @@ class Number
     static constexpr Number
     lowest() noexcept;
 
+    /** Conversions to Number are implicit and conversions away from Number
+     *  are explicit. This design encourages and facilitates the use of Number
+     *  as the preferred type for floating point arithmetic as it makes
+     *  "mixed mode" more convenient, e.g. MPTAmount + Number.
+     */
     explicit
     operator XRPAmount() const;  // round to nearest, even on tie
     explicit
+    operator MPTAmount() const;  // round to nearest, even on tie
+    explicit
     operator rep() const;  // round to nearest, even on tie
 
     friend constexpr bool
@@ -212,6 +221,10 @@ inline Number::Number(XRPAmount const& x) : Number{x.drops()}
 {
 }
 
+inline Number::Number(MPTAmount const& x) : Number{x.value()}
+{
+}
+
 inline constexpr Number::rep
 Number::mantissa() const noexcept
 {

include/xrpl/basics/XRPAmount.h

@@ -207,6 +207,10 @@ class XRPAmount : private boost::totally_ordered<XRPAmount>,
         return dropsAs<Dest>().value_or(defaultValue.drops());
     }
 
+    /* Clips a 64-bit value to a 32-bit JSON number. It is only used
+     * in contexts that don't expect the value to ever approach
+     * the 32-bit limits (i.e. fees and reserves).
+     */
     Json::Value
     jsonClipped() const
     {

include/xrpl/basics/base_uint.h

@@ -549,6 +549,7 @@ class base_uint
 using uint128 = base_uint<128>;
 using uint160 = base_uint<160>;
 using uint256 = base_uint<256>;
+using uint192 = base_uint<192>;
 
 template <std::size_t Bits, class Tag>
 [[nodiscard]] inline constexpr std::strong_ordering
@@ -634,6 +635,7 @@ operator<<(std::ostream& out, base_uint<Bits, Tag> const& u)
 #ifndef __INTELLISENSE__
 static_assert(sizeof(uint128) == 128 / 8, "There should be no padding bytes");
 static_assert(sizeof(uint160) == 160 / 8, "There should be no padding bytes");
+static_assert(sizeof(uint192) == 192 / 8, "There should be no padding bytes");
 static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
 #endif
 

include/xrpl/protocol/AmountConversions.h

@@ -33,13 +33,7 @@ toSTAmount(IOUAmount const& iou, Issue const& iss)
 {
     bool const isNeg = iou.signum() < 0;
     std::uint64_t const umant = isNeg ? -iou.mantissa() : iou.mantissa();
-    return STAmount(
-        iss,
-        umant,
-        iou.exponent(),
-        /*native*/ false,
-        isNeg,
-        STAmount::unchecked());
+    return STAmount(iss, umant, iou.exponent(), isNeg, STAmount::unchecked());
 }
 
 inline STAmount