Merge branch 'develop' into ximinez/acquireAsyncDispatch

2026-03-02 02:32:30 +00:00 · 2026-02-24 17:35:00 -04:00 · 2026-02-20 18:50:00 -04:00 · 2026-02-20 18:26:19 -04:00 · 2026-02-20 17:32:02 -04:00 · 2026-02-20 16:30:42 -05:00
21 changed files with 821 additions and 1087 deletions
--- a/include/xrpl/basics/CanProcess.h
+++ b/include/xrpl/basics/CanProcess.h
@@ -0,0 +1,139 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2024 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_BASICS_CANPROCESS_H_INCLUDED
+#define RIPPLE_BASICS_CANPROCESS_H_INCLUDED
+
+#include <functional>
+#include <mutex>
+#include <set>
+
+/** RAII class to check if an Item is already being processed on another thread,
+ * as indicated by it's presence in a Collection.
+ *
+ * If the Item is not in the Collection, it will be added under lock in the
+ * ctor, and removed under lock in the dtor. The object will be considered
+ * "usable" and evaluate to `true`.
+ *
+ * If the Item is in the Collection, no changes will be made to the collection,
+ * and the CanProcess object will be considered "unusable".
+ *
+ * It's up to the caller to decide what "usable" and "unusable" mean. (e.g.
+ * Process or skip a block of code, or set a flag.)
+ *
+ * The current use is to avoid lock contention that would be involved in
+ * processing something associated with the Item.
+ *
+ * Examples:
+ *
+ * void IncomingLedgers::acquireAsync(LedgerHash const& hash, ...)
+ * {
+ *    if (CanProcess check{acquiresMutex_, pendingAcquires_, hash})
+ *    {
+ *      acquire(hash, ...);
+ *    }
+ * }
+ *
+ * bool
+ * NetworkOPsImp::recvValidation(
+ *   std::shared_ptr<STValidation> const& val,
+ *   std::string const& source)
+ *   {
+ *       CanProcess check(
+ *           validationsMutex_, pendingValidations_, val->getLedgerHash());
+ *       BypassAccept bypassAccept =
+ *           check ? BypassAccept::no : BypassAccept::yes;
+ *       handleNewValidation(app_, val, source, bypassAccept, m_journal);
+ *   }
+ *
+ */
+class CanProcess
+{
+public:
+    template <class Mutex, class Collection, class Item>
+    CanProcess(Mutex& mtx, Collection& collection, Item const& item)
+        : cleanup_(insert(mtx, collection, item))
+    {
+    }
+
+    ~CanProcess()
+    {
+        if (cleanup_)
+            cleanup_();
+    }
+
+    CanProcess(CanProcess const&) = delete;
+
+    CanProcess&
+    operator=(CanProcess const&) = delete;
+
+    explicit
+    operator bool() const
+    {
+        return static_cast<bool>(cleanup_);
+    }
+
+private:
+    template <bool useIterator, class Mutex, class Collection, class Item>
+    std::function<void()>
+    doInsert(Mutex& mtx, Collection& collection, Item const& item)
+    {
+        std::unique_lock<Mutex> lock(mtx);
+        // TODO: Use structured binding once LLVM 16 is the minimum supported
+        // version. See also: https://github.com/llvm/llvm-project/issues/48582
+        // https://github.com/llvm/llvm-project/commit/127bf44385424891eb04cff8e52d3f157fc2cb7c
+        auto const insertResult = collection.insert(item);
+        auto const it = insertResult.first;
+        if (!insertResult.second)
+            return {};
+        if constexpr (useIterator)
+            return [&, it]() {
+                std::unique_lock<Mutex> lock(mtx);
+                collection.erase(it);
+            };
+        else
+            return [&]() {
+                std::unique_lock<Mutex> lock(mtx);
+                collection.erase(item);
+            };
+    }
+
+    // Generic insert() function doesn't use iterators because they may get
+    // invalidated
+    template <class Mutex, class Collection, class Item>
+    std::function<void()>
+    insert(Mutex& mtx, Collection& collection, Item const& item)
+    {
+        return doInsert<false>(mtx, collection, item);
+    }
+
+    // Specialize insert() for std::set, which does not invalidate iterators for
+    // insert and erase
+    template <class Mutex, class Item>
+    std::function<void()>
+    insert(Mutex& mtx, std::set<Item>& collection, Item const& item)
+    {
+        return doInsert<true>(mtx, collection, item);
+    }
+
+    // If set, then the item is "usable"
+    std::function<void()> cleanup_;
+};
+
+#endif
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -7,13 +7,8 @@
 #include <limits>
 #include <optional>
 #include <ostream>
-#include <stdexcept>
 #include <string>

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

 class Number;
@@ -21,39 +16,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
- * base-10 logarithm (roughly floor(log10(value))), and rem is value with
- * all factors of 10 removed (i.e., divided by the largest power of 10 that
- * divides value). 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;
 }

@@ -67,10 +41,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 prevents the creation of any
- * MantissaRanges representing other values.
+ * The mantissa_scale enum indicates whether the range is "small" or "large".
+ * This intentionally restricts the number of MantissaRanges that can be
+ * 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
@@ -84,8 +60,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
@@ -97,50 +73,25 @@ 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))
-        , scale(scale_)
+        : 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
@@ -148,59 +99,19 @@ 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.
 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 -
 * regardless of asset type - XRPAmount, MPTAmount, and IOUAmount, with at least
 * as much precision as those types require.
 *
- * ---- Internal Operational Representation ----
+ * ---- Internal Representation ----
 *
 * Internally, Number is represented with three values:
 *   1. a bool sign flag,
@@ -215,21 +126,15 @@ concept UnsignedMantissa = std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>
 *
 * A non-zero mantissa is (almost) always normalized, meaning it and the
 * exponent are grown or shrunk until the mantissa is in the range
- * [MantissaRange.referenceMin, MantissaRange.referenceMin * 10 - 1].
- *
- * This internal representation is only used during some operations to ensure
- * that the mantissa is a known, predictable size. The class itself stores the
- * values using the external representation described below.
+ * [MantissaRange.min, MantissaRange.max].
 *
 * Note:
 *   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. Unlike MantissaRange.min, referenceMin is always an exact power of 10,
- *      so a mantissa in the internal representation will always have a
- *      consistent number of digits.
- *   3. The functions toInternal() and fromInternal() are used to convert
- *      between the two representations.
+ *   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 ----
 *
@@ -242,12 +147,13 @@ concept UnsignedMantissa = std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>
 * represent the full range of valid XRP and MPT integer values accurately.
 *
 * Note:
- *   1. The "large" mantissa range is (2^63/10+1) to 2^63-1. 2^63-1 is between
- *      10^18 and 10^19-1, and (2^63/10+1) is between 10^17 and 10^18-1. Thus,
- *      the mantissa may have 18 or 19 digits. This value will be modified to
- *      always have 19 digits before some operations to ensure consistency.
+ *   1. 2^63-1 is between 10^18 and 10^19-1, which are the limits of the "large"
+ *      mantissa range.
 *   2. The functions mantissa() and exponent() return the external view of the
- *      Number value, specifically using a signed 63-bit mantissa.
+ *      Number value, specifically using a signed 63-bit mantissa. This may
+ *      require altering the internal representation to fit into that range
+ *      before the value is returned. The interface guarantees consistency of
+ *      the two values.
 *   3. Number cannot represent -2^63 (std::numeric_limits<std::int64_t>::min())
 *      as an exact integer, but it doesn't need to, because all asset values
 *      on-ledger are non-negative. This is due to implementation details of
@@ -302,7 +208,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:
@@ -310,6 +217,10 @@ public:
    constexpr static int minExponent = -32768;
    constexpr static int maxExponent = 32768;

+    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);
+
    // May need to make unchecked private
    struct unchecked
    {
@@ -387,7 +298,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
@@ -401,8 +313,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;
@@ -430,7 +342,7 @@ public:
    constexpr int
    signum() const noexcept
    {
-        return mantissa_ < 0 ? -1 : (mantissa_ ? 1 : 0);
+        return negative_ ? -1 : (mantissa_ ? 1 : 0);
    }

    Number
@@ -469,9 +381,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
@@ -536,39 +445,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);
+    static_assert(smallRange.min < maxRep);
+    static_assert(smallRange.max < maxRep);
    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, we'll need to bring them up into range.
