Fix touchy "funds are conserved" assertion in LoanPay

- Add "Yield Theft via Rounding Manipulation" test, which used to reliably triggered it. The test now verifies that no "yield theft" occurs.
2026-01-28 02:25:28 +00:00 · 2026-01-16 19:19:17 -05:00
15 changed files with 700 additions and 1149 deletions
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -23,16 +23,11 @@
 #include <xrpl/beast/utility/instrumentation.h>

 #include <cstdint>
-#include <functional>
 #include <limits>
 #include <optional>
 #include <ostream>
 #include <string>

-#ifdef _MSC_VER
-#include <boost/multiprecision/cpp_int.hpp>
-#endif  // !defined(_MSC_VER)
-
 namespace ripple {

 class Number;
@@ -40,37 +35,18 @@ class Number;
 std::string
 to_string(Number const& amount);

-/** Returns a rough estimate of log10(value).
- *
- * The return value is a pair (log, rem), where log is the estimated log10,
- * and rem is value divided by 10^log. If rem is 1, then value is an exact
- * power of ten, and log is the exact log10(value).
- *
- * This function only works for positive values.
- */
-template <typename T>
-constexpr std::pair<int, T>
-logTenEstimate(T value)
-{
-    int log = 0;
-    T remainder = value;
-    while (value >= 10)
-    {
-        if (value % 10 == 0)
-            remainder = remainder / 10;
-        value /= 10;
-        ++log;
-    }
-    return {log, remainder};
-}
-
 template <typename T>
 constexpr std::optional<int>
 logTen(T value)
 {
-    auto const est = logTenEstimate(value);
-    if (est.second == 1)
-        return est.first;
+    int log = 0;
+    while (value >= 10 && value % 10 == 0)
+    {
+        value /= 10;
+        ++log;
+    }
+    if (value == 1)
+        return log;
    return std::nullopt;
 }

@@ -84,10 +60,12 @@ isPowerOfTen(T value)
 /** MantissaRange defines a range for the mantissa of a normalized Number.
 *
 * The mantissa is in the range [min, max], where
+ * * min is a power of 10, and
+ * * max = min * 10 - 1.
 *
 * The mantissa_scale enum indicates whether the range is "small" or "large".
 * This intentionally restricts the number of MantissaRanges that can be
- * used to two: one for each scale.
+ * instantiated to two: one for each scale.
 *
 * The "small" scale is based on the behavior of STAmount for IOUs. It has a min
 * value of 10^15, and a max value of 10^16-1. This was sufficient for
@@ -101,8 +79,8 @@ isPowerOfTen(T value)
 * "large" scale.
 *
 * The "large" scale is intended to represent all values that can be represented
- * by an STAmount - IOUs, XRP, and MPTs. It has a min value of 2^63/10+1
- * (truncated), and a max value of 2^63-1.
+ * by an STAmount - IOUs, XRP, and MPTs. It has a min value of 10^18, and a max
+ * value of 10^19-1.
 *
 * Note that if the mentioned amendments are eventually retired, this class
 * should be left in place, but the "small" scale option should be removed. This
@@ -114,50 +92,28 @@ struct MantissaRange
    enum mantissa_scale { small, large };

    explicit constexpr MantissaRange(mantissa_scale scale_)
-        : max(getMax(scale_))
-        , min(computeMin(max))
-        , referenceMin(getReferenceMin(scale_, min))
-        , log(computeLog(min))
+        : min(getMin(scale_))
+        , max(min * 10 - 1)
+        , log(logTen(min).value_or(-1))
        , scale(scale_)
    {
-        // Since this is constexpr, if any of these throw, it won't compile
-        if (min * 10 <= max)
-            throw std::out_of_range("min * 10 <= max");
-        if (max / 10 >= min)
-            throw std::out_of_range("max / 10 >= min");
-        if ((min - 1) * 10 > max)
-            throw std::out_of_range("(min - 1) * 10 > max");
-        // This is a little hacky
-        if ((max + 10) / 10 < min)
-            throw std::out_of_range("(max + 10) / 10 < min");
    }

-    // Explicitly delete copy and move operations
-    MantissaRange(MantissaRange const&) = delete;
-    MantissaRange(MantissaRange&&) = delete;
-    MantissaRange&
-    operator=(MantissaRange const&) = delete;
-    MantissaRange&
-    operator=(MantissaRange&&) = delete;
-
-    rep max;
    rep min;
-    // This is not a great name. Used to determine if mantissas are in range,
-    // but have fewer digits than max
-    rep referenceMin;
+    rep max;
    int log;
    mantissa_scale scale;

 private:
    static constexpr rep
-    getMax(mantissa_scale scale)
+    getMin(mantissa_scale scale_)
    {
-        switch (scale)
+        switch (scale_)
        {
            case small:
-                return 9'999'999'999'999'999ULL;
+                return 1'000'000'000'000'000ULL;
            case large:
-                return std::numeric_limits<std::int64_t>::max();
+                return 1'000'000'000'000'000'000ULL;
            default:
                // Since this can never be called outside a non-constexpr
                // context, this throw assures that the build fails if an
@@ -165,33 +121,6 @@ private:
                throw std::runtime_error("Unknown mantissa scale");
        }
    }
-
-    static constexpr rep
-    computeMin(rep max)
-    {
-        return max / 10 + 1;
-    }
-
-    static constexpr rep
-    getReferenceMin(mantissa_scale scale, rep min)
-    {
-        switch (scale)
-        {
-            case large:
-                return 1'000'000'000'000'000'000ULL;
-            default:
-                if (isPowerOfTen(min))
-                    return min;
-                throw std::runtime_error("Unknown/bad mantissa scale");
-        }
-    }
-
-    static constexpr rep
-    computeLog(rep min)
-    {
-        auto const estimate = logTenEstimate(min);
-        return estimate.first + (estimate.second == 1 ? 0 : 1);
-    }
 };

 // Like std::integral, but only 64-bit integral types.
@@ -199,20 +128,6 @@ template <class T>
 concept Integral64 =
    std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>;

-namespace detail {
-#ifdef _MSC_VER
-using uint128_t = boost::multiprecision::uint128_t;
-using int128_t = boost::multiprecision::int128_t;
-#else   // !defined(_MSC_VER)
-using uint128_t = __uint128_t;
-using int128_t = __int128_t;
-#endif  // !defined(_MSC_VER)
-
-template <class T>
-concept UnsignedMantissa =
-    std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>;
-}  // namespace detail
-
 /** Number is a floating point type that can represent a wide range of values.
 *
 * It can represent all values that can be represented by an STAmount -
@@ -240,7 +155,9 @@ concept UnsignedMantissa =
 *   1. Normalization can be disabled by using the "unchecked" ctor tag. This
 *      should only be used at specific conversion points, some constexpr
 *      values, and in unit tests.
- *   2. The max of the "large" range, 2^63-1, TODO: explain the large range.
+ *   2. The max of the "large" range, 10^19-1, is the largest 10^X-1 value that
+ *      fits in an unsigned 64-bit number. (10^19-1 < 2^64-1 and
+ *      10^20-1 > 2^64-1). This avoids under- and overflows.
 *
 * ---- External Interface ----
 *
@@ -254,7 +171,7 @@ concept UnsignedMantissa =
 *
 * Note:
 *   1. 2^63-1 is between 10^18 and 10^19-1, which are the limits of the "large"
- *      mantissa range. TODO: update this explanation.
+ *      mantissa range.
 *   2. The functions mantissa() and exponent() return the external view of the
 *      Number value, specifically using a signed 63-bit mantissa. This may
 *      require altering the internal representation to fit into that range
@@ -314,7 +231,8 @@ class Number
    using rep = std::int64_t;
    using internalrep = MantissaRange::rep;

-    rep mantissa_{0};
+    bool negative_{false};
+    internalrep mantissa_{0};
    int exponent_{std::numeric_limits<int>::lowest()};

 public:
@@ -322,11 +240,9 @@ public:
    constexpr static int minExponent = -32768;
    constexpr static int maxExponent = 32768;

-#if MAXREP
    constexpr static internalrep maxRep = std::numeric_limits<rep>::max();
    static_assert(maxRep == 9'223'372'036'854'775'807);
    static_assert(-maxRep == std::numeric_limits<rep>::min() + 1);
-#endif

    // May need to make unchecked private
    struct unchecked
@@ -412,7 +328,8 @@ public:
    friend constexpr bool
    operator==(Number const& x, Number const& y) noexcept
    {
-        return x.mantissa_ == y.mantissa_ && x.exponent_ == y.exponent_;
+        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ &&
+            x.exponent_ == y.exponent_;
    }

    friend constexpr bool
@@ -426,8 +343,8 @@ public:
    {
        // If the two amounts have different signs (zero is treated as positive)
        // then the comparison is true iff the left is negative.
-        bool const lneg = x.mantissa_ < 0;
-        bool const rneg = y.mantissa_ < 0;
+        bool const lneg = x.negative_;
+        bool const rneg = y.negative_;

        if (lneg != rneg)
            return lneg;
@@ -455,7 +372,7 @@ public:
    constexpr int
    signum() const noexcept
    {
-        return mantissa_ < 0 ? -1 : (mantissa_ ? 1 : 0);
+        return negative_ ? -1 : (mantissa_ ? 1 : 0);
    }

    Number
@@ -494,9 +411,6 @@ public:
    friend Number
    root2(Number f);

-    friend Number
-    power(Number const& f, unsigned n, unsigned d);
-
    // Thread local rounding control.  Default is to_nearest
    enum rounding_mode { to_nearest, towards_zero, downward, upward };
    static rounding_mode
@@ -561,48 +475,22 @@ private:
    static_assert(isPowerOfTen(smallRange.min));
    static_assert(smallRange.min == 1'000'000'000'000'000LL);
    static_assert(smallRange.max == 9'999'999'999'999'999LL);
-    static_assert(smallRange.referenceMin == smallRange.min);
    static_assert(smallRange.log == 15);
-#if MAXREP
    static_assert(smallRange.min < maxRep);
    static_assert(smallRange.max < maxRep);
-#endif
    constexpr static MantissaRange largeRange{MantissaRange::large};
-    static_assert(!isPowerOfTen(largeRange.min));
-    static_assert(largeRange.min == 922'337'203'685'477'581ULL);
-    static_assert(largeRange.max == internalrep(9'223'372'036'854'775'807ULL));
-    static_assert(largeRange.max == std::numeric_limits<rep>::max());
-    static_assert(largeRange.referenceMin == 1'000'000'000'000'000'000ULL);
+    static_assert(isPowerOfTen(largeRange.min));
+    static_assert(largeRange.min == 1'000'000'000'000'000'000ULL);
+    static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
    static_assert(largeRange.log == 18);
-    // There are 2 values that will not fit in largeRange without some extra
-    // work
-    // * 9223372036854775808
-    // * 9223372036854775809
-    // They both end up < min, but with a leftover. If they round up, everything
-    // will be fine. If they don't, well need to bring them up into range.
-    // Guard::bringIntoRange handles this situation.
-
-#if MAXREP
    static_assert(largeRange.min < maxRep);
    static_assert(largeRange.max > maxRep);
-#endif

    // 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_;

-    // And one is needed because it needs to choose between oneSmall and
-    // oneLarge based on the current range
-    static Number
-    one(MantissaRange const& range);
-
-    static Number
-    root(MantissaRange const& range, Number f, unsigned d);
-
-    void
-    normalize(MantissaRange const& range);
-
    void
    normalize();

@@ -625,14 +513,11 @@ private:
    friend void
    doNormalize(
        bool& negative,
-        T& mantissa,
-        int& exponent,
+        T& mantissa_,
+        int& exponent_,
        MantissaRange::rep const& minMantissa,
        MantissaRange::rep const& maxMantissa);

-    bool
-    isnormal(MantissaRange const& range) const noexcept;
-
    bool
    isnormal() const noexcept;

@@ -649,64 +534,7 @@ private:
    static internalrep
    externalToInternal(rep mantissa);

-    /** Breaks down the number into components, potentially de-normalizing it.
-     *
-     * Ensures that the mantissa always has range_.log + 1 digits.
-     *
-     */
-    template <detail::UnsignedMantissa Rep = internalrep>
-    std::tuple<bool, Rep, int>
-    toInternal(MantissaRange const& range) const;
-
-    /** Breaks down the number into components, potentially de-normalizing it.
-     *
-     * Ensures that the mantissa always has range_.log + 1 digits.
-     *
-     */
-    template <detail::UnsignedMantissa Rep = internalrep>
-    std::tuple<bool, Rep, int>
-    toInternal() const;
-
-    /** Rebuilds the number from components.
-     *
-     * If "normalized" is true, the values are expected to be normalized - all
-     * in their valid ranges.
-     *
-     * If "normalized" is false, the values are expected to be "near
-     * normalized", meaning that the mantissa has to be modified at most once to
-     * bring it back into range.
-     *
-     */
-    template <
-        bool expectNormal = true,
-        detail::UnsignedMantissa Rep = internalrep>
-    void
-    fromInternal(
-        bool negative,
-        Rep mantissa,
-        int exponent,
-        MantissaRange const* pRange);
-
-    /** Rebuilds the number from components.
-     *
-     * If "normalized" is true, the values are expected to be normalized - all
-     * in their valid ranges.
-     *
-     * If "normalized" is false, the values are expected to be "near
-     * normalized", meaning that the mantissa has to be modified at most once to
-     * bring it back into range.
-     *
-     */
-    template <
-        bool expectNormal = true,
-        detail::UnsignedMantissa Rep = internalrep>
-    void
-    fromInternal(bool negative, Rep mantissa, int exponent);
-
    class Guard;
-
-public:
-    constexpr static internalrep largestMantissa = largeRange.max;
 };

 inline constexpr Number::Number(
@@ -714,8 +542,7 @@ inline constexpr Number::Number(
    internalrep mantissa,
    int exponent,
    unchecked) noexcept
-    : mantissa_{(negative ? -1 : 1) * static_cast<rep>(mantissa)}
-    , exponent_{exponent}
+    : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }

