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,185 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2012, 2013 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_INTEGRALAMOUNT_H_INCLUDED
+#define RIPPLE_BASICS_INTEGRALAMOUNT_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;
+
+    Json::Value
+    jsonClipped() const;
+
+    /** 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;
+
+    friend std::istream&
+    operator>>(std::istream& s, MPTAmount& val);
+
+    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::istream&
+operator>>(std::istream& s, MPTAmount& val)
+{
+    s >> val.value_;
+    return s;
+}
+
+// Output MPTAmount as just the value.
+template <class Char, class Traits>
+std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os, const MPTAmount& q)
+{
+    return os << q.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_INTEGRALAMOUNT_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;
@@ -89,6 +91,7 @@ class Number
     lowest() noexcept;
 
     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
@@ -210,6 +213,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/base_uint.h

@@ -548,6 +548,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
@@ -633,6 +634,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