-    // Guard::bringIntoRange handles this situation.
+    static_assert(largeRange.min < maxRep);
+    static_assert(largeRange.max > maxRep);

    // 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();

@@ -591,14 +483,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;

@@ -608,60 +497,14 @@ private:
    Number
    shiftExponent(int exponentDelta) const;

-    // Safely return the absolute value of a rep (int64) mantissa as an internalrep (uint64).
+    // Safely convert rep (int64) mantissa to internalrep (uint64). If the rep
+    // is negative, returns the positive value. This takes a little extra work
+    // because converting std::numeric_limits<std::int64_t>::min() flirts with
+    // UB, and can vary across compilers.
    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 "expectNormal" is true, the values are expected to be normalized - all
-     * in their valid ranges.
-     *
-     * If "expectNormal" 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 "expectNormal" is true, the values are expected to be normalized - all
-     * in their valid ranges.
-     *
-     * If "expectNormal" 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(
@@ -669,8 +512,7 @@ inline constexpr Number::Number(
    internalrep mantissa,
    int exponent,
    unchecked) noexcept
-    : mantissa_{negative ? -static_cast<rep>(mantissa) : static_cast<rep>(mantissa)}
-    , exponent_{exponent}
+    : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }

@@ -681,6 +523,12 @@ inline constexpr Number::Number(internalrep mantissa, int exponent, unchecked) n

 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{})
 {
@@ -703,7 +551,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.
@@ -714,7 +572,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
@@ -729,7 +596,7 @@ Number::operator-() const noexcept
    if (mantissa_ == 0)
        return Number{};
    auto x = *this;
-    x.mantissa_ = -x.mantissa_;
+    x.negative_ = !x.negative_;
    return x;
 }

@@ -810,58 +677,42 @@ 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 = externalToInternal(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;
-    internalrep mantissa = externalToInternal(mantissa_);
+    bool negative = negative_;
+    internalrep mantissa = mantissa_;
    int exponent = exponent_;

    if constexpr (std::is_unsigned_v<T>)
-    {
        XRPL_ASSERT_PARTS(
            !negative,
            "xrpl::Number::normalizeToRange",
            "Number is non-negative for unsigned range.");
-        // To avoid logical errors in release builds, throw if the Number is
-        // negative for an unsigned range.
-        if (negative)
-            throw std::runtime_error(
-                "Number::normalizeToRange: Number is negative for "
-                "unsigned range.");
-    }
    Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);

-    // Cast mantissa to signed type first (if T is a signed type) to avoid
-    // unsigned integer overflow when multiplying by negative sign
-    T signedMantissa = negative ? -static_cast<T>(mantissa) : static_cast<T>(mantissa);
-    return std::make_pair(signedMantissa, exponent);
+    auto const sign = negative ? -1 : 1;
+    return std::make_pair(static_cast<T>(sign * mantissa), exponent);
 }

 inline constexpr Number
--- a/include/xrpl/core/HashRouter.h
+++ b/include/xrpl/core/HashRouter.h
@@ -199,7 +199,7 @@ public:

    /** Add a suppression peer and get message's relay status.
     * Return pair:
-     * element 1: true if the peer is added.
+     * element 1: true if the key is added.
     * element 2: optional is seated to the relay time point or
     * is unseated if has not relayed yet. */
    std::pair<bool, std::optional<Stopwatch::time_point>>
--- a/include/xrpl/protocol/LedgerHeader.h
+++ b/include/xrpl/protocol/LedgerHeader.h
@@ -35,6 +35,8 @@ struct LedgerHeader

    // If validated is false, it means "not yet validated."
    // Once validated is true, it will never be set false at a later time.
+    // NOTE: If you are accessing this directly, you are probably doing it
+    //   wrong. Use LedgerMaster::isValidated().
    // VFALCO TODO Make this not mutable
    bool mutable validated = false;
    bool accepted = false;
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -232,7 +232,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
@@ -539,8 +539,6 @@ STAmount::fromNumber(A const& a, Number const& number)
        return STAmount{asset, intValue, 0, negative};
    }

-    XRPL_ASSERT_PARTS(
-        working.signum() >= 0, "xrpl::STAmount::fromNumber", "non-negative Number to normalize");
    auto const [mantissa, exponent] = working.normalizeToRange(cMinValue, cMaxValue);

    return STAmount{asset, mantissa, exponent, negative};
--- a/include/xrpl/protocol/SystemParameters.h
+++ b/include/xrpl/protocol/SystemParameters.h
@@ -23,7 +23,7 @@ systemName()
 /** Number of drops in the genesis account. */
 constexpr XRPAmount INITIAL_XRP{100'000'000'000 * DROPS_PER_XRP};
 static_assert(INITIAL_XRP.drops() == 100'000'000'000'000'000);
-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/include/xrpl/server/NetworkOPs.h
+++ b/include/xrpl/server/NetworkOPs.h
@@ -185,7 +185,7 @@ public:
    virtual bool
    isFull() = 0;
    virtual void
-    setMode(OperatingMode om) = 0;
+    setMode(OperatingMode om, char const* reason) = 0;
    virtual bool
    isBlocked() = 0;
    virtual bool
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -9,17 +9,20 @@
 #include <iterator>
 #include <limits>
 #include <numeric>
+#include <stdexcept>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <utility>

 #ifdef _MSC_VER
 #pragma message("Using boost::multiprecision::uint128_t and int128_t")
-#endif
-
-using uint128_t = xrpl::detail::uint128_t;
-using int128_t = xrpl::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 xrpl {

@@ -58,6 +61,9 @@ Number::setMantissaScale(MantissaRange::mantissa_scale scale)
 // precision 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
@@ -93,7 +99,7 @@ public:
    round() noexcept;

    // Modify the result to the correctly rounded value
-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    doRoundUp(
        bool& negative,
@@ -101,22 +107,22 @@ public:
        int& exponent,
        internalrep const& minMantissa,
        internalrep const& maxMantissa,
-        std::string_view location);
+        std::string location);

    // Modify the result to the correctly rounded value
-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    doRoundDown(bool& negative, T& mantissa, int& exponent, internalrep const& minMantissa);

    // Modify the result to the correctly rounded value
    void
-    doRound(rep& drops, std::string_view location);
+    doRound(rep& drops, std::string location);

 private:
    void
    doPush(unsigned d) noexcept;

-    template <detail::UnsignedMantissa T>
+    template <UnsignedMantissa T>
    void
    bringIntoRange(bool& negative, T& mantissa, int& exponent, internalrep const& minMantissa);
 };
@@ -203,7 +209,7 @@ Number::Guard::round() noexcept
    return 0;
 }

-template <detail::UnsignedMantissa T>
+template <UnsignedMantissa T>
 void
 Number::Guard::bringIntoRange(
    bool& negative,
@@ -222,13 +228,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,
@@ -236,7 +242,7 @@ Number::Guard::doRoundUp(
    int& exponent,
    internalrep const& minMantissa,
    internalrep const& maxMantissa,
-    std::string_view location)
+    std::string location)
 {
    auto r = round();
    if (r == 1 || (r == 0 && (mantissa & 1) == 1))
@@ -244,7 +250,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;
@@ -252,10 +258,10 @@ Number::Guard::doRoundUp(
    }
    bringIntoRange(negative, mantissa, exponent, minMantissa);
    if (exponent > maxExponent)
-        throw std::overflow_error(std::string{location});
+        throw std::overflow_error(location);
 }