@@ -729,6 +556,16 @@ inline constexpr Number::Number(

 constexpr static Number numZero{};

+inline Number::Number(
+    bool negative,
+    internalrep mantissa,
+    int exponent,
+    normalized)
+    : Number(negative, mantissa, exponent, unchecked{})
+{
+    normalize();
+}
+
 inline Number::Number(internalrep mantissa, int exponent, normalized)
    : Number(false, mantissa, exponent, normalized{})
 {
@@ -751,7 +588,17 @@ inline Number::Number(rep mantissa) : Number{mantissa, 0}
 inline constexpr Number::rep
 Number::mantissa() const noexcept
 {
-    return mantissa_;
+    auto m = mantissa_;
+    if (m > maxRep)
+    {
+        XRPL_ASSERT_PARTS(
+            !isnormal() || (m % 10 == 0 && m / 10 <= maxRep),
+            "xrpl::Number::mantissa",
+            "large normalized mantissa has no remainder");
+        m /= 10;
+    }
+    auto const sign = negative_ ? -1 : 1;
+    return sign * static_cast<Number::rep>(m);
 }

 /** Returns the exponent of the external view of the Number.
@@ -762,7 +609,16 @@ Number::mantissa() const noexcept
 inline constexpr int
 Number::exponent() const noexcept
 {
-    return exponent_;
+    auto e = exponent_;
+    if (mantissa_ > maxRep)
+    {
+        XRPL_ASSERT_PARTS(
+            !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= maxRep),
+            "xrpl::Number::exponent",
+            "large normalized mantissa has no remainder");
+        ++e;
+    }
+    return e;
 }

 inline constexpr Number
@@ -777,7 +633,7 @@ Number::operator-() const noexcept
    if (mantissa_ == 0)
        return Number{};
    auto x = *this;
-    x.mantissa_ = -1 * x.mantissa_;
+    x.negative_ = !x.negative_;
    return x;
 }

@@ -858,38 +714,34 @@ Number::min() noexcept
 inline Number
 Number::max() noexcept
 {
-    return Number{false, range_.get().max, maxExponent, unchecked{}};
+    return Number{
+        false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }

 inline Number
 Number::lowest() noexcept
 {
-    return Number{true, range_.get().max, maxExponent, unchecked{}};
-}
-
-inline bool
-Number::isnormal(MantissaRange const& range) const noexcept
-{
-    auto const abs_m = mantissa_ < 0 ? -mantissa_ : mantissa_;
-
-    return *this == Number{} ||
-        (range.min <= abs_m && abs_m <= range.max &&  //
-         minExponent <= exponent_ && exponent_ <= maxExponent);
+    return Number{
+        true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }

 inline bool
 Number::isnormal() const noexcept
 {
-    return isnormal(range_);
+    MantissaRange const& range = range_;
+    auto const abs_m = mantissa_;
+    return *this == Number{} ||
+        (range.min <= abs_m && abs_m <= range.max &&
+         (abs_m <= maxRep || abs_m % 10 == 0) && minExponent <= exponent_ &&
+         exponent_ <= maxExponent);
 }

 template <Integral64 T>
 std::pair<T, int>
 Number::normalizeToRange(T minMantissa, T maxMantissa) const
 {
-    bool negative = mantissa_ < 0;
-    auto const sign = negative ? -1 : 1;
-    internalrep mantissa = sign * mantissa_;
+    bool negative = negative_;
+    internalrep mantissa = mantissa_;
    int exponent = exponent_;

    if constexpr (std::is_unsigned_v<T>)
@@ -899,7 +751,8 @@ Number::normalizeToRange(T minMantissa, T maxMantissa) const
            "Number is non-negative for unsigned range.");
    Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);

-    return std::make_pair(sign * static_cast<T>(mantissa), exponent);
+    auto const sign = negative ? -1 : 1;
+    return std::make_pair(static_cast<T>(sign * mantissa), exponent);
 }

 inline constexpr Number
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -252,7 +252,7 @@ std::size_t constexpr maxMPTokenMetadataLength = 1024;

 /** The maximum amount of MPTokenIssuance */
 std::uint64_t constexpr maxMPTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull;
-static_assert(Number::largestMantissa >= maxMPTokenAmount);
+static_assert(Number::maxRep >= maxMPTokenAmount);

 /** The maximum length of Data payload */
 std::size_t constexpr maxDataPayloadLength = 256;
--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -62,8 +62,8 @@ private:
 public:
    using value_type = STAmount;

-    static int const cMinOffset = -96;
-    static int const cMaxOffset = 80;
+    static constexpr int cMinOffset = -96;
+    static constexpr int cMaxOffset = 80;

    // Maximum native value supported by the code
    constexpr static std::uint64_t cMinValue = 1'000'000'000'000'000ull;
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -416,9 +416,6 @@ public:
    void
    delField(int index);

-    SOEStyle
-    getStyle(SField const& field) const;
-
    bool
    hasMatchingEntry(STBase const&);

--- a/include/xrpl/protocol/SystemParameters.h
+++ b/include/xrpl/protocol/SystemParameters.h
@@ -43,7 +43,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);
-static_assert(Number::largestMantissa >= INITIAL_XRP.drops());
+static_assert(Number::maxRep >= INITIAL_XRP.drops());

 /** Returns true if the amount does not exceed the initial XRP in existence. */
 inline bool
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -35,10 +35,13 @@

 #ifdef _MSC_VER
 #pragma message("Using boost::multiprecision::uint128_t and int128_t")
-#endif
-
-using uint128_t = ripple::detail::uint128_t;
-using int128_t = ripple::detail::int128_t;
+#include <boost/multiprecision/cpp_int.hpp>
+using uint128_t = boost::multiprecision::uint128_t;
+using int128_t = boost::multiprecision::int128_t;
+#else   // !defined(_MSC_VER)
+using uint128_t = __uint128_t;
+using int128_t = __int128_t;
+#endif  // !defined(_MSC_VER)

 namespace ripple {

@@ -78,6 +81,10 @@ Number::setMantissaScale(MantissaRange::mantissa_scale scale)
 // preicision to an operation.  This enables the final result
 // to be correctly rounded to the internal precision of Number.

+template <class T>
+concept UnsignedMantissa =
+    std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>;
+
 class Number::Guard
 {
    std::uint64_t digits_;   // 16 decimal guard digits
@@ -113,7 +120,7 @@ public:
    round() noexcept;

    // Modify the result to the correctly rounded value
-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    doRoundUp(
        bool& negative,
@@ -124,7 +131,7 @@ public:
        std::string location);

    // Modify the result to the correctly rounded value
-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    doRoundDown(
        bool& negative,
@@ -140,7 +147,7 @@ private:
    void
    doPush(unsigned d) noexcept;

-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    bringIntoRange(
        bool& negative,
@@ -231,7 +238,7 @@ Number::Guard::round() noexcept
    return 0;
 }

-template <detail::UnsignedMantissa T>
+template <UnsignedMantissa T>
 void
 Number::Guard::bringIntoRange(
    bool& negative,
@@ -250,13 +257,13 @@ Number::Guard::bringIntoRange(
    {
        constexpr Number zero = Number{};

-        negative = false;
+        negative = zero.negative_;
        mantissa = zero.mantissa_;
        exponent = zero.exponent_;
    }
 }

-template <detail::UnsignedMantissa T>
+template <UnsignedMantissa T>
 void
 Number::Guard::doRoundUp(
    bool& negative,
@@ -272,7 +279,7 @@ Number::Guard::doRoundUp(
        ++mantissa;
        // Ensure mantissa after incrementing fits within both the
        // min/maxMantissa range and is a valid "rep".
-        if (mantissa > maxMantissa)
+        if (mantissa > maxMantissa || mantissa > maxRep)
        {
            mantissa /= 10;
            ++exponent;
@@ -283,7 +290,7 @@ Number::Guard::doRoundUp(
        throw std::overflow_error(location);
 }

-template <detail::UnsignedMantissa T>
+template <UnsignedMantissa T>
 void
 Number::Guard::doRoundDown(
    bool& negative,
@@ -311,8 +318,7 @@ Number::Guard::doRound(rep& drops, std::string location)
    auto r = round();
    if (r == 1 || (r == 0 && (drops & 1) == 1))
    {
-        auto const& range = range_.get();
-        if (drops >= range.max)
+        if (drops >= maxRep)
        {
            static_assert(sizeof(internalrep) == sizeof(rep));
            // This should be impossible, because it's impossible to represent
@@ -354,136 +360,12 @@ Number::externalToInternal(rep mantissa)
    return static_cast<internalrep>(-temp);
 }

-/** Breaks down the number into components, potentially de-normalizing it.
- *
- * Ensures that the mantissa always has range_.log digits.
- *
- */
-template <detail::UnsignedMantissa Rep>
-std::tuple<bool, Rep, int>
-Number::toInternal(MantissaRange const& range) const
-{
-    auto exponent = exponent_;
-    bool const negative = mantissa_ < 0;
-    auto const sign = negative ? -1 : 1;
-    Rep mantissa = static_cast<Rep>(sign * mantissa_);
-
-    auto const referenceMin = range.referenceMin;
-    auto const minMantissa = range.min;
-
-    if (mantissa != 0 && mantissa >= minMantissa && mantissa < referenceMin)
-    {
-        // Ensure the mantissa has the correct number of digits
-        mantissa *= 10;
-        --exponent;
-        XRPL_ASSERT_PARTS(
-            mantissa >= referenceMin && mantissa < referenceMin * 10,
-            "ripple::Number::toInternal()",
-            "Number is within reference range and has 'log' digits");
-    }
-
-    return {negative, mantissa, exponent};
-}
-
-/** Breaks down the number into components, potentially de-normalizing it.
- *
- * Ensures that the mantissa always has range_.log digits.
- *
- */
-template <detail::UnsignedMantissa Rep>
-std::tuple<bool, Rep, int>
-Number::toInternal() const
-{
-    return toInternal(range_);
-}
-
-/** Rebuilds the number from components.
- *
- * If "normalized" is true, the values are expected to be normalized - all
- * in their valid ranges.
- *
- * If "normalized" is false, the values are expected to be "near
- * normalized", meaning that the mantissa has to be modified at most once to
- * bring it back into range.
- *
- */
-template <bool expectNormal, detail::UnsignedMantissa Rep>
-void
-Number::fromInternal(
-    bool negative,
-    Rep mantissa,
-    int exponent,
-    MantissaRange const* pRange)
-{
-    if constexpr (std::is_same_v<
-                      std::bool_constant<expectNormal>,
-                      std::false_type>)
-    {
-        if (!pRange)
-            throw std::runtime_error("Missing range to Number::fromInternal!");
-        auto const& range = *pRange;
-
-        auto const maxMantissa = range.max;
-        auto const minMantissa = range.min;
-
-        XRPL_ASSERT_PARTS(
-            mantissa >= minMantissa,
-            "ripple::Number::fromInternal",
-            "mantissa large enough");
-
-        if (mantissa > maxMantissa || mantissa < minMantissa)
-        {
-            normalize(negative, mantissa, exponent, range.min, maxMantissa);
-        }
-
-        XRPL_ASSERT_PARTS(
-            mantissa >= minMantissa && mantissa <= maxMantissa,
-            "ripple::Number::fromInternal",
-            "mantissa in range");
-    }
-
-    auto const sign = negative ? -1 : 1;
-
-    mantissa_ = sign * static_cast<rep>(mantissa);
-    exponent_ = exponent;
-
-    XRPL_ASSERT_PARTS(
-        (pRange && isnormal(*pRange)) || isnormal(),
-        "ripple::Number::fromInternal",
-        "Number is normalized");
-}
-
-/** Rebuilds the number from components.
- *
- * If "normalized" is true, the values are expected to be normalized - all in
- * their valid ranges.
- *
- * If "normalized" is false, the values are expected to be "near normalized",
- * meaning that the mantissa has to be modified at most once to bring it back
- * into range.
- *
- */
-template <bool expectNormal, detail::UnsignedMantissa Rep>
-void
-Number::fromInternal(bool negative, Rep mantissa, int exponent)
-{
-    MantissaRange const* pRange = nullptr;
-    if constexpr (std::is_same_v<
-                      std::bool_constant<expectNormal>,
-                      std::false_type>)
-    {
-        pRange = &Number::range_.get();
-    }
-
-    fromInternal(negative, mantissa, exponent, pRange);
-}
-
 constexpr Number
 Number::oneSmall()
 {
    return Number{
        false,
-        Number::smallRange.referenceMin,
+        Number::smallRange.min,
        -Number::smallRange.log,
        Number::unchecked{}};
 };
@@ -495,7 +377,7 @@ Number::oneLarge()
 {
    return Number{
        false,
-        Number::largeRange.referenceMin,
+        Number::largeRange.min,
        -Number::largeRange.log,
        Number::unchecked{}};
 };
@@ -503,91 +385,106 @@ Number::oneLarge()
 constexpr Number oneLrg = Number::oneLarge();

 Number
-Number::one(MantissaRange const& range)
+Number::one()
 {
-    if (&range == &smallRange)
+    if (&range_.get() == &smallRange)
        return oneSml;
-    XRPL_ASSERT(&range == &largeRange, "Number::one() : valid range");
+    XRPL_ASSERT(&range_.get() == &largeRange, "Number::one() : valid range_");
    return oneLrg;
 }

-Number
-Number::one()
-{
-    return one(range_);
-}
-
 // Use the member names in this static function for now so the diff is cleaner
+// TODO: Rename the function parameters to get rid of the "_" suffix
 template <class T>
 void
 doNormalize(
    bool& negative,
-    T& mantissa,
-    int& exponent,
+    T& mantissa_,
+    int& exponent_,
    MantissaRange::rep const& minMantissa,
    MantissaRange::rep const& maxMantissa)
 {
    auto constexpr minExponent = Number::minExponent;
    auto constexpr maxExponent = Number::maxExponent;
+    auto constexpr maxRep = Number::maxRep;

    using Guard = Number::Guard;

    constexpr Number zero = Number{};
-    if (mantissa == 0 || (mantissa < minMantissa && exponent <= minExponent))
+    if (mantissa_ == 0)
    {
-        mantissa = zero.mantissa_;
-        exponent = zero.exponent_;
-        negative = false;
+        mantissa_ = zero.mantissa_;
+        exponent_ = zero.exponent_;
+        negative = zero.negative_;
        return;
    }
-
-    auto m = mantissa;
-    while ((m < minMantissa) && (exponent > minExponent))
+    auto m = mantissa_;
+    while ((m < minMantissa) && (exponent_ > minExponent))
    {
        m *= 10;
-        --exponent;
+        --exponent_;
    }
    Guard g;
    if (negative)
        g.set_negative();
    while (m > maxMantissa)
    {
-        if (exponent >= maxExponent)
+        if (exponent_ >= maxExponent)
            throw std::overflow_error("Number::normalize 1");
        g.push(m % 10);
        m /= 10;
-        ++exponent;
+        ++exponent_;
    }
-    if ((exponent < minExponent) || (m == 0))
+    if ((exponent_ < minExponent) || (m < minMantissa))
    {
-        mantissa = zero.mantissa_;
-        exponent = zero.exponent_;
-        negative = false;
+        mantissa_ = zero.mantissa_;
+        exponent_ = zero.exponent_;
+        negative = zero.negative_;
        return;
    }

+    // When using the largeRange, "m" needs fit within an int64, even if
+    // the final mantissa_ is going to end up larger to fit within the
+    // MantissaRange. Cut it down here so that the rounding will be done while
+    // it's smaller.
+    //
+    // Example: 9,900,000,000,000,123,456 > 9,223,372,036,854,775,807,
+    //      so "m" will be modified to 990,000,000,000,012,345. Then that value
+    //      will be rounded to 990,000,000,000,012,345 or
+    //      990,000,000,000,012,346, depending on the rounding mode. Finally,
+    //      mantissa_ will be "m*10" so it fits within the range, and end up as
+    //      9,900,000,000,000,123,450 or 9,900,000,000,000,123,460.
+    // mantissa() will return mantissa_ / 10, and exponent() will return
+    // exponent_ + 1.
+    if (m > maxRep)
+    {
+        if (exponent_ >= maxExponent)
+            throw std::overflow_error("Number::normalize 1.5");
+        g.push(m % 10);
+        m /= 10;
+        ++exponent_;
+    }
+    // Before modification, m should be within the min/max range. After
+    // modification, it must be less than maxRep. In other words, the original
+    // value should have been no more than maxRep * 10.
+    // (maxRep * 10 > maxMantissa)
    XRPL_ASSERT_PARTS(
-        m <= maxMantissa,
+        m <= maxRep,
        "xrpl::doNormalize",
        "intermediate mantissa fits in int64");
-    mantissa = m;
+    mantissa_ = m;

    g.doRoundUp(
        negative,
-        mantissa,
-        exponent,
+        mantissa_,
+        exponent_,
        minMantissa,
        maxMantissa,
        "Number::normalize 2");
-
    XRPL_ASSERT_PARTS(
-        mantissa >= minMantissa && mantissa <= maxMantissa,
+        mantissa_ >= minMantissa && mantissa_ <= maxMantissa,
        "xrpl::doNormalize",
        "final mantissa fits in range");
-    XRPL_ASSERT_PARTS(
-        exponent >= minExponent && exponent <= maxExponent,
-        "xrpl::doNormalize",
-        "final exponent fits in range");
 }

 template <>
@@ -626,20 +523,11 @@ Number::normalize<unsigned long>(
    doNormalize(negative, mantissa, exponent, minMantissa, maxMantissa);
 }

-void
-Number::normalize(MantissaRange const& range)
-{
-    auto [negative, mantissa, exponent] = toInternal(range);
-
-    normalize(negative, mantissa, exponent, range.min, range.max);
-
-    fromInternal(negative, mantissa, exponent, &range);
-}
-
 void
 Number::normalize()
 {
-    normalize(range_);
+    auto const& range = range_.get();
+    normalize(negative_, mantissa_, exponent_, range.min, range.max);
 }

 // Copy the number, but set a new exponent. Because the mantissa doesn't change,
@@ -649,33 +537,24 @@ Number
 Number::shiftExponent(int exponentDelta) const
 {
    XRPL_ASSERT_PARTS(isnormal(), "xrpl::Number::shiftExponent", "normalized");
-
-    Number result = *this;
-
-    result.exponent_ += exponentDelta;
-
-    if (result.exponent_ >= maxExponent)
+    auto const newExponent = exponent_ + exponentDelta;
+    if (newExponent >= maxExponent)
        throw std::overflow_error("Number::shiftExponent");
-    if (result.exponent_ < minExponent)
+    if (newExponent < minExponent)
    {
        return Number{};
    }
-
+    Number const result{negative_, mantissa_, newExponent, unchecked{}};
+    XRPL_ASSERT_PARTS(
+        result.isnormal(),
+        "xrpl::Number::shiftExponent",
+        "result is normalized");
    return result;
 }

-Number::Number(bool negative, internalrep mantissa, int exponent, normalized)
-{
-    auto const& range = range_.get();
-    normalize(negative, mantissa, exponent, range.min, range.max);
-    fromInternal(negative, mantissa, exponent, &range);
-}
-
 Number&
 Number::operator+=(Number const& y)
 {
-    auto const& range = range_.get();
-
    constexpr Number zero = Number{};
    if (y == zero)
        return *this;
@@ -691,7 +570,7 @@ Number::operator+=(Number const& y)
    }

    XRPL_ASSERT(
-        isnormal(range) && y.isnormal(range),
+        isnormal() && y.isnormal(),
        "xrpl::Number::operator+=(Number) : is normal");
    // *n = negative
    // *m = mantissa
@@ -699,10 +578,13 @@ Number::operator+=(Number const& y)

    // Need to use uint128_t, because large mantissas can overflow when added
    // together.
-    auto [xn, xm, xe] = toInternal<uint128_t>(range);
-
-    auto [yn, ym, ye] = y.toInternal<uint128_t>(range);
+    bool xn = negative_;
+    uint128_t xm = mantissa_;
+    auto xe = exponent_;

+    bool yn = y.negative_;
+    uint128_t ym = y.mantissa_;
+    auto ye = y.exponent_;
    Guard g;
    if (xe < ye)
    {
@@ -727,13 +609,14 @@ Number::operator+=(Number const& y)
        } while (xe > ye);
    }

+    auto const& range = range_.get();
    auto const& minMantissa = range.min;
    auto const& maxMantissa = range.max;

    if (xn == yn)
    {
        xm += ym;
-        if (xm > maxMantissa)
+        if (xm > maxMantissa || xm > maxRep)
        {
            g.push(xm % 10);
            xm /= 10;
@@ -754,7 +637,7 @@ Number::operator+=(Number const& y)
            xe = ye;
            xn = yn;
        }
-        while (xm < minMantissa)
+        while (xm < minMantissa && xm * 10 <= maxRep)
        {
            xm *= 10;
            xm -= g.pop();
@@ -763,8 +646,10 @@ Number::operator+=(Number const& y)
        g.doRoundDown(xn, xm, xe, minMantissa);
    }

-    normalize(xn, xm, xe, minMantissa, maxMantissa);
-    fromInternal(xn, xm, xe, &range);
+    negative_ = xn;
+    mantissa_ = static_cast<internalrep>(xm);
+    exponent_ = xe;
+    normalize();
    return *this;
 }

@@ -799,8 +684,6 @@ divu10(uint128_t& u)
 Number&
 Number::operator*=(Number const& y)
 {
-    auto const& range = range_.get();
-
    constexpr Number zero = Number{};
    if (*this == zero)
        return *this;
@@ -814,11 +697,15 @@ Number::operator*=(Number const& y)
    // *m = mantissa
    // *e = exponent

-    auto [xn, xm, xe] = toInternal(range);
+    bool xn = negative_;
    int xs = xn ? -1 : 1;
+    internalrep xm = mantissa_;
+    auto xe = exponent_;

-    auto [yn, ym, ye] = y.toInternal(range);
+    bool yn = y.negative_;
    int ys = yn ? -1 : 1;
+    internalrep ym = y.mantissa_;
+    auto ye = y.exponent_;

    auto zm = uint128_t(xm) * uint128_t(ym);
    auto ze = xe + ye;
@@ -828,10 +715,11 @@ Number::operator*=(Number const& y)
    if (zn)
        g.set_negative();

+    auto const& range = range_.get();
    auto const& minMantissa = range.min;
    auto const& maxMantissa = range.max;

-    while (zm > maxMantissa)
+    while (zm > maxMantissa || zm > maxRep)
    {
        // The following is optimization for:
        // g.push(static_cast<unsigned>(zm % 10));
@@ -848,17 +736,17 @@ Number::operator*=(Number const& y)
        minMantissa,
        maxMantissa,
        "Number::multiplication overflow : exponent is " + std::to_string(xe));
+    negative_ = zn;
+    mantissa_ = xm;
+    exponent_ = xe;

-    normalize(zn, xm, xe, minMantissa, maxMantissa);
-    fromInternal(zn, xm, xe, &range);
+    normalize();
    return *this;
 }

 Number&
 Number::operator/=(Number const& y)
 {
-    auto const& range = range_.get();
-
    constexpr Number zero = Number{};
    if (y == zero)
        throw std::overflow_error("Number: divide by 0");
@@ -871,12 +759,17 @@ Number::operator/=(Number const& y)
    // *m = mantissa
    // *e = exponent

-    auto [np, nm, ne] = toInternal(range);
+    bool np = negative_;
    int ns = (np ? -1 : 1);
+    auto nm = mantissa_;
+    auto ne = exponent_;

-    auto [dp, dm, de] = y.toInternal(range);
+    bool dp = y.negative_;
    int ds = (dp ? -1 : 1);
+    auto dm = y.mantissa_;
+    auto de = y.exponent_;

+    auto const& range = range_.get();
    auto const& minMantissa = range.min;
    auto const& maxMantissa = range.max;

@@ -888,7 +781,7 @@ Number::operator/=(Number const& y)
    // f can be up to 10^(38-19) = 10^19 safely
    static_assert(smallRange.log == 15);
    static_assert(largeRange.log == 18);
-    bool small = range.scale == MantissaRange::small;
+    bool small = Number::getMantissaScale() == MantissaRange::small;
    uint128_t const f =
        small ? 100'000'000'000'000'000 : 10'000'000'000'000'000'000ULL;
    XRPL_ASSERT_PARTS(
@@ -940,9 +833,11 @@ Number::operator/=(Number const& y)
        }
    }
    normalize(zn, zm, ze, minMantissa, maxMantissa);
-    fromInternal(zn, zm, ze, &range);
+    negative_ = zn;
+    mantissa_ = static_cast<internalrep>(zm);
+    exponent_ = ze;
    XRPL_ASSERT_PARTS(
-        isnormal(range), "xrpl::Number::operator/=", "result is normalized");
+        isnormal(), "xrpl::Number::operator/=", "result is normalized");

    return *this;
 }
@@ -954,7 +849,7 @@ Number::operator rep() const
    Guard g;
    if (drops != 0)
    {
-        if (drops < 0)
+        if (negative_)
        {
            g.set_negative();
            drops = -drops;
@@ -966,7 +861,7 @@ Number::operator rep() const
        }
        for (; offset > 0; --offset)
        {
-            if (drops >= largeRange.min)
+            if (drops > maxRep / 10)
                throw std::overflow_error("Number::operator rep() overflow");
            drops *= 10;
        }
@@ -996,22 +891,20 @@ Number::truncate() const noexcept
 std::string
 to_string(Number const& amount)
 {
-    auto const& range = Number::range_.get();
-
    // keep full internal accuracy, but make more human friendly if possible
    constexpr Number zero = Number{};
    if (amount == zero)
        return "0";

-    // The mantissa must have a set number of decimal places for this to work
-    auto [negative, mantissa, exponent] = amount.toInternal(range);
+    auto exponent = amount.exponent_;
+    auto mantissa = amount.mantissa_;
+    bool const negative = amount.negative_;

    // Use scientific notation for exponents that are too small or too large
-    auto const rangeLog = range.log;
-    if (((exponent != 0 && amount.exponent() != 0) &&
+    auto const rangeLog = Number::mantissaLog();
+    if (((exponent != 0) &&
         ((exponent < -(rangeLog + 10)) || (exponent > -(rangeLog - 10)))))
    {
-        // Remove trailing zeroes from the mantissa.
        while (mantissa != 0 && mantissa % 10 == 0 &&
               exponent < Number::maxExponent)
        {
@@ -1020,11 +913,8 @@ to_string(Number const& amount)
        }
        std::string ret = negative ? "-" : "";
        ret.append(std::to_string(mantissa));
-        if (exponent != 0)
-        {
-            ret.append(1, 'e');
-            ret.append(std::to_string(exponent));
-        }
+        ret.append(1, 'e');
+        ret.append(std::to_string(exponent));
        return ret;
    }

@@ -1113,11 +1003,20 @@ power(Number const& f, unsigned n)
    return r;
 }

+// Returns f^(1/d)
+// Uses Newton–Raphson iterations until the result stops changing
+// to find the non-negative root of the polynomial g(x) = x^d - f
+
+// This function, and power(Number f, unsigned n, unsigned d)
+// treat corner cases such as 0 roots as advised by Annex F of
+// the C standard, which itself is consistent with the IEEE
+// floating point standards.
+
 Number
-Number::root(MantissaRange const& range, Number f, unsigned d)
+root(Number f, unsigned d)
 {
    constexpr Number zero = Number{};
-    auto const one = Number::one(range);
+    auto const one = Number::one();

    if (f == one || d == 1)
        return f;
@@ -1134,30 +1033,22 @@ Number::root(MantissaRange const& range, Number f, unsigned d)
    if (f == zero)
        return f;

-    auto const [e, di] = [&]() {
-        auto const [negative, mantissa, exponent] = f.toInternal(range);
-
-        // Scale f into the range (0, 1) such that the scale change (e) is a
-        // multiple of the root (d)
-        auto e = exponent + range.log + 1;
-        auto const di = static_cast<int>(d);
-        auto ex = [e = e, di = di]()  // Euclidean remainder of e/d
-        {
-            int k = (e >= 0 ? e : e - (di - 1)) / di;
-            int k2 = e - k * di;
-            if (k2 == 0)
-                return 0;
-            return di - k2;
-        }();
-        e += ex;
-        f = f.shiftExponent(-e);  // f /= 10^e;
-        return std::make_tuple(e, di);
+    // Scale f into the range (0, 1) such that f's exponent is a multiple of d
+    auto e = f.exponent_ + Number::mantissaLog() + 1;
+    auto const di = static_cast<int>(d);
+    auto ex = [e = e, di = di]()  // Euclidean remainder of e/d
+    {
+        int k = (e >= 0 ? e : e - (di - 1)) / di;
+        int k2 = e - k * di;
+        if (k2 == 0)
+            return 0;
+        return di - k2;
    }();
+    e += ex;
+    f = f.shiftExponent(-e);  // f /= 10^e;

    XRPL_ASSERT_PARTS(
-        e % di == 0, "xrpl::root(Number, unsigned)", "e is divisible by d");
-    XRPL_ASSERT_PARTS(
-        f.isnormal(range), "xrpl::root(Number, unsigned)", "f is normalized");
+        f.isnormal(), "xrpl::root(Number, unsigned)", "f is normalized");
    bool neg = false;
    if (f < zero)
    {
@@ -1191,34 +1082,17 @@ Number::root(MantissaRange const& range, Number f, unsigned d)
    //  return r * 10^(e/d) to reverse scaling
    auto const result = r.shiftExponent(e / di);
    XRPL_ASSERT_PARTS(
-        result.isnormal(range),
+        result.isnormal(),
        "xrpl::root(Number, unsigned)",
        "result is normalized");
    return result;
 }

-// Returns f^(1/d)
-// Uses Newton–Raphson iterations until the result stops changing
-// to find the non-negative root of the polynomial g(x) = x^d - f
-
-// This function, and power(Number f, unsigned n, unsigned d)
-// treat corner cases such as 0 roots as advised by Annex F of
-// the C standard, which itself is consistent with the IEEE
-// floating point standards.
-
-Number
-root(Number f, unsigned d)
-{
-    auto const& range = Number::range_.get();
-    return Number::root(range, f, d);
-}
-
 Number
 root2(Number f)
 {
-    auto const& range = Number::range_.get();
    constexpr Number zero = Number{};
-    auto const one = Number::one(range);
+    auto const one = Number::one();

    if (f == one)
        return f;
@@ -1227,19 +1101,12 @@ root2(Number f)
    if (f == zero)
        return f;

-    auto const e = [&]() {
-        auto const [negative, mantissa, exponent] = f.toInternal(range);
-
-        // Scale f into the range (0, 1) such that f's exponent is a
-        // multiple of d
-        auto e = exponent + range.log + 1;
-        if (e % 2 != 0)
-            ++e;
-        f = f.shiftExponent(-e);  // f /= 10^e;
-        return e;
-    }();
-    XRPL_ASSERT_PARTS(
-        f.isnormal(range), "xrpl::root2(Number)", "f is normalized");
+    // Scale f into the range (0, 1) such that f's exponent is a multiple of d
+    auto e = f.exponent_ + Number::mantissaLog() + 1;
+    if (e % 2 != 0)
+        ++e;
+    f = f.shiftExponent(-e);  // f /= 10^e;
+    XRPL_ASSERT_PARTS(f.isnormal(), "xrpl::root2(Number)", "f is normalized");

    // Quadratic least squares curve fit of f^(1/d) in the range [0, 1]
    auto const D = 105;
@@ -1262,7 +1129,7 @@ root2(Number f)
    //  return r * 10^(e/2) to reverse scaling
    auto const result = r.shiftExponent(e / 2);
    XRPL_ASSERT_PARTS(
-        result.isnormal(range), "xrpl::root2(Number)", "result is normalized");
+        result.isnormal(), "xrpl::root2(Number)", "result is normalized");

    return result;
 }
@@ -1272,10 +1139,8 @@ root2(Number f)
 Number
 power(Number const& f, unsigned n, unsigned d)
 {
-    auto const& range = Number::range_.get();
-
    constexpr Number zero = Number{};
-    auto const one = Number::one(range);
+    auto const one = Number::one();

    if (f == one)
        return f;
@@ -1297,7 +1162,7 @@ power(Number const& f, unsigned n, unsigned d)
    d /= g;
    if ((n % 2) == 1 && (d % 2) == 0 && f < zero)
        throw std::overflow_error("Number::power nan");
-    return Number::root(range, power(f, n), d);
+    return root(power(f, n), d);
 }

 }  // namespace ripple
--- a/src/libxrpl/protocol/BuildInfo.cpp
+++ b/src/libxrpl/protocol/BuildInfo.cpp
@@ -36,7 +36,7 @@ namespace BuildInfo {
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
-char const* const versionString = "3.1.0-rc2"
+char const* const versionString = "3.1.0-rc1"
 // clang-format on

 #if defined(DEBUG) || defined(SANITIZER)
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -142,8 +142,6 @@ areComparable(STAmount const& v1, STAmount const& v2)
    return false;
 }

-static_assert(INITIAL_XRP.drops() == STAmount::cMaxNativeN);
-
 STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name)
 {
    std::uint64_t value = sit.get64();
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -599,12 +599,6 @@ STObject::delField(int index)
    v_.erase(v_.begin() + index);
 }

-SOEStyle
-STObject::getStyle(SField const& field) const
-{
-    return mType ? mType->style(field) : soeINVALID;
-}
-
 unsigned char
 STObject::getFieldU8(SField const& field) const
 {
--- a/src/libxrpl/protocol/STTakesAsset.cpp
+++ b/src/libxrpl/protocol/STTakesAsset.cpp
@@ -18,28 +18,10 @@ associateAsset(SLE& sle, Asset const& asset)
            // If the field is not set or present, skip it.
            if (type == STI_NOTPRESENT)
                continue;
-
            // If the type doesn't downcast, then the flag shouldn't be on the
            // SField
            auto& ta = entry.downcast<STTakesAsset>();
-            auto const style = sle.getStyle(ta.getFName());
-            XRPL_ASSERT_PARTS(
-                style != soeINVALID,
-                "ripple::associateAsset",
-                "valid template element style");
-
-            XRPL_ASSERT_PARTS(
-                style != soeDEFAULT || !ta.isDefault(),
-                "ripple::associateAsset",
-                "non-default value");
            ta.associateAsset(asset);
-
-            // associateAsset in derived classes may change the underlying
-            // value, but it won't know anything about how the value relates to
-            // the SLE. If the template element is soeDEFAULT, and the value
-            // changed to the default value, remove the field.
-            if (style == soeDEFAULT && ta.isDefault())
-                sle.makeFieldAbsent(field);
        }
    }
 }
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -7644,6 +7644,154 @@ protected:
        BEAST_EXPECT(afterSecondCoverAvailable == 0);
    }

+    void
+    testYieldTheftRounding(std::uint32_t flags)
+    {
+        testcase("Yield Theft via Rounding Manipulation");
+        using namespace jtx;
+        using namespace loan;
+
+        // 1. Setup Environment
+        Env env(*this, all);
+        Account const issuer{"issuer"};
+        Account const lender{"lender"};
+        Account const borrower{"borrower"};
+
+        env.fund(XRP(1000), issuer, lender, borrower);
+        env.close();
+
+        // 2. Asset Selection
+        PrettyAsset const iou = issuer["USD"];
+        env(trust(lender, iou(100'000'000)));
+        env(trust(borrower, iou(100'000'000)));
+        env(pay(issuer, lender, iou(100'000'000)));
+        env(pay(issuer, borrower, iou(100'000'000)));
+        env.close();
+
+        // 3. Create Vault and Broker with High Debt Limit (100M)
+        auto const brokerInfo = createVaultAndBroker(
+            env,
+            iou,
+            lender,
+            {
+                .vaultDeposit = 1'000'000,
+                .debtMax = Number{100'000'000},
+            });
+        auto const [currentSeq, vaultId, vaultKeylet] = [&]() {
+            auto const brokerSle =
+                env.le(keylet::loanbroker(brokerInfo.brokerID));
+            auto const currentSeq = brokerSle->at(sfLoanSequence);
+            auto const vaultKeylet = keylet::vault(brokerSle->at(sfVaultID));
+            auto const vaultId = brokerSle->at(sfVaultID);
+            return std::make_tuple(currentSeq, vaultId, vaultKeylet);
+        }();
+        Vault vault{env};
+        env(vault.deposit(
+            {.depositor = lender, .id = vaultId, .amount = iou(5'000'000)}));
+        env.close();
+        env(loanBroker::coverDeposit(
+            lender, brokerInfo.brokerID, iou(500'000)));
+        env.close();
+
+        // 4. Loan Parameters (Attack Vector)
+        Number const principal = 1'000'000;
+        TenthBips32 const interestRate = TenthBips32{1};  // 0.001%
+        std::uint32_t const paymentInterval = 86400;
+        std::uint32_t const paymentTotal = 3650;
+
+        auto const loanSetFee = fee(env.current()->fees().base * 2);
+        env(set(borrower, brokerInfo.brokerID, iou(principal).value(), flags),
+            sig(sfCounterpartySignature, lender),
+            loan::interestRate(interestRate),
+            loan::paymentInterval(paymentInterval),
+            loan::paymentTotal(paymentTotal),
+            fee(loanSetFee));
+        env.close();
+
+        // --- RETRIEVE OBJECTS & SETUP ATTACK ---
+
+        auto const loanKeylet = keylet::loan(brokerInfo.brokerID, currentSeq);
+        auto const [periodicPayment, loanScale] = [&]() {
+            auto const loanSle = env.le(loanKeylet);
+            // Construct Payment
+            return std::make_tuple(
+                STAmount{iou, loanSle->at(sfPeriodicPayment)},
+                loanSle->at(sfLoanScale));
+        }();
+        auto const roundedPayment =
+            roundToScale(periodicPayment, loanScale, Number::upward);
+
+        // ATTACK: Add dust buffer (1e-9) to force 'excess' logic execution
+        STAmount const paymentBuffer{iou, Number(1, -9)};
+        STAmount const attackPayment = periodicPayment + paymentBuffer;
+
+        auto const initialVaultAssets = env.le(vaultKeylet)->at(sfAssetsTotal);
+
+        log << "Periodic Payment: " << periodicPayment.value() << std::endl;
+        log << "Attack Payment:   " << attackPayment.value() << std::endl;
+        log << "Initial Vault Assets: " << initialVaultAssets << std::endl;
+
+        // 5. Execution Loop
+        int yieldTheftCount = 0;
+        auto previousAssetsTotal = initialVaultAssets;
+
+        auto borrowerBalance = [&]() { return env.balance(borrower, iou); };
+
+        for (int i = 0; i < 100; ++i)
+        {
+            auto const balanceBefore = borrowerBalance();
+            env(pay(borrower, loanKeylet.key, attackPayment, flags));
+            env.close();
+            auto const borrowerDelta = borrowerBalance() - balanceBefore;
+
+            auto const loanSle = env.le(loanKeylet);
+            if (!BEAST_EXPECT(loanSle))
+                break;
+            auto const updatedPayment =
+                STAmount{iou, loanSle->at(sfPeriodicPayment)};
+            BEAST_EXPECT(
+                (roundToScale(updatedPayment, loanScale, Number::upward) ==
+                 roundedPayment));
+            BEAST_EXPECT(
+                (updatedPayment == periodicPayment) ||
+                (flags == tfLoanOverpayment && i >= 2 &&
+                 updatedPayment < periodicPayment));
+
+            auto const currentVaultSle = env.le(vaultKeylet);
+            if (!BEAST_EXPECT(currentVaultSle))
+                break;
+
+            auto const currentAssetsTotal = currentVaultSle->at(sfAssetsTotal);
+            auto const delta = currentAssetsTotal - previousAssetsTotal;
+
+            BEAST_EXPECT(
+                (delta == beast::zero && borrowerDelta <= roundedPayment) ||
+                (delta > beast::zero && borrowerDelta > roundedPayment));
+
+            // If tx succeeded but Assets Total didn't change, interest was
+            // stolen.
+            if (delta == beast::zero && borrowerDelta > roundedPayment)
+            {
+                yieldTheftCount++;
+                // delta should be zero
+                log << "[ALERT] Iteration " << i
+                    << ": YIELD THEFT CONFIRMED. Vault Delta: " << delta
+                    << std::endl;
+            }
+            else
+            {
+                log << "[INFO]  Iteration " << i << ": Normal Yield: " << delta
+                    << std::endl;
+            }
+
+            previousAssetsTotal = currentAssetsTotal;
+        }
+
+        BEAST_EXPECTS(yieldTheftCount == 0, std::to_string(yieldTheftCount));
+        log << "[RESULT] Yield Theft Events: " << yieldTheftCount
+            << " / 50 payments." << std::endl;
+    }
+
 public:
    void
    run() override
@@ -7652,6 +7800,11 @@ public:
        testLoanPayLateFullPaymentBypassesPenalties();
        testLoanCoverMinimumRoundingExploit();
 #endif
+        for (auto const flags : {0u, tfLoanOverpayment})
+        {
+            testYieldTheftRounding(flags);
+        }
+
        testInvalidLoanSet();

        testCoverDepositWithdrawNonTransferableMPT();
--- a/src/test/app/Vault_test.cpp
+++ b/src/test/app/Vault_test.cpp
@@ -5801,263 +5801,6 @@ class Vault_test : public beast::unit_test::suite
        testCase(MPT, "MPT", owner, depositor, issuer);
    }

-    void
-    testAssetsMaximum()
-    {
-        testcase("Assets Maximum");
-
-        using namespace test::jtx;
-
-        Env env{*this, testable_amendments() | featureSingleAssetVault};
-        Account const owner{"owner"};
-        Account const issuer{"issuer"};
-
-        Vault vault{env};
-        env.fund(XRP(1'000'000), issuer, owner);
-        env.close();
-
-        auto const maxInt64 =
-            std::to_string(std::numeric_limits<std::int64_t>::max());
-        BEAST_EXPECT(maxInt64 == "9223372036854775807");
-
-        // Naming things is hard
-        auto const maxInt64Plus1 = std::to_string(
-            static_cast<std::uint64_t>(
-                std::numeric_limits<std::int64_t>::max()) +
-            1);
-        BEAST_EXPECT(maxInt64Plus1 == "9223372036854775808");
-
-        auto const initialXRP = to_string(INITIAL_XRP);
-        BEAST_EXPECT(initialXRP == "100000000000000000");
-
-        auto const initialXRPPlus1 = to_string(INITIAL_XRP + 1);
-        BEAST_EXPECT(initialXRPPlus1 == "100000000000000001");
-
-        {
-            testcase("Assets Maximum: XRP");
-
-            PrettyAsset const xrpAsset = xrpIssue();
-
-            auto [tx, keylet] =
-                vault.create({.owner = owner, .asset = xrpAsset});
-            tx[sfData] = "4D65746144617461";
-
-            tx[sfAssetsMaximum] = maxInt64;
-            env(tx, ter(tefEXCEPTION), THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
-            env.close();
-
-            // This value will be rounded
-            auto const insertAt = maxInt64Plus1.size() - 3;
-            auto const decimalTest = maxInt64Plus1.substr(0, insertAt) + "." +
-                maxInt64Plus1.substr(insertAt);  // (max int64+1) / 1000
-            BEAST_EXPECT(decimalTest == "9223372036854775.808");
-            tx[sfAssetsMaximum] = decimalTest;
-            auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-            env(tx, THISLINE);
-            env.close();
-
-            auto const vaultSle = env.le(newKeylet);
-            if (!BEAST_EXPECT(vaultSle))
-                return;
-
-            BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) == 9223372036854776);
-        }
-
-        {
-            testcase("Assets Maximum: MPT");
-
-            PrettyAsset const mptAsset = [&]() {
-                MPTTester mptt{env, issuer, mptInitNoFund};
-                mptt.create(
-                    {.flags =
-                         tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
-                env.close();
-                PrettyAsset const mptAsset = mptt["MPT"];
-                mptt.authorize({.account = owner});
-                env.close();
-                return mptAsset;
-            }();
-
-            env(pay(issuer, owner, mptAsset(100'000)), THISLINE);
-            env.close();
-
-            auto [tx, keylet] =
-                vault.create({.owner = owner, .asset = mptAsset});
-            tx[sfData] = "4D65746144617461";
-
-            tx[sfAssetsMaximum] = maxInt64;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
-            env.close();
-
-            // This value will be rounded
-            auto const insertAt = maxInt64Plus1.size() - 1;
-            auto const decimalTest = maxInt64Plus1.substr(0, insertAt) + "." +
-                maxInt64Plus1.substr(insertAt);  // (max int64+1) / 10
-            BEAST_EXPECT(decimalTest == "922337203685477580.8");
-            tx[sfAssetsMaximum] = decimalTest;
-            auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-            env(tx, THISLINE);
-            env.close();
-
-            auto const vaultSle = env.le(newKeylet);
-            if (!BEAST_EXPECT(vaultSle))
-                return;
-
-            BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) == 922337203685477581);
-        }
-
-        {
-            testcase("Assets Maximum: IOU");
-
-            // Almost anything goes with IOUs
-            PrettyAsset iouAsset = issuer["IOU"];
-            env.trust(iouAsset(1000), owner);
-            env(pay(issuer, owner, iouAsset(200)));
-            env.close();
-
-            auto [tx, keylet] =
-                vault.create({.owner = owner, .asset = iouAsset});
-            tx[sfData] = "4D65746144617461";
-
-            tx[sfAssetsMaximum] = maxInt64;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, THISLINE);
-            env.close();
-
-            tx[sfAssetsMaximum] = "1000000000000000e80";
-            env.close();
-
-            tx[sfAssetsMaximum] = "1000000000000000e-96";
-            env.close();
-
-            // These values will be rounded to 15 significant digits
-            {
-                auto const insertAt = maxInt64Plus1.size() - 1;
-                auto const decimalTest = maxInt64Plus1.substr(0, insertAt) +
-                    "." + maxInt64Plus1.substr(insertAt);  // (max int64+1) / 10
-                BEAST_EXPECT(decimalTest == "922337203685477580.8");
-                tx[sfAssetsMaximum] = decimalTest;
-                auto const newKeylet =
-                    keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
-                env.close();
-
-                auto const vaultSle = env.le(newKeylet);
-                if (!BEAST_EXPECT(vaultSle))
-                    return;
-
-                BEAST_EXPECT(
-                    (vaultSle->at(sfAssetsMaximum) ==
-                     Number{9223372036854776, 2, Number::normalized{}}));
-            }
-            {
-                tx[sfAssetsMaximum] =
-                    "9223372036854775807e40";  // max int64 * 10^40
-                auto const newKeylet =
-                    keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
-                env.close();
-
-                auto const vaultSle = env.le(newKeylet);
-                if (!BEAST_EXPECT(vaultSle))
-                    return;
-
-                BEAST_EXPECT(
-                    (vaultSle->at(sfAssetsMaximum) ==
-                     Number{9223372036854776, 43, Number::normalized{}}));
-            }
-            {
-                tx[sfAssetsMaximum] =
-                    "9223372036854775807e-40";  // max int64 * 10^-40
-                auto const newKeylet =
-                    keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
-                env.close();
-
-                auto const vaultSle = env.le(newKeylet);
-                if (!BEAST_EXPECT(vaultSle))
-                    return;
-
-                BEAST_EXPECT(
-                    (vaultSle->at(sfAssetsMaximum) ==
-                     Number{9223372036854776, -37, Number::normalized{}}));
-            }
-            {
-                tx[sfAssetsMaximum] =
-                    "9223372036854775807e-100";  // max int64 * 10^-100
-                auto const newKeylet =
-                    keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
-                env.close();
-
-                // Field 'AssetsMaximum' may not be explicitly set to default.
-                auto const vaultSle = env.le(newKeylet);
-                if (!BEAST_EXPECT(vaultSle))
-                    return;
-
-                BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) == numZero);
-            }
-
-            // What _can't_ IOUs do?
-            // 1. Exceed maximum exponent / offset
-            tx[sfAssetsMaximum] = "1000000000000000e81";
-            env(tx, ter(tefEXCEPTION), THISLINE);
-            env.close();
-
-            // 2. Mantissa larger than uint64 max
-            try
-            {
-                tx[sfAssetsMaximum] =
-                    "18446744073709551617e5";  // uint64 max + 1
-                env(tx, THISLINE);
-                BEAST_EXPECT(false);
-            }
-            catch (parse_error const& e)
-            {
-                using namespace std::string_literals;
-                BEAST_EXPECT(
-                    e.what() ==
-                    "invalidParamsField 'tx_json.AssetsMaximum' has invalid "
-                    "data."s);
-            }
-        }
-    }
-
 public:
    void
    run() override
@@ -6078,7 +5821,6 @@ public:
        testDelegate();
        testVaultClawbackBurnShares();
        testVaultClawbackAssets();
-        testAssetsMaximum();
    }
 };

--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -51,10 +51,9 @@ public:
    test_limits()
    {
        auto const scale = Number::getMantissaScale();
-        auto const minMantissa = Number::minMantissa();
-
-        testcase << "test_limits " << to_string(scale) << ", " << minMantissa;
+        testcase << "test_limits " << to_string(scale);
        bool caught = false;
+        auto const minMantissa = Number::minMantissa();
        try
        {
            Number x =
@@ -82,9 +81,8 @@ public:
            Number{},
            __LINE__);
        test(
-            // Use 1501 to force rounding up
            Number{false, minMantissa, 32000, Number::normalized{}} * 1'000 +
-                Number{false, 1'501, 32000, Number::normalized{}},
+                Number{false, 1'500, 32000, Number::normalized{}},
            Number{false, minMantissa + 2, 32003, Number::normalized{}},
            __LINE__);
        // 9,223,372,036,854,775,808
@@ -219,12 +217,12 @@ public:
                     9'999'999'999'999'999'990ULL,
                     -19,
                     Number::normalized{}}},
-                {Number{Number::largestMantissa},
+                {Number{Number::maxRep},
                 Number{6, -1},
-                 Number{Number::largestMantissa / 10, 1}},
-                {Number{Number::largestMantissa - 1},
+                 Number{Number::maxRep / 10, 1}},
+                {Number{Number::maxRep - 1},
                 Number{1, 0},
-                 Number{Number::largestMantissa}},
+                 Number{Number::maxRep}},
                // Test extremes
                {
                    // Each Number operand rounds up, so the actual mantissa is
@@ -242,30 +240,11 @@ public:
                    Number{2, 19},
                },
                {
-                    // Does not round. Mantissas are going to be >
-                    // largestMantissa, so if added together as uint64_t's, the
-                    // result will overflow. With addition using uint128_t,
-                    // there's no problem. After normalizing, the resulting
-                    // mantissa ends up less than largestMantissa.
-                    Number{
-                        false,
-                        Number::largestMantissa,
-                        0,
-                        Number::normalized{}},
-                    Number{
-                        false,
-                        Number::largestMantissa,
-                        0,
-                        Number::normalized{}},
-                    Number{
-                        false,
-                        Number::largestMantissa * 2,
-                        0,
-                        Number::normalized{}},
-                },
-                {
-                    // These mantissas round down, so adding them together won't
-                    // have any consequences.
+                    // Does not round. Mantissas are going to be > maxRep, so if
+                    // added together as uint64_t's, the result will overflow.
+                    // With addition using uint128_t, there's no problem. After
+                    // normalizing, the resulting mantissa ends up less than
+                    // maxRep.
                    Number{
                        false,
                        9'999'999'999'999'999'990ULL,
@@ -392,24 +371,16 @@ public:
                {Number{1'000'000'000'000'000'001, -18},
                 Number{1'000'000'000'000'000'000, -18},
                 Number{1'000'000'000'000'000'000, -36}},
-                {Number{Number::largestMantissa},
+                {Number{Number::maxRep},
                 Number{6, -1},
-                 Number{Number::largestMantissa - 1}},
-                {Number{
-                     false,
-                     Number::largestMantissa + 1,
-                     0,
-                     Number::normalized{}},
+                 Number{Number::maxRep - 1}},
+                {Number{false, Number::maxRep + 1, 0, Number::normalized{}},
                 Number{1, 0},
-                 Number{Number::largestMantissa / 10 + 1, 1}},
-                {Number{
-                     false,
-                     Number::largestMantissa + 1,
-                     0,
-                     Number::normalized{}},
+                 Number{Number::maxRep / 10 + 1, 1}},
+                {Number{false, Number::maxRep + 1, 0, Number::normalized{}},
                 Number{3, 0},
-                 Number{Number::largestMantissa}},
-                {power(2, 63), Number{3, 0}, Number{Number::largestMantissa}},
+                 Number{Number::maxRep}},
+                {power(2, 63), Number{3, 0}, Number{Number::maxRep}},
            });
        auto test = [this](auto const& c) {
            for (auto const& [x, y, z] : c)
@@ -432,16 +403,14 @@ public:
        auto const scale = Number::getMantissaScale();
        testcase << "test_mul " << to_string(scale);

-        // Case: Factor 1, Factor 2, Expected product, Line number
-        using Case = std::tuple<Number, Number, Number, int>;
+        using Case = std::tuple<Number, Number, Number>;
        auto test = [this](auto const& c) {
-            for (auto const& [x, y, z, line] : c)
+            for (auto const& [x, y, z] : c)
            {
                auto const result = x * y;
                std::stringstream ss;
                ss << x << " * " << y << " = " << result << ". Expected: " << z;
-                BEAST_EXPECTS(
-                    result == z, ss.str() + " line: " + std::to_string(line));
+                BEAST_EXPECTS(result == z, ss.str());
            }
        };
        auto tests = [&](auto const& cSmall, auto const& cLarge) {
@@ -451,105 +420,78 @@ public:
                test(cLarge);
        };
        auto const maxMantissa = Number::maxMantissa();
-        auto const maxInternalMantissa =
-            static_cast<std::uint64_t>(
-                static_cast<std::int64_t>(power(10, Number::mantissaLog()))) *
-                10 -
-            1;

        saveNumberRoundMode save{Number::setround(Number::to_nearest)};
        {
            auto const cSmall = std::to_array<Case>({
-                {Number{7}, Number{8}, Number{56}, __LINE__},
+                {Number{7}, Number{8}, Number{56}},
                {Number{1414213562373095, -15},
                 Number{1414213562373095, -15},
-                 Number{2000000000000000, -15},
-                 __LINE__},
+                 Number{2000000000000000, -15}},
                {Number{-1414213562373095, -15},
                 Number{1414213562373095, -15},
-                 Number{-2000000000000000, -15},
-                 __LINE__},
+                 Number{-2000000000000000, -15}},
                {Number{-1414213562373095, -15},
                 Number{-1414213562373095, -15},
-                 Number{2000000000000000, -15},
-                 __LINE__},
+                 Number{2000000000000000, -15}},
                {Number{3214285714285706, -15},
                 Number{3111111111111119, -15},
-                 Number{1000000000000000, -14},
-                 __LINE__},
+                 Number{1000000000000000, -14}},
                {Number{1000000000000000, -32768},
                 Number{1000000000000000, -32768},
-                 Number{0},
-                 __LINE__},
+                 Number{0}},
                // Maximum mantissa range
                {Number{9'999'999'999'999'999, 0},
                 Number{9'999'999'999'999'999, 0},
-                 Number{9'999'999'999'999'998, 16},
-                 __LINE__},
+                 Number{9'999'999'999'999'998, 16}},
            });
            auto const cLarge = std::to_array<Case>({
                // Note that items with extremely large mantissas need to be
                // calculated, because otherwise they overflow uint64. Items
                // from C with larger mantissa
-                {Number{7}, Number{8}, Number{56}, __LINE__},
+                {Number{7}, Number{8}, Number{56}},
                {Number{1414213562373095, -15},
                 Number{1414213562373095, -15},
-                 Number{1999999999999999862, -18},
-                 __LINE__},
+                 Number{1999999999999999862, -18}},
                {Number{-1414213562373095, -15},
                 Number{1414213562373095, -15},
-                 Number{-1999999999999999862, -18},
-                 __LINE__},
+                 Number{-1999999999999999862, -18}},
                {Number{-1414213562373095, -15},
                 Number{-1414213562373095, -15},
-                 Number{1999999999999999862, -18},
-                 __LINE__},
+                 Number{1999999999999999862, -18}},
                {Number{3214285714285706, -15},
                 Number{3111111111111119, -15},
                 Number{
                     false,
                     9'999'999'999'999'999'579ULL,
                     -18,
-                     Number::normalized{}},
-                 __LINE__},
+                     Number::normalized{}}},
                {Number{1000000000000000000, -32768},
                 Number{1000000000000000000, -32768},
-                 Number{0},
-                 __LINE__},
+                 Number{0}},
                // Items from cSmall expanded for the larger mantissa,
                // except duplicates. Sadly, it looks like sqrt(2)^2 != 2
                // with higher precision
                {Number{1414213562373095049, -18},
                 Number{1414213562373095049, -18},
-                 Number{2000000000000000001, -18},
-                 __LINE__},
+                 Number{2000000000000000001, -18}},
                {Number{-1414213562373095048, -18},
                 Number{1414213562373095048, -18},
-                 Number{-1999999999999999998, -18},
-                 __LINE__},
+                 Number{-1999999999999999998, -18}},
                {Number{-1414213562373095048, -18},
                 Number{-1414213562373095049, -18},
-                 Number{1999999999999999999, -18},
-                 __LINE__},
+                 Number{1999999999999999999, -18}},
                {Number{3214285714285714278, -18},
                 Number{3111111111111111119, -18},
-                 Number{10, 0},
-                 __LINE__},
-                // Maximum internal mantissa range - rounds up to 1e19
-                {Number{false, maxInternalMantissa, 0, Number::normalized{}},
-                 Number{false, maxInternalMantissa, 0, Number::normalized{}},
-                 Number{1, 38},
-                 __LINE__},
-                // Maximum actual mantissa range - same as int64 range
+                 Number{10, 0}},
+                // Maximum mantissa range - rounds up to 1e19
                {Number{false, maxMantissa, 0, Number::normalized{}},
                 Number{false, maxMantissa, 0, Number::normalized{}},
-                 Number{85'070'591'730'234'615'85, 19},
-                 __LINE__},
+                 Number{1, 38}},
                // Maximum int64 range
-                {Number{Number::largestMantissa, 0},
-                 Number{Number::largestMantissa, 0},
-                 Number{85'070'591'730'234'615'85, 19},
-                 __LINE__},
+                {Number{Number::maxRep, 0},
+                 Number{Number::maxRep, 0},
+                 Number{85'070'591'730'234'615'85, 19}},
            });
            tests(cSmall, cLarge);
        }
@@ -558,100 +500,76 @@ public:
                 << " towards_zero";
        {
            auto const cSmall = std::to_array<Case>(
-                {{Number{7}, Number{8}, Number{56}, __LINE__},
+                {{Number{7}, Number{8}, Number{56}},
                 {Number{1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{1999999999999999, -15},
-                  __LINE__},
+                  Number{1999999999999999, -15}},
                 {Number{-1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{-1999999999999999, -15},
-                  __LINE__},
+                  Number{-1999999999999999, -15}},
                 {Number{-1414213562373095, -15},
                  Number{-1414213562373095, -15},
-                  Number{1999999999999999, -15},
-                  __LINE__},
+                  Number{1999999999999999, -15}},
                 {Number{3214285714285706, -15},
                  Number{3111111111111119, -15},
-                  Number{9999999999999999, -15},
-                  __LINE__},
+                  Number{9999999999999999, -15}},
                 {Number{1000000000000000, -32768},
                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{0}}});
            auto const cLarge = std::to_array<Case>(
                // Note that items with extremely large mantissas need to be
                // calculated, because otherwise they overflow uint64. Items
                // from C with larger mantissa
                {
-                    {Number{7}, Number{8}, Number{56}, __LINE__},
+                    {Number{7}, Number{8}, Number{56}},
                    {Number{1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{1999999999999999861, -18},
-                     __LINE__},
+                     Number{1999999999999999861, -18}},
                    {Number{-1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{-1999999999999999861, -18},
-                     __LINE__},
+                     Number{-1999999999999999861, -18}},
                    {Number{-1414213562373095, -15},
                     Number{-1414213562373095, -15},
-                     Number{1999999999999999861, -18},
-                     __LINE__},
+                     Number{1999999999999999861, -18}},
                    {Number{3214285714285706, -15},
                     Number{3111111111111119, -15},
                     Number{
                         false,
                         9999999999999999579ULL,
                         -18,
-                         Number::normalized{}},
-                     __LINE__},
+                         Number::normalized{}}},
                    {Number{1000000000000000000, -32768},
                     Number{1000000000000000000, -32768},
-                     Number{0},
-                     __LINE__},
+                     Number{0}},
                    // Items from cSmall expanded for the larger mantissa,
                    // except duplicates. Sadly, it looks like sqrt(2)^2 != 2
                    // with higher precision
                    {Number{1414213562373095049, -18},
                     Number{1414213562373095049, -18},
-                     Number{2, 0},
-                     __LINE__},
+                     Number{2, 0}},
                    {Number{-1414213562373095048, -18},
                     Number{1414213562373095048, -18},
-                     Number{-1999999999999999997, -18},
-                     __LINE__},
+                     Number{-1999999999999999997, -18}},
                    {Number{-1414213562373095048, -18},
                     Number{-1414213562373095049, -18},
-                     Number{1999999999999999999, -18},
-                     __LINE__},
+                     Number{1999999999999999999, -18}},
                    {Number{3214285714285714278, -18},
                     Number{3111111111111111119, -18},
-                     Number{10, 0},
-                     __LINE__},
-                    // Maximum internal mantissa range - rounds down to
-                    // maxMantissa/10e1
+                     Number{10, 0}},
+                    // Maximum mantissa range - rounds down to maxMantissa/10e1
                    // 99'999'999'999'999'999'800'000'000'000'000'000'100