-template <detail::UnsignedMantissa T>
+template <UnsignedMantissa T>
 void
 Number::Guard::doRoundDown(
    bool& negative,
@@ -278,22 +284,21 @@ Number::Guard::doRoundDown(

 // Modify the result to the correctly rounded value
 void
-Number::Guard::doRound(rep& drops, std::string_view location)
+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
-            // "largestMantissa + 0.6" in Number, regardless of the scale. There aren't
-            // enough digits available. You'd either get a mantissa of "largestMantissa"
-            // or "largestMantissa / 10 + 1", neither of which will round up when
+            // "maxRep + 0.6" in Number, regardless of the scale. There aren't
+            // enough digits available. You'd either get a mantissa of "maxRep"
+            // or "(maxRep + 1) / 10", neither of which will round up when
            // converting to rep, though the latter might overflow _before_
            // rounding.
-            throw std::overflow_error(std::string{location});  // LCOV_EXCL_LINE
+            throw std::overflow_error(location);  // LCOV_EXCL_LINE
        }
        ++drops;
    }
@@ -313,133 +318,23 @@ Number::externalToInternal(rep mantissa)
    // If the mantissa is already positive, just return it
    if (mantissa >= 0)
        return mantissa;
+    // If the mantissa is negative, but fits within the positive range of rep,
+    // return it negated
+    if (mantissa >= -std::numeric_limits<rep>::max())
+        return -mantissa;