-                    {Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{
-                         false,
-                         maxInternalMantissa / 10 - 1,
-                         20,
-                         Number::normalized{}},
-                     __LINE__},
-                    // Maximum actual mantissa range - same as int64
                    {Number{false, maxMantissa, 0, Number::normalized{}},
                     Number{false, maxMantissa, 0, Number::normalized{}},
-                     Number{85'070'591'730'234'615'84, 19},
-                     __LINE__},
+                     Number{
+                         false,
+                         maxMantissa / 10 - 1,
+                         20,
+                         Number::normalized{}}},
                    // Maximum int64 range
                    // 85'070'591'730'234'615'847'396'907'784'232'501'249
-                    {Number{Number::largestMantissa, 0},
-                     Number{Number::largestMantissa, 0},
-                     Number{85'070'591'730'234'615'84, 19},
-                     __LINE__},
+                    {Number{Number::maxRep, 0},
+                     Number{Number::maxRep, 0},
+                     Number{85'070'591'730'234'615'84, 19}},
                });
            tests(cSmall, cLarge);
        }
@@ -660,100 +578,76 @@ public:
                 << " downward";
        {
            auto const cSmall = std::to_array<Case>(
-                {{Number{7}, Number{8}, Number{56}, __LINE__},
+                {{Number{7}, Number{8}, Number{56}},
                 {Number{1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{1999999999999999, -15},
-                  __LINE__},
+                  Number{1999999999999999, -15}},
                 {Number{-1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{-2000000000000000, -15},
-                  __LINE__},
+                  Number{-2000000000000000, -15}},
                 {Number{-1414213562373095, -15},
                  Number{-1414213562373095, -15},
-                  Number{1999999999999999, -15},
-                  __LINE__},
+                  Number{1999999999999999, -15}},
                 {Number{3214285714285706, -15},
                  Number{3111111111111119, -15},
-                  Number{9999999999999999, -15},
-                  __LINE__},
+                  Number{9999999999999999, -15}},
                 {Number{1000000000000000, -32768},
                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{0}}});
            auto const cLarge = std::to_array<Case>(
                // Note that items with extremely large mantissas need to be
                // calculated, because otherwise they overflow uint64. Items
                // from C with larger mantissa
                {
-                    {Number{7}, Number{8}, Number{56}, __LINE__},
+                    {Number{7}, Number{8}, Number{56}},
                    {Number{1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{1999999999999999861, -18},
-                     __LINE__},
+                     Number{1999999999999999861, -18}},
                    {Number{-1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{-1999999999999999862, -18},
-                     __LINE__},
+                     Number{-1999999999999999862, -18}},
                    {Number{-1414213562373095, -15},
                     Number{-1414213562373095, -15},
-                     Number{1999999999999999861, -18},
-                     __LINE__},
+                     Number{1999999999999999861, -18}},
                    {Number{3214285714285706, -15},
                     Number{3111111111111119, -15},
                     Number{
                         false,
                         9'999'999'999'999'999'579ULL,
                         -18,
-                         Number::normalized{}},
-                     __LINE__},
+                         Number::normalized{}}},
                    {Number{1000000000000000000, -32768},
                     Number{1000000000000000000, -32768},
-                     Number{0},
-                     __LINE__},
+                     Number{0}},
                    // Items from cSmall expanded for the larger mantissa,
                    // except duplicates. Sadly, it looks like sqrt(2)^2 != 2
                    // with higher precision
                    {Number{1414213562373095049, -18},
                     Number{1414213562373095049, -18},
-                     Number{2, 0},
-                     __LINE__},
+                     Number{2, 0}},
                    {Number{-1414213562373095048, -18},
                     Number{1414213562373095048, -18},
-                     Number{-1999999999999999998, -18},
-                     __LINE__},
+                     Number{-1999999999999999998, -18}},
                    {Number{-1414213562373095048, -18},
                     Number{-1414213562373095049, -18},
-                     Number{1999999999999999999, -18},
-                     __LINE__},
+                     Number{1999999999999999999, -18}},
                    {Number{3214285714285714278, -18},
                     Number{3111111111111111119, -18},
-                     Number{10, 0},
-                     __LINE__},
-                    // Maximum internal mantissa range - rounds down to
-                    // maxMantissa/10-1
+                     Number{10, 0}},
+                    // Maximum mantissa range - rounds down to maxMantissa/10e1
                    // 99'999'999'999'999'999'800'000'000'000'000'000'100
-                    {Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{
-                         false,
-                         maxInternalMantissa / 10 - 1,
-                         20,
-                         Number::normalized{}},
-                     __LINE__},
-                    // Maximum mantissa range - same as int64
                    {Number{false, maxMantissa, 0, Number::normalized{}},
                     Number{false, maxMantissa, 0, Number::normalized{}},
-                     Number{85'070'591'730'234'615'84, 19},
-                     __LINE__},
+                     Number{
+                         false,
+                         maxMantissa / 10 - 1,
+                         20,
+                         Number::normalized{}}},
                    // Maximum int64 range
                    // 85'070'591'730'234'615'847'396'907'784'232'501'249
-                    {Number{Number::largestMantissa, 0},
-                     Number{Number::largestMantissa, 0},
-                     Number{85'070'591'730'234'615'84, 19},
-                     __LINE__},
+                    {Number{Number::maxRep, 0},
+                     Number{Number::maxRep, 0},
+                     Number{85'070'591'730'234'615'84, 19}},
                });
            tests(cSmall, cLarge);
        }
@@ -762,91 +656,68 @@ public:
                 << " upward";
        {
            auto const cSmall = std::to_array<Case>(
-                {{Number{7}, Number{8}, Number{56}, __LINE__},
+                {{Number{7}, Number{8}, Number{56}},
                 {Number{1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{2000000000000000, -15},
-                  __LINE__},
+                  Number{2000000000000000, -15}},
                 {Number{-1414213562373095, -15},
                  Number{1414213562373095, -15},
-                  Number{-1999999999999999, -15},
-                  __LINE__},
+                  Number{-1999999999999999, -15}},
                 {Number{-1414213562373095, -15},
                  Number{-1414213562373095, -15},
-                  Number{2000000000000000, -15},
-                  __LINE__},
+                  Number{2000000000000000, -15}},
                 {Number{3214285714285706, -15},
                  Number{3111111111111119, -15},
-                  Number{1000000000000000, -14},
-                  __LINE__},
+                  Number{1000000000000000, -14}},
                 {Number{1000000000000000, -32768},
                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{0}}});
            auto const cLarge = std::to_array<Case>(
                // Note that items with extremely large mantissas need to be
                // calculated, because otherwise they overflow uint64. Items
                // from C with larger mantissa
                {
-                    {Number{7}, Number{8}, Number{56}, __LINE__},
+                    {Number{7}, Number{8}, Number{56}},
                    {Number{1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{1999999999999999862, -18},
-                     __LINE__},
+                     Number{1999999999999999862, -18}},
                    {Number{-1414213562373095, -15},
                     Number{1414213562373095, -15},
-                     Number{-1999999999999999861, -18},
-                     __LINE__},
+                     Number{-1999999999999999861, -18}},
                    {Number{-1414213562373095, -15},
                     Number{-1414213562373095, -15},
-                     Number{1999999999999999862, -18},
-                     __LINE__},
+                     Number{1999999999999999862, -18}},
                    {Number{3214285714285706, -15},
                     Number{3111111111111119, -15},
-                     Number{999999999999999958, -17},
-                     __LINE__},
+                     Number{999999999999999958, -17}},
                    {Number{1000000000000000000, -32768},
                     Number{1000000000000000000, -32768},
-                     Number{0},
-                     __LINE__},
+                     Number{0}},
                    // Items from cSmall expanded for the larger mantissa,
                    // except duplicates. Sadly, it looks like sqrt(2)^2 != 2
                    // with higher precision
                    {Number{1414213562373095049, -18},
                     Number{1414213562373095049, -18},
-                     Number{2000000000000000001, -18},
-                     __LINE__},
+                     Number{2000000000000000001, -18}},
                    {Number{-1414213562373095048, -18},
                     Number{1414213562373095048, -18},
-                     Number{-1999999999999999997, -18},
-                     __LINE__},
+                     Number{-1999999999999999997, -18}},
                    {Number{-1414213562373095048, -18},
                     Number{-1414213562373095049, -18},
-                     Number{2, 0},
-                     __LINE__},
+                     Number{2, 0}},
                    {Number{3214285714285714278, -18},
                     Number{3111111111111111119, -18},
-                     Number{1000000000000000001, -17},
-                     __LINE__},
-                    // Maximum internal mantissa range - rounds up to
-                    // minMantissa*10 1e19*1e19=1e38
-                    {Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{
-                         false, maxInternalMantissa, 0, Number::normalized{}},
-                     Number{1, 38},
-                     __LINE__},
-                    // Maximum mantissa range - same as int64
+                     Number{1000000000000000001, -17}},
+                    // Maximum mantissa range - rounds up to minMantissa*10
+                    // 1e19*1e19=1e38
                    {Number{false, maxMantissa, 0, Number::normalized{}},
                     Number{false, maxMantissa, 0, Number::normalized{}},
-                     Number{85'070'591'730'234'615'85, 19},
-                     __LINE__},
+                     Number{1, 38}},
                    // Maximum int64 range
                    // 85'070'591'730'234'615'847'396'907'784'232'501'249