-    // Cast to unsigned before negating to avoid undefined behavior
-    // when v == INT64_MIN (negating INT64_MIN in signed is UB)
-    return -static_cast<internalrep>(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>
-std::tuple<bool, Rep, int>
-Number::toInternal(MantissaRange const& range) const
-{
-    auto exponent = exponent_;
-    bool const negative = mantissa_ < 0;
-    // It should be impossible for mantissa_ to be INT64_MIN, but use externalToInternal just in
-    // case.
-    Rep mantissa = static_cast<Rep>(externalToInternal(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,
-            "xrpl::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 exactly range_.log + 1 digits.
- *
- */
-template <detail::UnsignedMantissa Rep>
-std::tuple<bool, Rep, int>
-Number::toInternal() const
-{
-    return toInternal(range_);
-}
-
-/** Rebuilds the number from components.
- *
- * If "expectNormal" is true, the values are expected to be normalized - all
- * in their valid ranges.
- *
- * If "expectNormal" 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, "xrpl::Number::fromInternal", "mantissa large enough");
-
-        if (mantissa > maxMantissa || mantissa < minMantissa)
-        {
-            normalize(negative, mantissa, exponent, range.min, maxMantissa);
-        }
-
-        XRPL_ASSERT_PARTS(
-            mantissa >= minMantissa && mantissa <= maxMantissa,
-            "xrpl::Number::fromInternal",
-            "mantissa in range");
-    }
-
-    // mantissa is unsigned, but it might not be uint64
-    mantissa_ = static_cast<rep>(static_cast<internalrep>(mantissa));
-    if (negative)
-        mantissa_ = -mantissa_;
-    exponent_ = exponent;
-
-    XRPL_ASSERT_PARTS(
-        (pRange && isnormal(*pRange)) || isnormal(),
-        "xrpl::Number::fromInternal",
-        "Number is normalized");
-}
-
-/** Rebuilds the number from components.
- *
- * If "expectNormal" is true, the values are expected to be normalized - all in
- * their valid ranges.
- *
- * If "expectNormal" 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);
+    // If the mantissa doesn't fit within the positive range, convert to
+    // int128_t, negate that, and cast it back down to the internalrep
+    // In practice, this is only going to cover the case of
+    // std::numeric_limits<rep>::min().
+    int128_t temp = mantissa;
+    return static_cast<internalrep>(-temp);
 }

 constexpr Number
 Number::oneSmall()
 {
-    return Number{
-        false, Number::smallRange.referenceMin, -Number::smallRange.log, Number::unchecked{}};
+    return Number{false, Number::smallRange.min, -Number::smallRange.log, Number::unchecked{}};
 };

 constexpr Number oneSml = Number::oneSmall();
@@ -447,89 +342,103 @@ constexpr Number oneSml = Number::oneSmall();
 constexpr Number
 Number::oneLarge()
 {
-    return Number{
-        false, Number::largeRange.referenceMin, -Number::largeRange.log, Number::unchecked{}};
+    return Number{false, Number::largeRange.min, -Number::largeRange.log, Number::unchecked{}};
 };

 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;
    }

-    XRPL_ASSERT_PARTS(m <= maxMantissa, "xrpl::doNormalize", "intermediate mantissa fits in int64");
-    mantissa = m;
-
-    g.doRoundUp(negative, mantissa, exponent, minMantissa, maxMantissa, "Number::normalize 2");
+    // 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 <= maxRep, "xrpl::doNormalize", "intermediate mantissa fits in int64");
+    mantissa_ = m;

+    g.doRoundUp(negative, 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 <>
@@ -568,20 +477,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,
@@ -591,33 +491,21 @@ 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;
@@ -632,8 +520,7 @@ Number::operator+=(Number const& y)
        return *this;
    }

-    XRPL_ASSERT(
-        isnormal(range) && y.isnormal(range), "xrpl::Number::operator+=(Number) : is normal");
+    XRPL_ASSERT(isnormal() && y.isnormal(), "xrpl::Number::operator+=(Number) : is normal");
    // *n = negative
    // *s = sign
    // *m = mantissa
@@ -641,10 +528,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)
    {
@@ -669,13 +559,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;
@@ -695,7 +586,7 @@ Number::operator+=(Number const& y)
            xe = ye;
            xn = yn;
        }
-        while (xm < minMantissa)
+        while (xm < minMantissa && xm * 10 <= maxRep)
        {
            xm *= 10;
            xm -= g.pop();
@@ -704,8 +595,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;
 }

@@ -740,8 +633,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;
@@ -755,11 +646,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;
@@ -769,10 +664,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));
@@ -789,17 +685,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");
@@ -812,12 +708,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;

@@ -829,7 +730,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(f >= minMantissa * 10, "Number::operator/=", "factor expected size");

@@ -879,8 +780,10 @@ Number::operator/=(Number const& y)
        }
    }
    normalize(zn, zm, ze, minMantissa, maxMantissa);
-    fromInternal(zn, zm, ze, &range);
-    XRPL_ASSERT_PARTS(isnormal(range), "xrpl::Number::operator/=", "result is normalized");
+    negative_ = zn;
+    mantissa_ = static_cast<internalrep>(zm);
+    exponent_ = ze;
+    XRPL_ASSERT_PARTS(isnormal(), "xrpl::Number::operator/=", "result is normalized");

    return *this;
 }
@@ -893,10 +796,10 @@ operator rep() const
    Guard g;
    if (drops != 0)
    {
-        if (drops < 0)
+        if (negative_)
        {
            g.set_negative();
-            drops = externalToInternal(drops);
+            drops = -drops;
        }
        for (; offset < 0; ++offset)
        {
@@ -905,7 +808,7 @@ 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;
        }
@@ -935,22 +838,19 @@ 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) &&
-         ((exponent < -(rangeLog + 10)) || (exponent > -(rangeLog - 10)))))
+    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)
        {
            mantissa /= 10;
@@ -958,11 +858,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;
    }

@@ -1046,11 +943,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;
@@ -1067,28 +973,21 @@ 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");
+    XRPL_ASSERT_PARTS(f.isnormal(), "xrpl::root(Number, unsigned)", "f is normalized");
    bool neg = false;
    if (f < zero)
    {
@@ -1121,33 +1020,15 @@ 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), "xrpl::root(Number, unsigned)", "result is normalized");
+    XRPL_ASSERT_PARTS(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;
@@ -1156,18 +1037,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;
@@ -1189,7 +1064,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");
+    XRPL_ASSERT_PARTS(result.isnormal(), "xrpl::root2(Number)", "result is normalized");

    return result;
 }
@@ -1199,10 +1074,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;
@@ -1224,7 +1097,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 xrpl
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -85,7 +85,12 @@ public:
    }

    virtual void
-    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) override
+    acquireAsync(
+        JobType type,
+        std::string const& name,
+        uint256 const& hash,
+        std::uint32_t seq,
+        InboundLedger::Reason reason) override
    {
    }

--- a/src/test/basics/CanProcess_test.cpp
+++ b/src/test/basics/CanProcess_test.cpp
@@ -0,0 +1,165 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2012-2016 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <xrpl/basics/CanProcess.h>
+#include <xrpl/beast/unit_test.h>
+
+#include <memory>
+
+namespace ripple {
+namespace test {
+
+struct CanProcess_test : beast::unit_test::suite
+{
+    template <class Mutex, class Collection, class Item>
+    void
+    test(
+        std::string const& name,
+        Mutex& mtx,
+        Collection& collection,
+        std::vector<Item> const& items)
+    {
+        testcase(name);
+
+        if (!BEAST_EXPECT(!items.empty()))
+            return;
+        if (!BEAST_EXPECT(collection.empty()))
+            return;
+
+        // CanProcess objects can't be copied or moved. To make that easier,
+        // store shared_ptrs
+        std::vector<std::shared_ptr<CanProcess>> trackers;
+        // Fill up the vector with two CanProcess for each Item. The first
+        // inserts the item into the collection and is "good". The second does
+        // not and is "bad".
+        for (int i = 0; i < items.size(); ++i)
+        {
+            {
+                auto const& good =
+                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
+                BEAST_EXPECT(*good);
+            }
+            BEAST_EXPECT(trackers.size() == (2 * i) + 1);
+            BEAST_EXPECT(collection.size() == i + 1);
+            {
+                auto const& bad =
+                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
+                BEAST_EXPECT(!*bad);
+            }
+            BEAST_EXPECT(trackers.size() == 2 * (i + 1));
+            BEAST_EXPECT(collection.size() == i + 1);
+        }
+        BEAST_EXPECT(collection.size() == items.size());
+        // Now remove the items from the vector<CanProcess> two at a time, and
+        // try to get another CanProcess for that item.
+        for (int i = 0; i < items.size(); ++i)
+        {
+            // Remove the "bad" one in the second position
+            // This will have no effect on the collection
+            {
+                auto const iter = trackers.begin() + 1;
+                BEAST_EXPECT(!**iter);
+                trackers.erase(iter);
+            }
+            BEAST_EXPECT(trackers.size() == (2 * items.size()) - 1);
+            BEAST_EXPECT(collection.size() == items.size());
+            {
+                // Append a new "bad" one
+                auto const& bad =
+                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
+                BEAST_EXPECT(!*bad);
+            }
+            BEAST_EXPECT(trackers.size() == 2 * items.size());
+            BEAST_EXPECT(collection.size() == items.size());
+
+            // Remove the "good" one from the front
+            {
+                auto const iter = trackers.begin();
+                BEAST_EXPECT(**iter);
+                trackers.erase(iter);
+            }
+            BEAST_EXPECT(trackers.size() == (2 * items.size()) - 1);
+            BEAST_EXPECT(collection.size() == items.size() - 1);
+            {
+                // Append a new "good" one
+                auto const& good =
+                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
+                BEAST_EXPECT(*good);
+            }
+            BEAST_EXPECT(trackers.size() == 2 * items.size());
+            BEAST_EXPECT(collection.size() == items.size());
+        }
+        // Now remove them all two at a time
+        for (int i = items.size() - 1; i >= 0; --i)
+        {
+            // Remove the "bad" one from the front
+            {
+                auto const iter = trackers.begin();
+                BEAST_EXPECT(!**iter);
+                trackers.erase(iter);
+            }
+            BEAST_EXPECT(trackers.size() == (2 * i) + 1);
+            BEAST_EXPECT(collection.size() == i + 1);
+            // Remove the "good" one now in front
+            {
+                auto const iter = trackers.begin();
+                BEAST_EXPECT(**iter);
+                trackers.erase(iter);
+            }
+            BEAST_EXPECT(trackers.size() == 2 * i);
+            BEAST_EXPECT(collection.size() == i);
+        }
+        BEAST_EXPECT(trackers.empty());
+        BEAST_EXPECT(collection.empty());
+    }
+
+    void
+    run() override
+    {
+        {
+            std::mutex m;
+            std::set<int> collection;
+            std::vector<int> const items{1, 2, 3, 4, 5};
+            test("set of int", m, collection, items);
+        }
+        {
+            std::mutex m;
+            std::set<std::string> collection;
+            std::vector<std::string> const items{"one", "two", "three", "four", "five"};
+            test("set of string", m, collection, items);
+        }
+        {
+            std::mutex m;
+            std::unordered_set<char> collection;
+            std::vector<char> const items{'1', '2', '3', '4', '5'};
+            test("unorderd_set of char", m, collection, items);
+        }
+        {
+            std::mutex m;
+            std::unordered_set<std::uint64_t> collection;
+            std::vector<std::uint64_t> const items{100u, 1000u, 150u, 4u, 0u};
+            test("unordered_set of uint64_t", m, collection, items);
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(CanProcess, ripple_basics, ripple);
+
+}  // namespace test
+}  // namespace ripple
--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -32,10 +32,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 = Number{false, minMantissa * 10, 32768, Number::normalized{}};
@@ -59,9 +58,8 @@ public:
            __LINE__);
        test(Number{false, minMantissa, -32769, Number::normalized{}}, 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
@@ -170,12 +168,8 @@ public:
                {Number{true, 9'999'999'999'999'999'999ULL, -37, Number::normalized{}},
                 Number{1'000'000'000'000'000'000, -18},
                 Number{false, 9'999'999'999'999'999'990ULL, -19, Number::normalized{}}},
-                {Number{Number::largestMantissa},
-                 Number{6, -1},
-                 Number{Number::largestMantissa / 10, 1}},
-                {Number{Number::largestMantissa - 1},
-                 Number{1, 0},
-                 Number{Number::largestMantissa}},
+                {Number{Number::maxRep}, Number{6, -1}, Number{Number::maxRep / 10, 1}},
+                {Number{Number::maxRep - 1}, Number{1, 0}, Number{Number::maxRep}},
                // Test extremes
                {
                    // Each Number operand rounds up, so the actual mantissa is
@@ -185,18 +179,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, 0, Number::normalized{}},
                    Number{false, 9'999'999'999'999'999'990ULL, 0, Number::normalized{}},
                    Number{false, 1'999'999'999'999'999'998ULL, 1, Number::normalized{}},
@@ -285,16 +272,14 @@ 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{6, -1},
-                 Number{Number::largestMantissa - 1}},
-                {Number{false, Number::largestMantissa + 1, 0, Number::normalized{}},
+                {Number{Number::maxRep}, Number{6, -1}, 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)
@@ -317,15 +302,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) {
@@ -335,100 +319,70 @@ 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, -32768},
-                 Number{1000000000000000, -32768},
-                 Number{0},
-                 __LINE__},
+                 Number{1000000000000000, -14}},
+                {Number{1000000000000000, -32768}, Number{1000000000000000, -32768}, 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{false, 9'999'999'999'999'999'579ULL, -18, 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{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{1999999999999999999, -18}},
+                {Number{3214285714285714278, -18}, Number{3111111111111111119, -18}, 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);
        }
@@ -436,90 +390,66 @@ public:
        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " 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{1000000000000000, -32768},
-                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{9999999999999999, -15}},
+                 {Number{1000000000000000, -32768}, Number{1000000000000000, -32768}, 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{false, 9999999999999999579ULL, -18, 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);
        }
@@ -527,90 +457,66 @@ public:
        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " 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{1000000000000000, -32768},
-                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{9999999999999999, -15}},
+                 {Number{1000000000000000, -32768}, Number{1000000000000000, -32768}, 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{false, 9'999'999'999'999'999'579ULL, -18, 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);
        }
@@ -618,89 +524,66 @@ public:
        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " 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, -32768},
-                  Number{1000000000000000, -32768},
-                  Number{0},
-                  __LINE__}});
+                  Number{1000000000000000, -14}},
+                 {Number{1000000000000000, -32768}, Number{1000000000000000, -32768}, 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);
        }
@@ -931,11 +814,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}},
@@ -947,16 +825,16 @@ 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{}}},
        });
@@ -1005,8 +883,6 @@ public:
            }
        };

-        auto const maxInternalMantissa = power(10, Number::mantissaLog()) * 10 - 1;
-
        auto const cSmall = std::to_array<Number>({
            Number{2},
            Number{2'000'000},
@@ -1016,10 +892,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;
@@ -1370,18 +1243,18 @@ 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");
+                        Number{false, maxMantissa, 0, Number::normalized{}}, "9999999999999999990");
                    test(
-                        Number{true, maxMantissa, 0, Number::normalized{}}, "-9223372036854775807");
+                        Number{true, maxMantissa, 0, Number::normalized{}}, "-9999999999999999990");

                    test(
                        Number{std::numeric_limits<std::int64_t>::max(), 0}, "9223372036854775807");
@@ -1617,7 +1490,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((power(maxInt64, 2) == Number{85'070'591'730'234'62, 22}));
@@ -1634,217 +1507,21 @@ 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((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19}));

            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{}}));
-            }
-        }
-    }
-
-    void
-    testNormalizeToRange()
-    {
-        // Test edge-cases of normalizeToRange
-        auto const scale = Number::getMantissaScale();
-        testcase << "normalizeToRange " << to_string(scale);
-
-        auto test = [this](
-                        Number const& n,
-                        auto const rangeMin,
-                        auto const rangeMax,
-                        auto const expectedMantissa,
-                        auto const expectedExponent,
-                        auto const line) {
-            auto const normalized = n.normalizeToRange(rangeMin, rangeMax);
-            BEAST_EXPECTS(
-                normalized.first == expectedMantissa,
-                "Number " + to_string(n) + " scaled to " + std::to_string(rangeMax) +
-                    ". Expected mantissa:" + std::to_string(expectedMantissa) +
-                    ", got: " + std::to_string(normalized.first) + " @ " + std::to_string(line));
-            BEAST_EXPECTS(
-                normalized.second == expectedExponent,
-                "Number " + to_string(n) + " scaled to " + std::to_string(rangeMax) +
-                    ". Expected exponent:" + std::to_string(expectedExponent) +
-                    ", got: " + std::to_string(normalized.second) + " @ " + std::to_string(line));
-        };
-
-        std::int64_t constexpr iRangeMin = 100;
-        std::int64_t constexpr iRangeMax = 999;
-
-        std::uint64_t constexpr uRangeMin = 100;
-        std::uint64_t constexpr uRangeMax = 999;
-
-        constexpr static MantissaRange largeRange{MantissaRange::large};
-
-        std::int64_t constexpr iBigMin = largeRange.min;
-        std::int64_t constexpr iBigMax = largeRange.max;
-
-        auto const testSuite = [&](Number const& n,
-                                   auto const expectedSmallMantissa,
-                                   auto const expectedSmallExponent,
-                                   auto const expectedLargeMantissa,
-                                   auto const expectedLargeExponent,
-                                   auto const line) {
-            test(n, iRangeMin, iRangeMax, expectedSmallMantissa, expectedSmallExponent, line);
-            test(n, iBigMin, iBigMax, expectedLargeMantissa, expectedLargeExponent, line);
-
-            // Only test non-negative. testing a negative number with an
-            // unsigned range will assert, and asserts can't be tested.
-            if (n.signum() >= 0)
-            {
-                test(n, uRangeMin, uRangeMax, expectedSmallMantissa, expectedSmallExponent, line);
-                test(
-                    n,
-                    largeRange.min,
-                    largeRange.max,
-                    expectedLargeMantissa,
-                    expectedLargeExponent,
-                    line);
-            }
-        };
-
-        {
-            // zero
-            Number const n{0};
-
-            testSuite(
-                n,
-                0,
-                std::numeric_limits<int>::lowest(),
-                0,
-                std::numeric_limits<int>::lowest(),
-                __LINE__);
-        }
-        {
-            // Small positive number
-            Number const n{2};
-
-            testSuite(n, 200, -2, 2'000'000'000'000'000'000, -18, __LINE__);
-        }
-        {
-            // Negative number
-            Number const n{-2};
-
-            testSuite(n, -200, -2, -2'000'000'000'000'000'000, -18, __LINE__);
-        }
-        {
-            // Biggest valid mantissa
-            Number const n{Number::largestMantissa, 0, Number::normalized{}};
-
-            if (scale == MantissaRange::small)
-                // With the small mantissa range, the value rounds up. Because
-                // it rounds up, when scaling up to the full int64 range, it
-                // can't go over the max, so it is one digit smaller than the
-                // full value.
-                testSuite(n, 922, 16, 922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, 922, 16, Number::largestMantissa, 0, __LINE__);
-        }
-        {
-            // Biggest valid mantissa + 1
-            Number const n{Number::largestMantissa + 1, 0, Number::normalized{}};
-
-            if (scale == MantissaRange::small)
-                // With the small mantissa range, the value rounds up. Because
-                // it rounds up, when scaling up to the full int64 range, it
-                // can't go over the max, so it is one digit smaller than the
-                // full value.
-                testSuite(n, 922, 16, 922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, 922, 16, 922'337'203'685'477'581, 1, __LINE__);
-        }
-        {
-            // Biggest valid mantissa + 2
-            Number const n{Number::largestMantissa + 2, 0, Number::normalized{}};
-
-            if (scale == MantissaRange::small)
-                // With the small mantissa range, the value rounds up. Because
-                // it rounds up, when scaling up to the full int64 range, it
-                // can't go over the max, so it is one digit smaller than the
-                // full value.
-                testSuite(n, 922, 16, 922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, 922, 16, 922'337'203'685'477'581, 1, __LINE__);
-        }
-        {
-            // Biggest valid mantissa + 3
-            Number const n{Number::largestMantissa + 3, 0, Number::normalized{}};
-
-            if (scale == MantissaRange::small)
-                // With the small mantissa range, the value rounds up. Because
-                // it rounds up, when scaling up to the full int64 range, it
-                // can't go over the max, so it is one digit smaller than the
-                // full value.
-                testSuite(n, 922, 16, 922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, 922, 16, 922'337'203'685'477'581, 1, __LINE__);
-        }
-        {
-            // int64 min
-            Number const n{std::numeric_limits<std::int64_t>::min(), 0};
-
-            if (scale == MantissaRange::small)
-                testSuite(n, -922, 16, -922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, -922, 16, -922'337'203'685'477'581, 1, __LINE__);
-        }
-        {
-            // int64 min + 1
-            Number const n{std::numeric_limits<std::int64_t>::min() + 1, 0};
-
-            if (scale == MantissaRange::small)
-                testSuite(n, -922, 16, -922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, -922, 16, -9'223'372'036'854'775'807, 0, __LINE__);
-        }
-        {
-            // int64 min - 1
-            // Need to cast to uint, even though we're dealing with a negative
-            // number to avoid overflow and UB
-            Number const n{
-                true,
-                -static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::min()) + 1,
-                0,
-                Number::normalized{}};
-
-            if (scale == MantissaRange::small)
-                testSuite(n, -922, 16, -922'337'203'685'477'600, 1, __LINE__);
-            else
-                testSuite(n, -922, 16, -922'337'203'685'477'581, 1, __LINE__);
+            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{}}));
        }
    }

@@ -1875,7 +1552,6 @@ public:
            test_truncate();
            testRounding();
            testInt64();
-            testNormalizeToRange();
        }
    }
 };
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -107,10 +107,8 @@ RCLConsensus::Adaptor::acquireLedger(LedgerHash const& hash)
            // Tell the ledger acquire system that we need the consensus ledger
            acquiringLedger_ = hash;

-            app_.getJobQueue().addJob(jtADVANCE, "GetConsL1", [id = hash, &app = app_, this]() {
-                JLOG(j_.debug()) << "JOB advanceLedger getConsensusLedger1 started";
-                app.getInboundLedgers().acquireAsync(id, 0, InboundLedger::Reason::CONSENSUS);
-            });
+            app_.getInboundLedgers().acquireAsync(
+                jtADVANCE, "GetConsL1", hash, 0, InboundLedger::Reason::CONSENSUS);
        }
        return std::nullopt;
    }
@@ -985,7 +983,7 @@ void
 RCLConsensus::Adaptor::updateOperatingMode(std::size_t const positions) const
 {
    if (!positions && app_.getOPs().isFull())
-        app_.getOPs().setMode(OperatingMode::CONNECTED);
+        app_.getOPs().setMode(OperatingMode::CONNECTED, "updateOperatingMode: no positions");
 }

 void
--- a/src/xrpld/app/consensus/RCLValidations.cpp
+++ b/src/xrpld/app/consensus/RCLValidations.cpp
@@ -117,12 +117,8 @@ RCLValidationsAdaptor::acquire(LedgerHash const& hash)
    {
        JLOG(j_.warn()) << "Need validated ledger for preferred ledger analysis " << hash;

-        Application* pApp = &app_;
-
-        app_.getJobQueue().addJob(jtADVANCE, "GetConsL2", [pApp, hash, this]() {
-            JLOG(j_.debug()) << "JOB advanceLedger getConsensusLedger2 started";
-            pApp->getInboundLedgers().acquireAsync(hash, 0, InboundLedger::Reason::CONSENSUS);
-        });
+        app_.getInboundLedgers().acquireAsync(
+            jtADVANCE, "GetConsL2", hash, 0, InboundLedger::Reason::CONSENSUS);
        return std::nullopt;
    }

--- a/src/xrpld/app/ledger/InboundLedgers.h
+++ b/src/xrpld/app/ledger/InboundLedgers.h
@@ -26,7 +26,12 @@ public:
    // Queue. TODO review whether all callers of acquire() can use this
    // instead. Inbound ledger acquisition is asynchronous anyway.
    virtual void
-    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) = 0;
+    acquireAsync(
+        JobType type,
+        std::string const& name,
+        uint256 const& hash,
+        std::uint32_t seq,
+        InboundLedger::Reason reason) = 0;

    virtual std::shared_ptr<InboundLedger>
    find(LedgerHash const& hash) = 0;
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -353,7 +353,14 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&)

    if (!wasProgress)
    {
-        checkLocal();
+        if (checkLocal())
+        {
+            // Done. Something else (probably consensus) built the ledger
+            // locally while waiting for data (or possibly before requesting)
+            XRPL_ASSERT(isDone(), "ripple::InboundLedger::onTimer : done");
+            JLOG(journal_.info()) << "Finished while waiting " << hash_;
+            return;
+        }

        mByHash = true;

--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -2,9 +2,9 @@
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/main/Application.h>

+#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/DecayingSample.h>
 #include <xrpl/basics/Log.h>
-#include <xrpl/basics/scope.h>
 #include <xrpl/beast/container/aged_map.h>
 #include <xrpl/core/JobQueue.h>
 #include <xrpl/core/PerfLog.h>
@@ -59,12 +59,15 @@ public:
                (reason != InboundLedger::Reason::CONSENSUS))
                return {};

+            std::stringstream ss;
+
            bool isNew = true;
            std::shared_ptr<InboundLedger> inbound;
            {
                ScopedLockType sl(mLock);
                if (stopping_)
                {
+                    JLOG(j_.debug()) << "Abort(stopping): " << ss.str();
                    return {};
                }

@@ -83,47 +86,61 @@ public:
                    ++mCounter;
                }
            }
+            ss << " IsNew: " << (isNew ? "true" : "false");

            if (inbound->isFailed())
+            {
+                JLOG(j_.debug()) << "Abort(failed): " << ss.str();
                return {};
+            }

            if (!isNew)
                inbound->update(seq);

            if (!inbound->isComplete())
+            {
+                JLOG(j_.debug()) << "InProgress: " << ss.str();
                return {};
+            }

+            JLOG(j_.debug()) << "Complete: " << ss.str();
            return inbound->getLedger();
        };
        using namespace std::chrono_literals;
-        std::shared_ptr<Ledger const> ledger =
-            perf::measureDurationAndLog(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
-
-        return ledger;
+        return perf::measureDurationAndLog(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
    }

    void
-    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) override
+    acquireAsync(
+        JobType type,
+        std::string const& name,
+        uint256 const& hash,
+        std::uint32_t seq,
+        InboundLedger::Reason reason) override
    {
-        std::unique_lock lock(acquiresMutex_);
-        try
+        if (auto check = std::make_shared<CanProcess const>(acquiresMutex_, pendingAcquires_, hash);
+            *check)
        {
-            if (pendingAcquires_.contains(hash))
-                return;
-            pendingAcquires_.insert(hash);
-            scope_unlock unlock(lock);
-            acquire(hash, seq, reason);
+            app_.getJobQueue().addJob(type, name, [check, name, hash, seq, reason, this]() {
+                JLOG(j_.debug()) << "JOB acquireAsync " << name << " started ";
+                try
+                {
+                    acquire(hash, seq, reason);
+                }
+                catch (std::exception const& e)
+                {
+                    JLOG(j_.warn()) << "Exception thrown for acquiring new "
+                                       "inbound ledger "
+                                    << hash << ": " << e.what();
+                }
+                catch (...)
+                {
+                    JLOG(j_.warn()) << "Unknown exception thrown for acquiring new "
+                                       "inbound ledger "
+                                    << hash;
+                }
+            });
        }
-        catch (std::exception const& e)
-        {
-            JLOG(j_.warn()) << "Exception thrown for acquiring new inbound ledger " << hash << ": "
-                            << e.what();
-        }
-        catch (...)
-        {
-            JLOG(j_.warn()) << "Unknown exception thrown for acquiring new inbound ledger " << hash;
-        }
-        pendingAcquires_.erase(hash);
    }

    std::shared_ptr<InboundLedger>
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -907,8 +907,9 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
        return;
    }

-    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq
-                           << " with >= " << minVal << " validations";
+    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq << " ("
+                           << to_short_string(ledger->header().hash) << ") with >= " << minVal
+                           << " validations";

    ledger->setValidated();
    ledger->setFull();
--- a/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
+++ b/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
@@ -13,7 +13,8 @@ TimeoutCounter::TimeoutCounter(
    QueueJobParameter&& jobParameter,
    beast::Journal journal)
    : app_(app)
-    , journal_(journal)
+    , sink_(journal, to_short_string(hash) + " ")
+    , journal_(sink_)
    , hash_(hash)
    , timeouts_(0)
    , complete_(false)
@@ -33,6 +34,7 @@ TimeoutCounter::setTimer(ScopedLockType& sl)
 {
    if (isDone())
        return;
+    JLOG(journal_.debug()) << "Setting timer for " << timerInterval_.count() << "ms";
    timer_.expires_after(timerInterval_);
    timer_.async_wait([wptr = pmDowncast()](boost::system::error_code const& ec) {
        if (ec == boost::asio::error::operation_aborted)
@@ -40,6 +42,10 @@ TimeoutCounter::setTimer(ScopedLockType& sl)

        if (auto ptr = wptr.lock())
        {
+            JLOG(ptr->journal_.debug())
+                << "timer: ec: " << ec
+                << " (operation_aborted: " << boost::asio::error::operation_aborted << " - "
+                << (ec == boost::asio::error::operation_aborted ? "aborted" : "other") << ")";
            ScopedLockType sl(ptr->mtx_);
            ptr->queueJob(sl);
        }
--- a/src/xrpld/app/ledger/detail/TimeoutCounter.h
+++ b/src/xrpld/app/ledger/detail/TimeoutCounter.h
@@ -3,6 +3,7 @@
 #include <xrpld/app/main/Application.h>

 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/utility/WrappedSink.h>
 #include <xrpl/core/Job.h>

 #include <boost/asio/basic_waitable_timer.hpp>
@@ -103,6 +104,7 @@ protected:
    // Used in this class for access to boost::asio::io_context and
    // xrpl::Overlay. Used in subtypes for the kitchen sink.
    Application& app_;
+    beast::WrappedSink sink_;
    beast::Journal journal_;
    mutable std::recursive_mutex mtx_;

--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -30,10 +30,10 @@
 #include <xrpld/rpc/MPTokenIssuanceID.h>
 #include <xrpld/rpc/ServerHandler.h>

+#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/UptimeClock.h>
 #include <xrpl/basics/mulDiv.h>
 #include <xrpl/basics/safe_cast.h>
-#include <xrpl/basics/scope.h>
 #include <xrpl/beast/utility/rngfill.h>
 #include <xrpl/core/HashRouter.h>
 #include <xrpl/core/NetworkIDService.h>
@@ -396,7 +396,7 @@ public:
    isFull() override;

    void
-    setMode(OperatingMode om) override;
+    setMode(OperatingMode om, char const* reason) override;

    bool
    isBlocked() override;
@@ -841,7 +841,7 @@ NetworkOPsImp::strOperatingMode(bool const admin /* = false */) const
 inline void
 NetworkOPsImp::setStandAlone()
 {
-    setMode(OperatingMode::FULL);
+    setMode(OperatingMode::FULL, "setStandAlone");
 }

 inline void
@@ -984,7 +984,7 @@ NetworkOPsImp::processHeartbeatTimer()
        {
            if (mMode != OperatingMode::DISCONNECTED)
            {
-                setMode(OperatingMode::DISCONNECTED);
+                setMode(OperatingMode::DISCONNECTED, "Heartbeat: insufficient peers");
                std::stringstream ss;
                ss << "Node count (" << numPeers << ") has fallen "
                   << "below required minimum (" << minPeerCount_ << ").";
@@ -1008,7 +1008,7 @@ NetworkOPsImp::processHeartbeatTimer()

        if (mMode == OperatingMode::DISCONNECTED)
        {
-            setMode(OperatingMode::CONNECTED);
+            setMode(OperatingMode::CONNECTED, "Heartbeat: sufficient peers");
            JLOG(m_journal.info()) << "Node count (" << numPeers << ") is sufficient.";
            CLOG(clog.ss()) << "setting mode to CONNECTED based on " << numPeers << " peers. ";
        }
@@ -1018,9 +1018,9 @@ NetworkOPsImp::processHeartbeatTimer()
        auto origMode = mMode.load();
        CLOG(clog.ss()) << "mode: " << strOperatingMode(origMode, true);
        if (mMode == OperatingMode::SYNCING)
-            setMode(OperatingMode::SYNCING);
+            setMode(OperatingMode::SYNCING, "Heartbeat: check syncing");
        else if (mMode == OperatingMode::CONNECTED)
-            setMode(OperatingMode::CONNECTED);
+            setMode(OperatingMode::CONNECTED, "Heartbeat: check connected");
        auto newMode = mMode.load();
        if (origMode != newMode)
        {
@@ -1710,7 +1710,7 @@ void
 NetworkOPsImp::setAmendmentBlocked()
 {
    amendmentBlocked_ = true;
-    setMode(OperatingMode::CONNECTED);
+    setMode(OperatingMode::CONNECTED, "setAmendmentBlocked");
 }

 inline bool
@@ -1741,7 +1741,7 @@ void
 NetworkOPsImp::setUNLBlocked()
 {
    unlBlocked_ = true;
-    setMode(OperatingMode::CONNECTED);
+    setMode(OperatingMode::CONNECTED, "setUNLBlocked");
 }

 inline void
@@ -1837,7 +1837,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint

    if ((mMode == OperatingMode::TRACKING) || (mMode == OperatingMode::FULL))
    {
-        setMode(OperatingMode::CONNECTED);
+        setMode(OperatingMode::CONNECTED, "check LCL: not on consensus ledger");
    }

    if (consensus)
@@ -1922,8 +1922,8 @@ NetworkOPsImp::beginConsensus(
        // this shouldn't happen unless we jump ledgers
        if (mMode == OperatingMode::FULL)
        {
-            JLOG(m_journal.warn()) << "Don't have LCL, going to tracking";
-            setMode(OperatingMode::TRACKING);
+            JLOG(m_journal.warn()) << "beginConsensus Don't have LCL, going to tracking";
+            setMode(OperatingMode::TRACKING, "beginConsensus: No LCL");
            CLOG(clog) << "beginConsensus Don't have LCL, going to tracking. ";
        }

@@ -2052,7 +2052,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
        // validations we have for LCL.  If the ledger is good enough, go to
        // TRACKING - TODO
        if (!needNetworkLedger_)
-            setMode(OperatingMode::TRACKING);
+            setMode(OperatingMode::TRACKING, "endConsensus: check tracking");
    }

    if (((mMode == OperatingMode::CONNECTED) || (mMode == OperatingMode::TRACKING)) &&
@@ -2065,7 +2065,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
        if (registry_.timeKeeper().now() <
            (current->header().parentCloseTime + 2 * current->header().closeTimeResolution))
        {
-            setMode(OperatingMode::FULL);
+            setMode(OperatingMode::FULL, "endConsensus: check full");
        }
    }

@@ -2077,7 +2077,7 @@ NetworkOPsImp::consensusViewChange()
 {
    if ((mMode == OperatingMode::FULL) || (mMode == OperatingMode::TRACKING))
    {
-        setMode(OperatingMode::CONNECTED);
+        setMode(OperatingMode::CONNECTED, "consensusViewChange");
    }
 }

@@ -2379,7 +2379,7 @@ NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 }

 void
-NetworkOPsImp::setMode(OperatingMode om)
+NetworkOPsImp::setMode(OperatingMode om, char const* reason)
 {
    using namespace std::chrono_literals;
    if (om == OperatingMode::CONNECTED)
@@ -2399,11 +2399,12 @@ NetworkOPsImp::setMode(OperatingMode om)
    if (mMode == om)
        return;

+    auto const sink = om < mMode ? m_journal.warn() : m_journal.info();
    mMode = om;

    accounting_.mode(om);

-    JLOG(m_journal.info()) << "STATE->" << strOperatingMode();
+    JLOG(sink) << "STATE->" << strOperatingMode() << " - " << reason;
    pubServer();
 }

@@ -2412,32 +2413,24 @@ NetworkOPsImp::recvValidation(std::shared_ptr<STValidation> const& val, std::str
 {
    JLOG(m_journal.trace()) << "recvValidation " << val->getLedgerHash() << " from " << source;

-    std::unique_lock lock(validationsMutex_);
-    BypassAccept bypassAccept = BypassAccept::no;
-    try
    {
-        if (pendingValidations_.contains(val->getLedgerHash()))
-            bypassAccept = BypassAccept::yes;
-        else
-            pendingValidations_.insert(val->getLedgerHash());
-        scope_unlock unlock(lock);
-        handleNewValidation(registry_.app(), val, source, bypassAccept, m_journal);
+        CanProcess const check(validationsMutex_, pendingValidations_, val->getLedgerHash());
+        try
+        {
+            BypassAccept bypassAccept = check ? BypassAccept::no : BypassAccept::yes;
+            handleNewValidation(registry_.app(), val, source, bypassAccept, m_journal);
+        }
+        catch (std::exception const& e)
+        {
+            JLOG(m_journal.warn()) << "Exception thrown for handling new validation "
+                                   << val->getLedgerHash() << ": " << e.what();
+        }
+        catch (...)
+        {
+            JLOG(m_journal.warn())
+                << "Unknown exception thrown for handling new validation " << val->getLedgerHash();
+        }
    }
-    catch (std::exception const& e)
-    {
-        JLOG(m_journal.warn()) << "Exception thrown for handling new validation "
-                               << val->getLedgerHash() << ": " << e.what();
-    }
-    catch (...)
-    {
-        JLOG(m_journal.warn()) << "Unknown exception thrown for handling new validation "
-                               << val->getLedgerHash();
-    }
-    if (bypassAccept == BypassAccept::no)
-    {
-        pendingValidations_.erase(val->getLedgerHash());
-    }
-    lock.unlock();

    pubValidation(val);
Author	SHA1	Message	Date
Ed Hennis	6fc972746d	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-24 17:35:00 -04:00
Ed Hennis	930afbdea8	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-20 18:50:00 -04:00
Ed Hennis	95c5bef48b	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-20 18:26:19 -04:00
Ed Hennis	b489b6c3ce	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-20 17:32:02 -04:00
Ed Hennis	70765acef4	Merge remote-tracking branch 'upstream/develop' into ximinez/acquireAsyncDispatch * upstream/develop: ci: [DEPENDABOT] bump tj-actions/changed-files from 46.0.5 to 47.0.4 (6394) ci: [DEPENDABOT] bump codecov/codecov-action from 5.4.3 to 5.5.2 (6398) ci: Build docs in PRs and in private repos (6400) ci: Add dependabot config (6379) Fix tautological assertion (6393) chore: Apply clang-format width 100 (6387)	2026-02-20 16:30:42 -05:00
Ed Hennis	77aa90bd0e	Update formatting	2026-02-20 16:27:59 -05:00
Ed Hennis	4758bb6dc9	Merge commit '25cca465538a56cce501477f9e5e2c1c7ea2d84c' into ximinez/acquireAsyncDispatch * commit '25cca465538a56cce501477f9e5e2c1c7ea2d84c': chore: Set clang-format width to 100 in config file (6387)	2026-02-20 16:27:39 -05:00
Ed Hennis	46e3dcb5fb	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-19 16:24:54 -05:00
Ed Hennis	d57579f10b	Merge remote-tracking branch 'XRPLF/develop' into ximinez/acquireAsyncDispatch * XRPLF/develop: refactor: Modularize app/tx (6228) refactor: Decouple app/tx from `Application` and `Config` (6227) chore: Update clang-format to 21.1.8 (6352) refactor: Modularize `HashRouter`, `Conditions`, and `OrderBookDB` (6226) chore: Fix minor issues in comments (6346) refactor: Modularize the NetworkOPs interface (6225) chore: Fix `gcov` lib coverage build failure on macOS (6350) refactor: Modularize RelationalDB (6224) refactor: Modularize WalletDB and Manifest (6223) fix: Update invariant checks for Permissioned Domains (6134) refactor: Change main thread name to `xrpld-main` (6336) refactor: Fix spelling issues in tests (6199) test: Add file and line location to Env (6276) chore: Remove CODEOWNERS (6337) perf: Remove unnecessary caches (5439) chore: Restore unity builds (6328) refactor: Update secp256k1 to 0.7.1 (6331) fix: Increment sequence when accepting new manifests (6059) fix typo in LendingHelpers unit-test (6215)	2026-02-18 19:52:18 -05:00
Ed Hennis	d8dd376d1c	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-04 16:30:10 -04:00
Ed Hennis	a8c03e2e6c	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-02-03 16:08:06 -04:00
Ed Hennis	2167a66bc7	Fix formatting	2026-01-28 19:39:15 -05:00
Ed Hennis	ed948a858c	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-28 18:49:15 -04:00
Ed Hennis	608c102743	Merge commit '5f638f55536def0d88b970d1018a465a238e55f4' into ximinez/acquireAsyncDispatch * commit '5f638f55536def0d88b970d1018a465a238e55f4': chore: Set ColumnLimit to 120 in clang-format (6288)	2026-01-28 17:47:53 -05:00
Ed Hennis	36d1607a4e	Merge commit '92046785d1fea5f9efe5a770d636792ea6cab78b' into ximinez/acquireAsyncDispatch * commit '92046785d1fea5f9efe5a770d636792ea6cab78b': test: Fix the `xrpl.net` unit test using async read (6241) ci: Upload Conan recipes for develop, release candidates, and releases (6286) fix: Stop embedded tests from hanging on ARM by using `atomic_flag` (6248) fix: Remove DEFAULT fields that change to the default in associateAsset (6259) (6273) refactor: Update Boost to 1.90 (6280) refactor: clean up uses of `std::source_location` (6272) ci: Pass missing sanitizers input to actions (6266) ci: Properly propagate Conan credentials (6265) ci: Explicitly set version when exporting the Conan recipe (6264) ci: Use plus instead of hyphen for Conan recipe version suffix (6261) chore: Detect uninitialized variables in CMake files (6247) ci: Run on-trigger and on-pr when generate-version is modified (6257) refactor: Enforce 15-char limit and simplify labels for thread naming (6212) docs: Update Ripple Bug Bounty public key (6258) ci: Add missing commit hash to Conan recipe version (6256) fix: Include `<functional>` header in `Number.h` (6254) ci: Upload Conan recipe for merges into develop and commits to release (6235) Limit reply size on `TMGetObjectByHash` queries (6110) ci: remove 'master' branch as a trigger (6234) Improve ledger_entry lookups for fee, amendments, NUNL, and hashes (5644)	2026-01-28 17:47:47 -05:00
Ed Hennis	53ebb86d60	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-15 13:03:36 -04:00
Ed Hennis	1d989bc6de	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-15 12:06:00 -04:00
Ed Hennis	64c0cb8c7e	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-13 18:19:11 -04:00
Ed Hennis	c77cfef41c	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-13 15:28:01 -04:00
Ed Hennis	08aa8c06d1	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-12 14:52:16 -04:00
Ed Hennis	9498672f8e	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-11 00:50:43 -04:00
Ed Hennis	e91d55a0e0	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-08 17:06:11 -04:00
Ed Hennis	afdc452cfc	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-08 13:04:20 -04:00
Ed Hennis	a0d4ef1a54	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2026-01-06 14:02:15 -05:00
Ed Hennis	8bc384f8bf	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-22 17:39:59 -05:00
Ed Hennis	bd961c484b	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-18 19:59:52 -05:00
Ed Hennis	aee242a8d4	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-12 20:34:59 -05:00
Ed Hennis	fcae74de58	Merge remote-tracking branch 'XRPLF/develop' into ximinez/acquireAsyncDispatch * XRPLF/develop: refactor: Rename `ripple` namespace to `xrpl` (5982) refactor: Move JobQueue and related classes into xrpl.core module (6121) refactor: Rename `rippled` binary to `xrpld` (5983) refactor: rename info() to header() (6138) refactor: rename `LedgerInfo` to `LedgerHeader` (6136) refactor: clean up `RPCHelpers` (5684) chore: Fix docs readme and cmake (6122) chore: Clean up .gitignore and .gitattributes (6001) chore: Use updated secp256k1 recipe (6118)	2025-12-11 15:33:12 -05:00
Ed Hennis	a56effcb00	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-05 21:13:10 -05:00
Ed Hennis	64c2eca465	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-02 17:37:29 -05:00
Ed Hennis	e56f750e1d	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-12-01 14:40:45 -05:00
Ed Hennis	fde000f3eb	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-28 15:46:44 -05:00
Ed Hennis	d0a62229da	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-27 01:48:56 -05:00
Ed Hennis	d5932cc7d4	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-26 00:25:17 -05:00
Ed Hennis	0b534da781	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-25 14:55:06 -05:00
Ed Hennis	71a70d343b	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-24 21:49:11 -05:00
Ed Hennis	0899e65030	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-24 21:30:22 -05:00
Ed Hennis	31ba529761	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-21 12:47:58 -05:00
Ed Hennis	e2c6e5ebb6	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-18 22:39:29 -05:00
Ed Hennis	9d807fce48	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-15 03:08:41 -05:00
Ed Hennis	9ef160765c	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-13 12:19:21 -05:00
Ed Hennis	d6c0eb243b	Merge branch 'develop' into ximinez/acquireAsyncDispatch	2025-11-12 14:12:55 -05:00
Ed Hennis	84c9fc123c	Fix formatting	2025-11-10 19:53:05 -05:00
Ed Hennis	00a2a58cfa	Add missing header	2025-11-10 19:53:05 -05:00
Ed Hennis	bb2098d873	Add a unit test for CanProcess - Delete the copy ctor & operator	2025-11-10 19:53:05 -05:00
Ed Hennis	46a5bc74db	refactor: acquireAsync will dispatch the job, not the other way around	2025-11-10 19:53:05 -05:00
Ed Hennis	7b72b9cc82	Improve job queue collision checks and logging - Improve logging related to ledger acquisition and operating mode changes - Class "CanProcess" to keep track of processing of distinct items	2025-11-10 19:53:05 -05:00