-                    {Number{Number::largestMantissa, 0},
-                     Number{Number::largestMantissa, 0},
-                     Number{85'070'591'730'234'615'85, 19},
-                     __LINE__},
+                    {Number{Number::maxRep, 0},
+                     Number{Number::maxRep, 0},
+                     Number{85'070'591'730'234'615'85, 19}},
                });
            tests(cSmall, cLarge);
        }
@@ -1119,12 +990,6 @@ public:
        };
        */

-        auto const maxInternalMantissa =
-            static_cast<std::uint64_t>(
-                static_cast<std::int64_t>(power(10, Number::mantissaLog()))) *
-                10 -
-            1;
-
        auto const cSmall = std::to_array<Case>(
            {{Number{2}, 2, Number{1414213562373095049, -18}},
             {Number{2'000'000}, 2, Number{1414213562373095049, -15}},
@@ -1136,17 +1001,17 @@ public:
             {Number{0}, 5, Number{0}},
             {Number{5625, -4}, 2, Number{75, -2}}});
        auto const cLarge = std::to_array<Case>({
-            {Number{false, maxInternalMantissa - 9, -1, Number::normalized{}},
+            {Number{false, Number::maxMantissa() - 9, -1, Number::normalized{}},
             2,
             Number{false, 999'999'999'999'999'999, -9, Number::normalized{}}},
-            {Number{false, maxInternalMantissa - 9, 0, Number::normalized{}},
+            {Number{false, Number::maxMantissa() - 9, 0, Number::normalized{}},
             2,
             Number{
                 false, 3'162'277'660'168'379'330, -9, Number::normalized{}}},
-            {Number{Number::largestMantissa},
+            {Number{Number::maxRep},
             2,
             Number{false, 3'037'000'499'976049692, -9, Number::normalized{}}},
-            {Number{Number::largestMantissa},
+            {Number{Number::maxRep},
             4,
             Number{false, 55'108'98747006743627, -14, Number::normalized{}}},
        });
@@ -1196,9 +1061,6 @@ public:
            }
        };

-        auto const maxInternalMantissa =
-            power(10, Number::mantissaLog()) * 10 - 1;
-
        auto const cSmall = std::to_array<Number>({
            Number{2},
            Number{2'000'000},
@@ -1208,10 +1070,7 @@ public:
            Number{5, -1},
            Number{0},
            Number{5625, -4},
-            Number{Number::largestMantissa},
-            maxInternalMantissa,
-            Number{Number::minMantissa(), 0, Number::unchecked{}},
-            Number{Number::maxMantissa(), 0, Number::unchecked{}},
+            Number{Number::maxRep},
        });
        test(cSmall);
        bool caught = false;
@@ -1577,20 +1436,20 @@ public:
            case MantissaRange::large:
                // Test the edges
                // ((exponent < -(28)) || (exponent > -(8)))))
-                test(Number::min(), "922337203685477581e-32768");
+                test(Number::min(), "1e-32750");
                test(Number::max(), "9223372036854775807e32768");
                test(Number::lowest(), "-9223372036854775807e32768");
                {
                    NumberRoundModeGuard mg(Number::towards_zero);

                    auto const maxMantissa = Number::maxMantissa();
-                    BEAST_EXPECT(maxMantissa == 9'223'372'036'854'775'807ULL);
+                    BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
                    test(
                        Number{false, maxMantissa, 0, Number::normalized{}},
-                        "9223372036854775807");
+                        "9999999999999999990");
                    test(
                        Number{true, maxMantissa, 0, Number::normalized{}},
-                        "-9223372036854775807");
+                        "-9999999999999999990");

                    test(
                        Number{std::numeric_limits<std::int64_t>::max(), 0},
@@ -1831,7 +1690,7 @@ public:
            Number const initalXrp{INITIAL_XRP};
            BEAST_EXPECT(initalXrp.exponent() > 0);

-            Number const maxInt64{Number::largestMantissa};
+            Number const maxInt64{Number::maxRep};
            BEAST_EXPECT(maxInt64.exponent() > 0);
            // 85'070'591'730'234'615'865'843'651'857'942'052'864 - 38 digits
            BEAST_EXPECT(
@@ -1851,7 +1710,7 @@ public:
            Number const initalXrp{INITIAL_XRP};
            BEAST_EXPECT(initalXrp.exponent() <= 0);

-            Number const maxInt64{Number::largestMantissa};
+            Number const maxInt64{Number::maxRep};
            BEAST_EXPECT(maxInt64.exponent() <= 0);
            // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits
            BEAST_EXPECT(
@@ -1859,47 +1718,16 @@ public:

            NumberRoundModeGuard mg(Number::towards_zero);

-            {
-                auto const maxInternalMantissa =
-                    static_cast<std::uint64_t>(static_cast<std::int64_t>(
-                        power(10, Number::mantissaLog()))) *
-                        10 -
-                    1;
-
-                // Rounds down to fit under 2^63
-                Number const max =
-                    Number{false, maxInternalMantissa, 0, Number::normalized{}};
-                // No alterations by the accessors
-                BEAST_EXPECT(max.mantissa() == maxInternalMantissa / 10);
-                BEAST_EXPECT(max.exponent() == 1);
-                // 99'999'999'999'999'999'800'000'000'000'000'000'100 - also 38
-                // digits
-                BEAST_EXPECT(
-                    (power(max, 2) ==
-                     Number{
-                         false,
-                         maxInternalMantissa / 10 - 1,
-                         20,
-                         Number::normalized{}}));
-            }
-
-            {
-                auto const maxMantissa = Number::maxMantissa();
-                Number const max =
-                    Number{false, maxMantissa, 0, Number::normalized{}};
-                // No alterations by the accessors
-                BEAST_EXPECT(max.mantissa() == maxMantissa);
-                BEAST_EXPECT(max.exponent() == 0);
-                // 85'070'591'730'234'615'847'396'907'784'232'501'249 - also 38
-                // digits
-                BEAST_EXPECT(
-                    (power(max, 2) ==
-                     Number{
-                         false,
-                         85'070'591'730'234'615'84,
-                         19,
-                         Number::normalized{}}));
-            }
+            auto const maxMantissa = Number::maxMantissa();
+            Number const max =
+                Number{false, maxMantissa, 0, Number::normalized{}};
+            BEAST_EXPECT(max.mantissa() == maxMantissa / 10);
+            BEAST_EXPECT(max.exponent() == 1);
+            // 99'999'999'999'999'999'800'000'000'000'000'000'100 - also 38
+            // digits
+            BEAST_EXPECT((
+                power(max, 2) ==
+                Number{false, maxMantissa / 10 - 1, 20, Number::normalized{}}));
        }
    }

--- a/src/xrpld/app/misc/detail/LendingHelpers.cpp
+++ b/src/xrpld/app/misc/detail/LendingHelpers.cpp
@@ -1928,9 +1928,12 @@ loanMakePayment(

    // -------------------------------------------------------------
    // overpayment handling
+    auto const roundedAmount =
+        roundToAsset(asset, amount, loanScale, Number::towards_zero);
    if (paymentType == LoanPaymentType::overpayment &&
        loan->isFlag(lsfLoanOverpayment) && paymentRemainingProxy > 0 &&
-        totalPaid < amount && numPayments < loanMaximumPaymentsPerTransaction)
+        totalPaid < roundedAmount &&
+        numPayments < loanMaximumPaymentsPerTransaction)
    {
        TenthBips32 const overpaymentInterestRate{
            loan->at(sfOverpaymentInterestRate)};
@@ -1940,7 +1943,7 @@ loanMakePayment(
        // totalValueOutstanding, because that would have been processed as
        // another normal payment. But cap it just in case.
        Number const overpayment =
-            std::min(amount - totalPaid, *totalValueOutstandingProxy);
+            std::min(roundedAmount - totalPaid, *totalValueOutstandingProxy);

        detail::ExtendedPaymentComponents const overpaymentComponents =
            detail::computeOverpaymentComponents(
--- a/src/xrpld/app/tx/detail/LoanPay.cpp
+++ b/src/xrpld/app/tx/detail/LoanPay.cpp
@@ -8,6 +8,7 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TxFlags.h>

+#include <algorithm>
 #include <bit>

 namespace ripple {
@@ -430,9 +431,10 @@ LoanPay::doApply()
    // Vault object state changes
    view.update(vaultSle);

+    Number const assetsAvailableBefore = *assetsAvailableProxy;
+    Number const assetsTotalBefore = *assetsTotalProxy;
 #if !NDEBUG
    {
-        Number const assetsAvailableBefore = *assetsAvailableProxy;
        Number const pseudoAccountBalanceBefore = accountHolds(
            view,
            vaultPseudoAccount,
@@ -456,17 +458,6 @@ LoanPay::doApply()
        "rippled::LoanPay::doApply",
        "assets available must not be greater than assets outstanding");

-    if (*assetsAvailableProxy > *assetsTotalProxy)
-    {
-        // LCOV_EXCL_START
-        JLOG(j_.fatal()) << "Vault assets available must not be greater "
-                            "than assets outstanding. Available: "
-                         << *assetsAvailableProxy
-                         << ", Total: " << *assetsTotalProxy;
-        return tecINTERNAL;
-        // LCOV_EXCL_STOP
-    }
-
    JLOG(j_.debug()) << "total paid to vault raw: " << totalPaidToVaultRaw
                     << ", total paid to vault rounded: "
                     << totalPaidToVaultRounded
@@ -493,10 +484,70 @@ LoanPay::doApply()
    associateAsset(*vaultSle, asset);

    // Duplicate some checks after rounding
+    Number const assetsAvailableAfter = *assetsAvailableProxy;
+    Number const assetsTotalAfter = *assetsTotalProxy;
+
    XRPL_ASSERT_PARTS(
-        *assetsAvailableProxy <= *assetsTotalProxy,
+        assetsAvailableAfter <= *assetsTotalProxy,
        "xrpl::LoanPay::doApply",
        "assets available must not be greater than assets outstanding");
+    if (assetsAvailableAfter == assetsAvailableBefore)
+    {
+        // An unchanged assetsAvailable indicates that the amount paid to the
+        // vault was zero, or rounded to zero. That should be impossible, but I
+        // can't rule it out for extreme edge cases, so fail gracefully if it
+        // happens.
+        //
+        // LCOV_EXCL_START
+        JLOG(j_.warn()) << "LoanPay: Vault assets available unchanged after "
+                           "rounding: Before: "
+                        << assetsAvailableBefore
+                        << ", After: " << assetsAvailableAfter;
+        return tecPRECISION_LOSS;
+        // LCOV_EXCL_STOP
+    }
+    if (paymentParts->valueChange != beast::zero &&
+        assetsTotalAfter == assetsTotalBefore)
+    {
+        // Non-zero valueChange with an unchanged assetsTotal indicates that the
+        // actual value change rounded to zero. That should be impossible, but I
+        // can't rule it out for extreme edge cases, so fail gracefully if it
+        // happens.
+        //
+        // LCOV_EXCL_START
+        JLOG(j_.warn())
+            << "LoanPay: Vault assets expected change, but unchanged after "
+               "rounding: Before: "
+            << assetsTotalBefore << ", After: " << assetsTotalAfter
+            << ", ValueChange: " << paymentParts->valueChange;
+        return tecPRECISION_LOSS;
+        // LCOV_EXCL_STOP
+    }
+    if (paymentParts->valueChange == beast::zero &&
+        assetsTotalAfter != assetsTotalBefore)
+    {
+        // A change in assetsTotal when there was no valueChange indicates that
+        // something really weird happened. That should be flat out impossible.
+        //
+        // LCOV_EXCL_START
+        JLOG(j_.warn()) << "LoanPay: Vault assets changed unexpectedly after "
+                           "rounding: Before: "
+                        << assetsTotalBefore << ", After: " << assetsTotalAfter
+                        << ", ValueChange: " << paymentParts->valueChange;
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }
+    if (assetsAvailableAfter > *assetsTotalProxy)
+    {
+        // Assets available are not allowed to be larger than assets total.
+        // LCOV_EXCL_START
+        JLOG(j_.fatal())
+            << "LoanPay: Vault assets available must not be greater "
+               "than assets outstanding. Available: "
+            << assetsAvailableAfter << ", Total: " << *assetsTotalProxy;
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }

 #if !NDEBUG
    auto const accountBalanceBefore = accountHolds(
@@ -568,7 +619,6 @@ LoanPay::doApply()
        return ter;

 #if !NDEBUG
-    Number const assetsAvailableAfter = *assetsAvailableProxy;
    Number const pseudoAccountBalanceAfter = accountHolds(
        view,
        vaultPseudoAccount,
@@ -609,12 +659,98 @@ LoanPay::doApply()
              ahIGNORE_AUTH,
              j_,
              SpendableHandling::shFULL_BALANCE);
+    auto const balanceScale = [&]() {
+        // This is so ugly.
+        std::vector<int> exponents;

+        for (auto const& a : {
+                 accountBalanceBefore,
+                 vaultBalanceBefore,
+                 brokerBalanceBefore,
+                 accountBalanceAfter,
+                 vaultBalanceAfter,
+                 brokerBalanceAfter,
+             })
+        {
+            // Exclude zeroes
+            if (a != beast::zero)
+                exponents.push_back(a.exponent());
+        }
+        auto [min, max] =
+            std::minmax_element(exponents.begin(), exponents.end());
+        // IOU rounding can be interesting. Give a margin of error that reflects
+        // the orders of magnitude between the extremes.
+        if (!asset.integral() && *max < STAmount::cMaxOffset * 3 / 4)
+            *max += *max - *min;
+        return std::min(*max, STAmount::cMaxOffset);
+    }();
+
+    auto const accountBalanceBeforeRounded =
+        roundToScale(accountBalanceBefore, balanceScale);
+    auto const vaultBalanceBeforeRounded =
+        roundToScale(vaultBalanceBefore, balanceScale);
+    auto const brokerBalanceBeforeRounded =
+        roundToScale(brokerBalanceBefore, balanceScale);
+
+    auto const totalBalanceBefore =
+        accountBalanceBefore + vaultBalanceBefore + brokerBalanceBefore;
+    auto const totalBalanceBeforeRounded =
+        roundToScale(totalBalanceBefore, balanceScale);
+
+    JLOG(j_.trace()) << "Before: account "
+                     << Number(accountBalanceBeforeRounded) << " ("
+                     << Number(accountBalanceBefore) << ")"
+                     << ", vault " << Number(vaultBalanceBeforeRounded) << " ("
+                     << Number(vaultBalanceBefore) << ")"
+                     << ", broker " << Number(brokerBalanceBeforeRounded)
+                     << " (" << Number(brokerBalanceBefore) << ")"
+                     << ", total " << Number(totalBalanceBeforeRounded) << " ("
+                     << Number(totalBalanceBefore) << ")";
+
+    auto const accountBalanceAfterRounded =
+        roundToScale(accountBalanceAfter, balanceScale);
+    auto const vaultBalanceAfterRounded =
+        roundToScale(vaultBalanceAfter, balanceScale);
+    auto const brokerBalanceAfterRounded =
+        roundToScale(brokerBalanceAfter, balanceScale);
+
+    auto const totalBalanceAfter =
+        accountBalanceAfter + vaultBalanceAfter + brokerBalanceAfter;
+    auto const totalBalanceAfterRounded =
+        roundToScale(totalBalanceAfter, balanceScale);
+
+    JLOG(j_.trace()) << "After: account " << Number(accountBalanceAfterRounded)
+                     << " (" << Number(accountBalanceAfter) << ")"
+                     << ", vault " << Number(vaultBalanceAfterRounded) << " ("
+                     << Number(vaultBalanceAfter) << ")"
+                     << ", broker " << Number(brokerBalanceAfterRounded) << " ("
+                     << Number(brokerBalanceAfter) << ")"
+                     << ", total " << Number(totalBalanceAfterRounded) << " ("
+                     << Number(totalBalanceAfter) << ")";
+
+    auto const accountBalanceChange =
+        accountBalanceAfter - accountBalanceBefore;
+    auto const vaultBalanceChange = vaultBalanceAfter - vaultBalanceBefore;
+    auto const brokerBalanceChange = brokerBalanceAfter - brokerBalanceBefore;
+
+    auto const totalBalanceChange = roundToScale(
+        accountBalanceChange + vaultBalanceChange + brokerBalanceChange,
+        balanceScale);
+
+    JLOG(j_.trace()) << "Changes: account " << to_string(accountBalanceChange)
+                     << ", vault " << to_string(vaultBalanceChange)
+                     << ", broker " << to_string(brokerBalanceChange)
+                     << ", total " << to_string(totalBalanceChange);
+
+    // Rounding for IOUs can be weird, so check a few different ways to show
+    // that funds are conserved.
    XRPL_ASSERT_PARTS(
-        accountBalanceBefore + vaultBalanceBefore + brokerBalanceBefore ==
-            accountBalanceAfter + vaultBalanceAfter + brokerBalanceAfter,
+        totalBalanceBefore == totalBalanceAfter ||
+            totalBalanceBeforeRounded == totalBalanceAfterRounded ||
+            totalBalanceChange == beast::zero,
        "ripple::LoanPay::doApply",
        "funds are conserved (with rounding)");
+
    XRPL_ASSERT_PARTS(
        accountBalanceAfter >= beast::zero,
        "ripple::LoanPay::doApply",