Merge remote-tracking branch 'origin' into vvysokikh1/fix-positive-balance-trustline-pay-no-reserve

include/xrpl/basics/IntrusivePointer.h

@@ -58,7 +58,7 @@ concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
     When the strong pointer count goes to zero, the "partialDestructor" is
     called. This can be used to destroy as much of the object as possible while
     still retaining the reference counts. For example, for SHAMapInnerNodes the
-    children may be reset in that function. Note that std::shared_poiner WILL
+    children may be reset in that function. Note that std::shared_pointer WILL
     run the destructor when the strong count reaches zero, but may not free the
     memory used by the object until the weak count reaches zero. In rippled, we
     typically allocate shared pointers with the `make_shared` function. When

include/xrpl/basics/IntrusiveRefCounts.h

@@ -301,7 +301,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
     // change the counts and flags (the count could be atomically changed, but
     // the flags depend on the current value of the counts).
     //
-    // Note: If this becomes a perf bottleneck, the `partialDestoryStartedMask`
+    // Note: If this becomes a perf bottleneck, the `partialDestroyStartedMask`
     // may be able to be set non-atomically. But it is easier to reason about
     // the code if the flag is set atomically.
     while (1)

include/xrpl/basics/Log.h

@@ -221,7 +221,8 @@ public:
 private:
     enum {
         // Maximum line length for log messages.
-        // If the message exceeds this length it will be truncated with elipses.
+        // If the message exceeds this length it will be truncated with
+        // ellipses.
         maximumMessageCharacters = 12 * 1024
     };
 

include/xrpl/basics/Number.h

@@ -1,8 +1,11 @@
 #ifndef XRPL_BASICS_NUMBER_H_INCLUDED
 #define XRPL_BASICS_NUMBER_H_INCLUDED
 
+#include <xrpl/beast/utility/instrumentation.h>
+
 #include <cstdint>
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <string>
 
@@ -13,42 +16,252 @@ class Number;
 std::string
 to_string(Number const& amount);
 
+template <typename T>
+constexpr std::optional<int>
+logTen(T value)
+{
+    int log = 0;
+    while (value >= 10 && value % 10 == 0)
+    {
+        value /= 10;
+        ++log;
+    }
+    if (value == 1)
+        return log;
+    return std::nullopt;
+}
+
 template <typename T>
 constexpr bool
 isPowerOfTen(T value)
 {
-    while (value >= 10 && value % 10 == 0)
-        value /= 10;
-    return value == 1;
+    return logTen(value).has_value();
 }
 
+/** MantissaRange defines a range for the mantissa of a normalized Number.
+ *
+ * The mantissa is in the range [min, max], where
+ * * min is a power of 10, and
+ * * max = min * 10 - 1.
+ *
+ * The mantissa_scale enum indicates whether the range is "small" or "large".
+ * This intentionally restricts the number of MantissaRanges that can be
+ * 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
+ * uses before Lending Protocol was implemented, mostly related to AMM.
+ *
+ * However, it does not have sufficient precision to represent the full integer
+ * range of int64_t values (-2^63 to 2^63-1), which are needed for XRP and MPT
+ * values. The implementation of SingleAssetVault, and LendingProtocol need to
+ * represent those integer values accurately and precisely, both for the
+ * STNumber field type, and for internal calculations. That necessitated the
+ * "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 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
+ * will allow for future expansion beyond 64-bits if it is ever needed.
+ */
+struct MantissaRange
+{
+    using rep = std::uint64_t;
+    enum mantissa_scale { small, large };
+
+    explicit constexpr MantissaRange(mantissa_scale scale_)
+        : min(getMin(scale_))
+        , max(min * 10 - 1)
+        , log(logTen(min).value_or(-1))
+        , scale(scale_)
+    {
+    }
+
+    rep min;
+    rep max;
+    int log;
+    mantissa_scale scale;
+
+private:
+    static constexpr rep
+    getMin(mantissa_scale scale_)
+    {
+        switch (scale_)
+        {
+            case small:
+                return 1'000'000'000'000'000ULL;
+            case large:
+                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
+                // invalid scale is used.
+                throw std::runtime_error("Unknown mantissa scale");
+        }
+    }
+};
+
+// 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>;
+
+/** 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 Representation ----
+ *
+ * Internally, Number is represented with three values:
+ *   1. a bool sign flag,
+ *   2. a std::uint64_t mantissa,
+ *   3. an int exponent.
+ *
+ * The internal mantissa is an unsigned integer in the range defined by the
+ * current MantissaRange. The exponent is an integer in the range
+ * [minExponent, maxExponent].
+ *
+ * See the description of MantissaRange for more details on the ranges.
+ *
+ * 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.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. 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 ----
+ *
+ * The external interface of Number consists of a std::int64_t mantissa, which
+ * is restricted to 63-bits, and an int exponent, which must be in the range
+ * [minExponent, maxExponent]. The range of the mantissa depends on which
+ * MantissaRange is currently active. For the "short" range, the mantissa will
+ * be between 10^15 and 10^16-1. For the "large" range, the mantissa will be
+ * between -(2^63-1) and 2^63-1. As noted above, the "large" range is needed to
+ * represent the full range of valid XRP and MPT integer values accurately.
+ *
+ * Note:
+ *   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. 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
+ *      several operations which use unsigned arithmetic internally. This is
+ *      sufficient to represent all valid XRP values (where the absolute value
+ *      can not exceed INITIAL_XRP: 10^17), and MPT values (where the absolute
+ *      value can not exceed maxMPTokenAmount: 2^63-1).
+ *
+ * ---- Mantissa Range Switching ----
+ *
+ * The mantissa range may be changed at runtime via setMantissaScale(). The
+ * default mantissa range is "large". The range is updated whenever transaction
+ * processing begins, based on whether SingleAssetVault or LendingProtocol are
+ * enabled. If either is enabled, the mantissa range is set to "large". If not,
+ * it is set to "small", preserving backward compatibility and correct
+ * "amendment-gating".
+ *
+ * It is extremely unlikely that any more calls to setMantissaScale() will be
+ * needed outside of unit tests.
+ *
+ * ---- Usage With Different Ranges ----
+ *
+ * Outside of unit tests, and existing checks, code that uses Number should not
+ * know or care which mantissa range is active.
+ *
+ * The results of computations using Numbers with a small mantissa may differ
+ * from computations using Numbers with a large mantissa, specifically as it
+ * effects the results after rounding. That is why the large mantissa range is
+ * amendment gated in transaction processing.
+ *
+ * It is extremely unlikely that any more calls to getMantissaScale() will be
+ * needed outside of unit tests.
+ *
+ * Code that uses Number should not assume or check anything about the
+ * mantissa() or exponent() except that they fit into the "large" range
+ * specified in the "External Interface" section.
+ *
+ * ----- Unit Tests -----
+ *
+ * Within unit tests, it may be useful to explicitly switch between the two
+ * ranges, or to check which range is active when checking the results of
+ * computations. If the test is doing the math directly, the
+ * set/getMantissaScale() functions may be most appropriate. However, if the
+ * test has anything to do with transaction processing, it should enable or
+ * disable the amendments that control the mantissa range choice
+ * (SingleAssetVault and LendingProtocol), and/or check if either of those
+ * amendments are enabled to determine which result to expect.
+ *
+ */
 class Number
 {
     using rep = std::int64_t;
-    rep mantissa_{0};
+    using internalrep = MantissaRange::rep;
+
+    bool negative_{false};
+    internalrep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
 
 public:
-    // The range for the mantissa when normalized
-    constexpr static std::int64_t minMantissa = 1'000'000'000'000'000LL;
-    static_assert(isPowerOfTen(minMantissa));
-    constexpr static std::int64_t maxMantissa = minMantissa * 10 - 1;
-    static_assert(maxMantissa == 9'999'999'999'999'999LL);
-
     // The range for the exponent when normalized
     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
     {
         explicit unchecked() = default;
     };
 
+    // Like unchecked, normalized is used with the ctors that take an
+    // internalrep mantissa. Unlike unchecked, those ctors will normalize the
+    // value.
+    // Only unit tests are expected to use this class
+    struct normalized
+    {
+        explicit normalized() = default;
+    };
+
     explicit constexpr Number() = default;
 
     Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
-    explicit constexpr Number(rep mantissa, int exponent, unchecked) noexcept;
+    explicit constexpr Number(
+        bool negative,
+        internalrep mantissa,
+        int exponent,
+        unchecked) noexcept;
+    // Assume unsigned values are... unsigned. i.e. positive
+    explicit constexpr Number(
+        internalrep mantissa,
+        int exponent,
+        unchecked) noexcept;
+    // Only unit tests are expected to use this ctor
+    explicit Number(
+        bool negative,
+        internalrep mantissa,
+        int exponent,
+        normalized);
+    // Assume unsigned values are... unsigned. i.e. positive
+    explicit Number(internalrep mantissa, int exponent, normalized);
 
     constexpr rep
     mantissa() const noexcept;
@@ -78,11 +291,11 @@ public:
     Number&
     operator/=(Number const& x);
 
-    static constexpr Number
+    static Number
     min() noexcept;
-    static constexpr Number
+    static Number
     max() noexcept;
-    static constexpr Number
+    static Number
     lowest() noexcept;
 
     /** Conversions to Number are implicit and conversions away from Number
@@ -96,7 +309,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
@@ -110,8 +324,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;
@@ -139,7 +353,7 @@ public:
     constexpr int
     signum() const noexcept
     {
-        return (mantissa_ < 0) ? -1 : (mantissa_ ? 1 : 0);
+        return negative_ ? -1 : (mantissa_ ? 1 : 0);
     }
 
     Number
@@ -169,6 +383,15 @@ public:
         return os << to_string(x);
     }
 
+    friend std::string
+    to_string(Number const& amount);
+
+    friend Number
+    root(Number f, unsigned d);
+
+    friend Number
+    root2(Number f);
+
     // Thread local rounding control.  Default is to_nearest
     enum rounding_mode { to_nearest, towards_zero, downward, upward };
     static rounding_mode
@@ -177,44 +400,206 @@ public:
     static rounding_mode
     setround(rounding_mode mode);
 
+    /** Returns which mantissa scale is currently in use for normalization.
+     *
+     * If you think you need to call this outside of unit tests, no you don't.
+     */
+    static MantissaRange::mantissa_scale
+    getMantissaScale();
+    /** Changes which mantissa scale is used for normalization.
+     *
+     * If you think you need to call this outside of unit tests, no you don't.
+     */
+    static void
+    setMantissaScale(MantissaRange::mantissa_scale scale);
+
+    inline static internalrep
+    minMantissa()
+    {
+        return range_.get().min;
+    }
+
+    inline static internalrep
+    maxMantissa()
+    {
+        return range_.get().max;
+    }
+
+    inline static int
+    mantissaLog()
+    {
+        return range_.get().log;
+    }
+
+    /// oneSmall is needed because the ranges are private
+    constexpr static Number
+    oneSmall();
+    /// oneLarge is needed because the ranges are private
+    constexpr static Number
+    oneLarge();
+
+    // And one is needed because it needs to choose between oneSmall and
+    // oneLarge based on the current range
+    static Number
+    one();
+
+    template <Integral64 T>
+    [[nodiscard]]
+    std::pair<T, int>
+    normalizeToRange(T minMantissa, T maxMantissa) const;
+
 private:
     static thread_local rounding_mode mode_;
+    // The available ranges for mantissa
+
+    constexpr static MantissaRange smallRange{MantissaRange::small};
+    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.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 == 1'000'000'000'000'000'000ULL);
+    static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
+    static_assert(largeRange.log == 18);
+    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_;
 
     void
     normalize();
-    constexpr bool
+
+    /** Normalize Number components to an arbitrary range.
+     *
+     * min/maxMantissa are parameters because this function is used by both
+     * normalize(), which reads from range_, and by normalizeToRange,
+     * which is public and can accept an arbitrary range from the caller.
+     */
+    template <class T>
+    static void
+    normalize(
+        bool& negative,
+        T& mantissa,
+        int& exponent,
+        internalrep const& minMantissa,
+        internalrep const& maxMantissa);
+
+    template <class T>
+    friend void
+    doNormalize(
+        bool& negative,
+        T& mantissa_,
+        int& exponent_,
+        MantissaRange::rep const& minMantissa,
+        MantissaRange::rep const& maxMantissa);
+
+    bool
     isnormal() const noexcept;
 
+    // Copy the number, but modify the exponent by "exponentDelta". Because the
+    // mantissa doesn't change, the result will be "mostly" normalized, but the
+    // exponent could go out of range, so it will be checked.
+    Number
+    shiftExponent(int exponentDelta) const;
+
+    // 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);
+
     class Guard;
 };
 
+inline constexpr Number::Number(
+    bool negative,
+    internalrep mantissa,
+    int exponent,
+    unchecked) noexcept
+    : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
+{
+}
+
+inline constexpr Number::Number(
+    internalrep mantissa,
+    int exponent,
+    unchecked) noexcept
+    : Number(false, mantissa, exponent, unchecked{})
+{
+}
+
 constexpr static Number numZero{};
 
-inline constexpr Number::Number(rep mantissa, int exponent, unchecked) noexcept
-    : mantissa_{mantissa}, exponent_{exponent}
+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{})
 {
 }
 
 inline Number::Number(rep mantissa, int exponent)
-    : mantissa_{mantissa}, exponent_{exponent}
+    : Number(mantissa < 0, externalToInternal(mantissa), exponent, normalized{})
 {
-    normalize();
 }
 
 inline Number::Number(rep mantissa) : Number{mantissa, 0}
 {
 }
 
+/** Returns the mantissa of the external view of the Number.
+ *
+ * Please see the "---- External Interface ----" section of the class
+ * documentation for an explanation of why the internal value may be modified.
+ */
 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.
+ *
+ * Please see the "---- External Interface ----" section of the class
+ * documentation for an explanation of why the internal value may be modified.
+ */
 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
@@ -226,15 +611,17 @@ Number::operator+() const noexcept
 inline constexpr Number
 Number::operator-() const noexcept
 {
+    if (mantissa_ == 0)
+        return Number{};
     auto x = *this;
-    x.mantissa_ = -x.mantissa_;
+    x.negative_ = !x.negative_;
     return x;
 }
 
 inline Number&
 Number::operator++()
 {
-    *this += Number{1000000000000000, -15, unchecked{}};
+    *this += one();
     return *this;
 }
 
@@ -249,7 +636,7 @@ Number::operator++(int)
 inline Number&
 Number::operator--()
 {
-    *this -= Number{1000000000000000, -15, unchecked{}};
+    *this -= one();
     return *this;
 }
 
@@ -299,30 +686,54 @@ operator/(Number const& x, Number const& y)
     return z;
 }
 
-inline constexpr Number
+inline Number
 Number::min() noexcept
 {
-    return Number{minMantissa, minExponent, unchecked{}};
+    return Number{false, range_.get().min, minExponent, unchecked{}};
 }
 
-inline constexpr Number
+inline Number
 Number::max() noexcept
 {
-    return Number{maxMantissa, maxExponent, unchecked{}};
+    return Number{
+        false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }
 
-inline constexpr Number
+inline Number
 Number::lowest() noexcept
 {
-    return -Number{maxMantissa, maxExponent, unchecked{}};
+    return Number{
+        true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }
 
-inline constexpr bool
+inline bool
 Number::isnormal() const noexcept
 {
-    auto const abs_m = mantissa_ < 0 ? -mantissa_ : mantissa_;
-    return minMantissa <= abs_m && abs_m <= maxMantissa &&
-        minExponent <= exponent_ && exponent_ <= maxExponent;
+    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 = 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.");
+    Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
+
+    auto const sign = negative ? -1 : 1;
+    return std::make_pair(static_cast<T>(sign * mantissa), exponent);
 }
 
 inline constexpr Number
@@ -364,6 +775,20 @@ squelch(Number const& x, Number const& limit) noexcept
     return x;
 }
 
+inline std::string
+to_string(MantissaRange::mantissa_scale const& scale)
+{
+    switch (scale)
+    {
+        case MantissaRange::small:
+            return "small";
+        case MantissaRange::large:
+            return "large";
+        default:
+            throw std::runtime_error("Bad scale");
+    }
+}
+
 class saveNumberRoundMode
 {
     Number::rounding_mode mode_;
@@ -402,6 +827,34 @@ public:
     operator=(NumberRoundModeGuard const&) = delete;
 };
 
+/** Sets the new scale and restores the old scale when it leaves scope.
+ *
+ * If you think you need to use this class outside of unit tests, no you don't.
+ *
+ */
+class NumberMantissaScaleGuard
+{
+    MantissaRange::mantissa_scale const saved_;
+
+public:
+    explicit NumberMantissaScaleGuard(
+        MantissaRange::mantissa_scale scale) noexcept
+        : saved_{Number::getMantissaScale()}
+    {
+        Number::setMantissaScale(scale);
+    }
+
+    ~NumberMantissaScaleGuard()
+    {
+        Number::setMantissaScale(saved_);
+    }
+
+    NumberMantissaScaleGuard(NumberMantissaScaleGuard const&) = delete;
+
+    NumberMantissaScaleGuard&
+    operator=(NumberMantissaScaleGuard const&) = delete;
+};
+
 }  // namespace xrpl
 
 #endif  // XRPL_BASICS_NUMBER_H_INCLUDED

include/xrpl/basics/Slice.h

@@ -152,8 +152,8 @@ public:
 
     /** Return a "sub slice" of given length starting at the given position
 
-        Note that the subslice encompasses the range [pos, pos + rcount),
-        where rcount is the smaller of count and size() - pos.
+        Note that the subslice encompasses the range [pos, pos + rCount),
+        where rCount is the smaller of count and size() - pos.
 
         @param pos position of the first character
         @count requested length

include/xrpl/basics/StringUtilities.h

@@ -31,7 +31,7 @@ template <class Iterator>
 std::optional<Blob>
 strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 {
-    static constexpr std::array<int, 256> const unxtab = []() {
+    static constexpr std::array<int, 256> const digitLookupTable = []() {
         std::array<int, 256> t{};
 
         for (auto& x : t)
@@ -57,7 +57,7 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     if (strSize & 1)
     {
-        int c = unxtab[*iter++];
+        int c = digitLookupTable[*iter++];
 
         if (c < 0)
             return {};
@@ -67,12 +67,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     while (iter != end)
     {
-        int cHigh = unxtab[*iter++];
+        int cHigh = digitLookupTable[*iter++];
 
         if (cHigh < 0)
             return {};
 
-        int cLow = unxtab[*iter++];
+        int cLow = digitLookupTable[*iter++];
 
         if (cLow < 0)
             return {};

include/xrpl/beast/container/detail/aged_unordered_container.h

@@ -3189,11 +3189,12 @@ operator==(aged_unordered_container<
 {
     if (size() != other.size())
         return false;
-    for (auto iter(cbegin()), last(cend()), olast(other.cend()); iter != last;
+    for (auto iter(cbegin()), last(cend()), otherLast(other.cend());
+         iter != last;
          ++iter)
     {
-        auto oiter(other.find(extract(*iter)));
-        if (oiter == olast)
+        auto otherIter(other.find(extract(*iter)));
+        if (otherIter == otherLast)
             return false;
     }
     return true;

include/xrpl/beast/core/CurrentThreadName.h

@@ -5,6 +5,8 @@
 #ifndef BEAST_CORE_CURRENT_THREAD_NAME_H_INCLUDED
 #define BEAST_CORE_CURRENT_THREAD_NAME_H_INCLUDED
 
+#include <boost/predef.h>
+
 #include <string>
 #include <string_view>
 
@@ -16,6 +18,31 @@ namespace beast {
 void
 setCurrentThreadName(std::string_view newThreadName);
 
+#if BOOST_OS_LINUX
+
+// On Linux, thread names are limited to 16 bytes including the null terminator.
+// Maximum number of characters is therefore 15.
+constexpr std::size_t maxThreadNameLength = 15;
+
+/** Sets the name of the caller thread with compile-time size checking.
+    @tparam N The size of the string literal including null terminator
+    @param newThreadName A string literal to set as the thread name
+
+    This template overload enforces that thread names are at most 16 characters
+    (including null terminator) at compile time, matching Linux's limit.
+*/
+template <std::size_t N>
+void
+setCurrentThreadName(char const (&newThreadName)[N])
+{
+    static_assert(
+        N <= maxThreadNameLength + 1,
+        "Thread name cannot exceed 15 characters");
+
+    setCurrentThreadName(std::string_view(newThreadName, N - 1));
+}
+#endif
+
 /** Returns the name of the caller thread.
 
     The name returned is the name as set by a call to setCurrentThreadName().

include/xrpl/beast/core/LexicalCast.h

@@ -18,7 +18,7 @@ namespace beast {
 
 namespace detail {
 
-// These specializatons get called by the non-member functions to do the work
+// These specializations get called by the non-member functions to do the work
 template <class Out, class In>
 struct LexicalCast;
 

include/xrpl/beast/hash/hash_append.h

@@ -203,7 +203,7 @@ struct is_contiguously_hashable<T[N], HashAlgorithm>
         Throws:
             Never
         Effect:
-            Returns the reslting hash of all the input data.
+            Returns the resulting hash of all the input data.
 */
 /** @{ */
 

include/xrpl/beast/utility/PropertyStream.h

@@ -376,7 +376,7 @@ public:
         print statement examples
         "parent.child" prints child and all of its children
         "parent.child." start at the parent and print down to child
-        "parent.grandchild" prints nothing- grandchild not direct discendent
+        "parent.grandchild" prints nothing- grandchild not direct descendent
         "parent.grandchild." starts at the parent and prints down to grandchild
         "parent.grandchild.*" starts at parent, print through grandchild
        children

include/xrpl/core/PerfLog.h

@@ -40,7 +40,7 @@ public:
     using microseconds = std::chrono::microseconds;
 
     /**
-     * Configuration from [perf] section of rippled.cfg.
+     * Configuration from [perf] section of xrpld.cfg.
      */
     struct Setup
     {

include/xrpl/json/json_reader.h

@@ -1,8 +1,6 @@
 #ifndef XRPL_JSON_JSON_READER_H_INCLUDED
 #define XRPL_JSON_JSON_READER_H_INCLUDED
 
-#define CPPTL_JSON_READER_H_INCLUDED
-
 #include <xrpl/json/json_forwards.h>
 #include <xrpl/json/json_value.h>
 
@@ -68,7 +66,7 @@ public:
      * error occurred during parsing.
      */
     std::string
-    getFormatedErrorMessages() const;
+    getFormattedErrorMessages() const;
 
     static constexpr unsigned nest_limit{25};
 
@@ -231,4 +229,4 @@ operator>>(std::istream&, Value&);
 
 }  // namespace Json
 
-#endif  // CPPTL_JSON_READER_H_INCLUDED
+#endif  // XRPL_JSON_JSON_READER_H_INCLUDED

include/xrpl/json/json_value.h

@@ -44,7 +44,7 @@ enum ValueType {
 class StaticString
 {
 public:
-    constexpr explicit StaticString(char const* czstring) : str_(czstring)
+    constexpr explicit StaticString(char const* czString) : str_(czString)
     {
     }
 
@@ -682,4 +682,4 @@ public:
 
 }  // namespace Json
 
-#endif  // CPPTL_JSON_H_INCLUDED
+#endif  // XRPL_JSON_JSON_VALUE_H_INCLUDED

include/xrpl/json/json_writer.h

@@ -90,7 +90,7 @@ private:
     void
     writeArrayValue(Value const& value);
     bool
-    isMultineArray(Value const& value);
+    isMultilineArray(Value const& value);
     void
     pushValue(std::string const& value);
     void
@@ -157,7 +157,7 @@ private:
     void
     writeArrayValue(Value const& value);
     bool
-    isMultineArray(Value const& value);
+    isMultilineArray(Value const& value);
     void
     pushValue(std::string const& value);
     void

include/xrpl/ledger/CredentialHelpers.h

@@ -15,7 +15,7 @@ namespace xrpl {
 namespace credentials {
 
 // These function will be used by the code that use DepositPreauth / Credentials
-// (and any future preauthorization modes) as part of authorization (all the
+// (and any future pre-authorization modes) as part of authorization (all the
 // transfer funds transactions)
 
 // Check if credential sfExpiration field has passed ledger's parentCloseTime
@@ -41,7 +41,8 @@ checkFields(STTx const& tx, beast::Journal j);
 
 // Accessing the ledger to check if provided credentials are valid. Do not use
 // in doApply (only in preclaim) since it does not remove expired credentials.
-// If you call it in prelaim, you also must call verifyDepositPreauth in doApply
+// If you call it in preclaim, you also must call verifyDepositPreauth in
+// doApply
 TER
 valid(
     STTx const& tx,

include/xrpl/ledger/Credit.h

@@ -0,0 +1,50 @@
+#ifndef XRPL_LEDGER_CREDIT_H_INCLUDED
+#define XRPL_LEDGER_CREDIT_H_INCLUDED
+
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/IOUAmount.h>
+#include <xrpl/protocol/STAmount.h>
+
+namespace xrpl {
+
+/** Calculate the maximum amount of IOUs that an account can hold
+    @param ledger the ledger to check against.
+    @param account the account of interest.
+    @param issuer the issuer of the IOU.
+    @param currency the IOU to check.
+    @return The maximum amount that can be held.
+*/
+/** @{ */
+STAmount
+creditLimit(
+    ReadView const& view,
+    AccountID const& account,
+    AccountID const& issuer,
+    Currency const& currency);
+
+IOUAmount
+creditLimit2(
+    ReadView const& v,
+    AccountID const& acc,
+    AccountID const& iss,
+    Currency const& cur);
+/** @} */
+
+/** Returns the amount of IOUs issued by issuer that are held by an account
+    @param ledger the ledger to check against.
+    @param account the account of interest.
+    @param issuer the issuer of the IOU.
+    @param currency the IOU to check.
+*/
+/** @{ */
+STAmount
+creditBalance(
+    ReadView const& view,
+    AccountID const& account,
+    AccountID const& issuer,
+    Currency const& currency);
+/** @} */
+
+}  // namespace xrpl
+
+#endif

include/xrpl/ledger/View.h

@@ -61,6 +61,9 @@ enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
 /** Controls the treatment of unauthorized MPT balances */
 enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
 
+/** Controls whether to include the account's full spendable balance */
+enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
+
 [[nodiscard]] bool
 isGlobalFrozen(ReadView const& view, AccountID const& issuer);
 
@@ -305,86 +308,57 @@ isLPTokenFrozen(
     Issue const& asset,
     Issue const& asset2);
 
-// Returns the amount an account can spend without going into debt.
+// Returns the amount an account can spend.
 //
-// <-- saAmount: amount of currency held by account. May be negative.
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer,
-    FreezeHandling zeroIfFrozen,
-    beast::Journal j);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Issue const& issue,
-    FreezeHandling zeroIfFrozen,
-    beast::Journal j);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    MPTIssue const& mptIssue,
-    FreezeHandling zeroIfFrozen,
-    AuthHandling zeroIfUnauthorized,
-    beast::Journal j);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Asset const& asset,
-    FreezeHandling zeroIfFrozen,
-    AuthHandling zeroIfUnauthorized,
-    beast::Journal j);
-
-// Returns the amount an account can spend total.
+// If shSIMPLE_BALANCE is specified, this is the amount the account can spend
+// without going into debt.
 //
-// These functions use accountHolds, but unlike accountHolds:
-// * The account can go into debt.
-// * If the account is the asset issuer the only limit is defined by the asset /
+// If shFULL_BALANCE is specified, this is the amount the account can spend
+// total. Specifically:
+// * The account can go into debt if using a trust line, and the other side has
+// a non-zero limit.
+// * If the account is the asset issuer the limit is defined by the asset /
 //   issuance.
 //
 // <-- saAmount: amount of currency held by account. May be negative.
 [[nodiscard]] STAmount
-accountSpendable(
+accountHolds(
     ReadView const& view,
     AccountID const& account,
     Currency const& currency,
     AccountID const& issuer,
     FreezeHandling zeroIfFrozen,
-    beast::Journal j);
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
-accountSpendable(
+accountHolds(
     ReadView const& view,
     AccountID const& account,
     Issue const& issue,
     FreezeHandling zeroIfFrozen,
-    beast::Journal j);
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
-accountSpendable(
+accountHolds(
     ReadView const& view,
     AccountID const& account,
     MPTIssue const& mptIssue,
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
-    beast::Journal j);
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
-accountSpendable(
+accountHolds(
     ReadView const& view,
     AccountID const& account,
     Asset const& asset,
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
-    beast::Journal j);
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 // Returns the amount an account can spend of the currency type saDefault, or
 // returns saDefault if this account is the issuer of the currency in
@@ -655,7 +629,7 @@ createPseudoAccount(
     uint256 const& pseudoOwnerKey,
     SField const& ownerField);
 
-// Returns true iff sleAcct is a pseudo-account or specific
+// Returns true if and only if sleAcct is a pseudo-account or specific
 // pseudo-accounts in pseudoFieldFilter.
 //
 // Returns false if sleAcct is
@@ -710,13 +684,16 @@ checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
  *      the sender has it.
+ *    - Checks that the receiver will not exceed the limit (IOU trustline limit
+ *      or MPT MaximumAmount).
  */
 [[nodiscard]] TER
 canWithdraw(
-    AccountID const& from,
     ReadView const& view,
+    AccountID const& from,
     AccountID const& to,
     SLE::const_ref toSle,
+    STAmount const& amount,
     bool hasDestinationTag);
 
 /** Checks that can withdraw funds from an object to itself or a destination.
@@ -730,12 +707,15 @@ canWithdraw(
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
  *      the sender has it.
+ *    - Checks that the receiver will not exceed the limit (IOU trustline limit
+ *      or MPT MaximumAmount).
  */
 [[nodiscard]] TER
 canWithdraw(
-    AccountID const& from,
     ReadView const& view,
+    AccountID const& from,
     AccountID const& to,
+    STAmount const& amount,
     bool hasDestinationTag);
 
 /** Checks that can withdraw funds from an object to itself or a destination.
@@ -749,6 +729,8 @@ canWithdraw(
  *    - If withdrawing to self, succeed.
  *    - If not, checks if the receiver requires deposit authorization, and if
  *      the sender has it.
+ *    - Checks that the receiver will not exceed the limit (IOU trustline limit
+ *      or MPT MaximumAmount).
  */
 [[nodiscard]] TER
 canWithdraw(ReadView const& view, STTx const& tx);

include/xrpl/nodestore/DummyScheduler.h

@@ -6,7 +6,7 @@
 namespace xrpl {
 namespace NodeStore {
 
-/** Simple NodeStore Scheduler that just peforms the tasks synchronously. */
+/** Simple NodeStore Scheduler that just performs the tasks synchronously. */
 class DummyScheduler : public Scheduler
 {
 public:

include/xrpl/nodestore/Manager.h

@@ -55,7 +55,7 @@ public:
             HyperLevelDB, LevelDBFactory, SQLite, MDB
 
         If the fastBackendParameter is omitted or empty, no ephemeral database
-        is used. If the scheduler parameter is omited or unspecified, a
+        is used. If the scheduler parameter is omitted or unspecified, a
         synchronous scheduler is used which performs all tasks immediately on
         the caller's thread.
 

include/xrpl/nodestore/README.md

@@ -96,7 +96,7 @@ Facebook's RocksDB database, builds on LevelDB.
 
 Use SQLite.
 
-'path' speficies where the backend will store its data files.
+'path' specifies where the backend will store its data files.
 
 Choices for 'compression'
 
@@ -130,7 +130,7 @@ newer versions of RocksDB (TBD).
 ## Discussion
 
 RocksDBQuickFactory is intended to provide a testbed for comparing potential
-rocksdb performance with the existing recommended configuration in rippled.cfg.
+rocksdb performance with the existing recommended configuration in xrpld.cfg.
 Through various executions and profiling some conclusions are presented below.
 
 - If the write ahead log is enabled, insert speed soon clogs up under load. The
@@ -161,7 +161,7 @@ Through various executions and profiling some conclusions are presented below.
 
 - Multiple runs of the benchmarks can yield surprisingly different results. This
   can perhaps be attributed to the asynchronous nature of rocksdb's compaction
-  process. The benchmarks are artifical and create highly unlikely write load to
+  process. The benchmarks are artificial and create highly unlikely write load to
   create the dataset to measure different read access patterns. Therefore multiple
   runs of the benchmarks are required to get a feel for the effectiveness of the
   changes. This contrasts sharply with the keyvadb benchmarking were highly

include/xrpl/proto/org/xrpl/rpc/v1/xrp_ledger.proto

@@ -9,7 +9,7 @@ import "org/xrpl/rpc/v1/get_ledger_entry.proto";
 import "org/xrpl/rpc/v1/get_ledger_data.proto";
 import "org/xrpl/rpc/v1/get_ledger_diff.proto";
 
-// These methods are binary only methods for retrieiving arbitrary ledger state
+// These methods are binary only methods for retrieving arbitrary ledger state
 // via gRPC. These methods are used by clio, but can also be
 // used by any client that wants to extract ledger state in an efficient manner.
 // They do not directly mimic the JSON equivalent methods.

include/xrpl/proto/xrpl.proto

@@ -17,9 +17,9 @@ enum MessageType {
   mtHAVE_SET = 35;
   mtVALIDATION = 41;
   mtGET_OBJECTS = 42;
-  mtVALIDATORLIST = 54;
+  mtVALIDATOR_LIST = 54;
   mtSQUELCH = 55;
-  mtVALIDATORLISTCOLLECTION = 56;
+  mtVALIDATOR_LIST_COLLECTION = 56;
   mtPROOF_PATH_REQ = 57;
   mtPROOF_PATH_RESPONSE = 58;
   mtREPLAY_DELTA_REQ = 59;
@@ -308,7 +308,7 @@ message TMSquelch {
 }
 
 enum TMLedgerMapType {
-  lmTRANASCTION = 1;    // transaction map
+  lmTRANSACTION = 1;    // transaction map
   lmACCOUNT_STATE = 2;  // account state map
 }
 

include/xrpl/protocol/AmountConversions.h

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

include/xrpl/protocol/HashPrefix.h

@@ -67,9 +67,6 @@ enum class HashPrefix : std::uint32_t {
     /** Payment Channel Claim */
     paymentChannelClaim = detail::make_hash_prefix('C', 'L', 'M'),
 
-    /** Credentials signature */
-    credential = detail::make_hash_prefix('C', 'R', 'D'),
-
     /** Batch */
     batch = detail::make_hash_prefix('B', 'C', 'H'),
 };

include/xrpl/protocol/IOUAmount.h

@@ -20,14 +20,16 @@ namespace xrpl {
 
     Arithmetic operations can throw std::overflow_error during normalization
     if the amount exceeds the largest representable amount, but underflows
-    will silently trunctate to zero.
+    will silently truncate to zero.
 */
 class IOUAmount : private boost::totally_ordered<IOUAmount>,
                   private boost::additive<IOUAmount>
 {
 private:
-    std::int64_t mantissa_;
-    int exponent_;
+    using mantissa_type = std::int64_t;
+    using exponent_type = int;
+    mantissa_type mantissa_;
+    exponent_type exponent_;
 
     /** Adjusts the mantissa and exponent to the proper range.
 
@@ -38,11 +40,14 @@ private:
     void
     normalize();
 
+    static IOUAmount
+    fromNumber(Number const& number);
+
 public:
     IOUAmount() = default;
     explicit IOUAmount(Number const& other);
     IOUAmount(beast::Zero);
-    IOUAmount(std::int64_t mantissa, int exponent);
+    IOUAmount(mantissa_type mantissa, exponent_type exponent);
 
     IOUAmount& operator=(beast::Zero);
 
@@ -71,10 +76,10 @@ public:
     int
     signum() const noexcept;
 
-    int
+    exponent_type
     exponent() const noexcept;
 
-    std::int64_t
+    mantissa_type
     mantissa() const noexcept;
 
     static IOUAmount
@@ -92,7 +97,7 @@ inline IOUAmount::IOUAmount(beast::Zero)
     *this = beast::zero;
 }
 
-inline IOUAmount::IOUAmount(std::int64_t mantissa, int exponent)
+inline IOUAmount::IOUAmount(mantissa_type mantissa, exponent_type exponent)
     : mantissa_(mantissa), exponent_(exponent)
 {
     normalize();
@@ -149,13 +154,13 @@ IOUAmount::signum() const noexcept
     return (mantissa_ < 0) ? -1 : (mantissa_ ? 1 : 0);
 }
 
-inline int
+inline IOUAmount::exponent_type
 IOUAmount::exponent() const noexcept
 {
     return exponent_;
 }
 
-inline std::int64_t
+inline IOUAmount::mantissa_type
 IOUAmount::mantissa() const noexcept
 {
     return mantissa_;

include/xrpl/protocol/Indexes.h

@@ -18,7 +18,7 @@
 namespace xrpl {
 
 class SeqProxy;
-/** Keylet computation funclets.
+/** Keylet computation functions.
 
     Entries in the ledger are located using 256-bit locators. The locators are
     calculated using a wide range of parameters specific to the entry whose

include/xrpl/protocol/Issue.h

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

include/xrpl/protocol/MPTIssue.h

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

include/xrpl/protocol/Permissions.h

@@ -29,7 +29,7 @@ enum GranularPermissionType : std::uint32_t {
 #pragma pop_macro("PERMISSION")
 };
 
-enum Delegation { delegatable, notDelegatable };
+enum Delegation { delegable, notDelegable };
 
 class Permission
 {
@@ -38,7 +38,7 @@ private:
 
     std::unordered_map<std::uint16_t, uint256> txFeatureMap_;
 
-    std::unordered_map<std::uint16_t, Delegation> delegatableTx_;
+    std::unordered_map<std::uint16_t, Delegation> delegableTx_;
 
     std::unordered_map<std::string, GranularPermissionType>
         granularPermissionMap_;
@@ -71,8 +71,7 @@ public:
     getTxFeature(TxType txType) const;
 
     bool
-    isDelegatable(std::uint32_t const& permissionValue, Rules const& rules)
-        const;
+    isDelegable(std::uint32_t const& permissionValue, Rules const& rules) const;
 
     // for tx level permission, permission value is equal to tx type plus one
     uint32_t

include/xrpl/protocol/Protocol.h

@@ -179,7 +179,7 @@ static constexpr int loanPaymentsPerFeeIncrement = 5;
  *
  * This limit is enforced during the loan payment process, and thus is not
  * estimated. If the limit is hit, no further payments or overpayments will be
- * processed, no matter how much of the transation Amount is left, but the
+ * processed, no matter how much of the transaction Amount is left, but the
  * transaction will succeed with the payments that have been processed up to
  * that point.
  *
@@ -233,6 +233,7 @@ std::size_t constexpr maxMPTokenMetadataLength = 1024;
 
 /** The maximum amount of MPTokenIssuance */
 std::uint64_t constexpr maxMPTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull;
+static_assert(Number::maxRep >= maxMPTokenAmount);
 
 /** The maximum length of Data payload */
 std::size_t constexpr maxDataPayloadLength = 256;

include/xrpl/protocol/Quality.h

@@ -210,7 +210,7 @@ public:
 
 private:
     // The ceil_in and ceil_out methods that deal in TAmount all convert
-    // their arguments to STAoumout and convert the result back to TAmount.
+    // their arguments to STAmount and convert the result back to TAmount.
     // This helper function takes care of all the conversion operations.
     template <
         class In,

include/xrpl/protocol/SField.h

@@ -135,7 +135,10 @@ public:
         sMD_Always = 0x10,   // value when node containing it is affected at all
         sMD_BaseTen = 0x20,  // value is treated as base 10, overriding behavior
         sMD_PseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
-        // _only_, then it is a pseudo-account
+                                   // _only_, then it is a pseudo-account
+        sMD_NeedsAsset = 0x80,     // This field needs to be associated with an
+                                   // asset before it is serialized as a ledger
+                                   // object. Intended for STNumber.
         sMD_Default =
             sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create
     };

include/xrpl/protocol/STAmount.h

@@ -138,7 +138,7 @@ public:
 
     template <AssetType A>
     STAmount(A const& asset, Number const& number)
-        : STAmount(asset, number.mantissa(), number.exponent())
+        : STAmount(fromNumber(asset, number))
     {
     }
 
@@ -282,6 +282,10 @@ public:
     mpt() const;
 
 private:
+    template <AssetType A>
+    static STAmount
+    fromNumber(A const& asset, Number const& number);
+
     static std::unique_ptr<STAmount>
     construct(SerialIter&, SField const& name);
 
@@ -345,10 +349,19 @@ STAmount::STAmount(
     , mIsNegative(negative)
 {
     // mValue is uint64, but needs to fit in the range of int64
-    XRPL_ASSERT(
-        mValue <= std::numeric_limits<std::int64_t>::max(),
-        "xrpl::STAmount::STAmount(SField, A, std::uint64_t, int, bool) : "
-        "maximum mantissa input");
+    if (Number::getMantissaScale() == MantissaRange::small)
+    {
+        XRPL_ASSERT(
+            mValue <= std::numeric_limits<std::int64_t>::max(),
+            "xrpl::STAmount::STAmount(SField, A, std::uint64_t, int, bool) : "
+            "maximum mantissa input");
+    }
+    else
+    {
+        if (integral() && mValue > std::numeric_limits<std::int64_t>::max())
+            throw std::overflow_error(
+                "STAmount mantissa is too large " + std::to_string(mantissa));
+    }
     canonicalize();
 }
 
@@ -542,14 +555,23 @@ STAmount::operator=(XRPAmount const& amount)
     return *this;
 }
 
-inline STAmount&
-STAmount::operator=(Number const& number)
+template <AssetType A>
+inline STAmount
+STAmount::fromNumber(A const& a, Number const& number)
 {
-    mIsNegative = number.mantissa() < 0;
-    mValue = mIsNegative ? -number.mantissa() : number.mantissa();
-    mOffset = number.exponent();
-    canonicalize();
-    return *this;
+    bool const negative = number.mantissa() < 0;
+    Number const working{negative ? -number : number};
+    Asset asset{a};
+    if (asset.integral())
+    {
+        std::uint64_t const intValue = static_cast<std::int64_t>(working);
+        return STAmount{asset, intValue, 0, negative};
+    }
+
+    auto const [mantissa, exponent] =
+        working.normalizeToRange(cMinValue, cMaxValue);
+
+    return STAmount{asset, mantissa, exponent, negative};
 }
 
 inline void
@@ -699,17 +721,32 @@ getRate(STAmount const& offerOut, STAmount const& offerIn);
  * @param rounding Optional Number rounding mode
  *
  */
-STAmount
+[[nodiscard]] STAmount
 roundToScale(
     STAmount const& value,
     std::int32_t scale,
     Number::rounding_mode rounding = Number::getround());
 
+/** Round an arbitrary precision Number IN PLACE to the precision of a given
+ * Asset.
+ *
+ * This is used to ensure that calculations do not collect dust for IOUs, or
+ * fractional amounts for the integral types XRP and MPT.
+ *
+ * @param asset The relevant asset
+ * @param value The lvalue to be rounded
+ */
+template <AssetType A>
+void
+roundToAsset(A const& asset, Number& value)
+{
+    value = STAmount{asset, value};
+}
+
 /** Round an arbitrary precision Number to the precision of a given Asset.
  *
- * This is used to ensure that calculations do not collect dust beyond the
- * precision of the reference value for IOUs, or fractional amounts for the
- * integral types XRP and MPT.
+ * This is used to ensure that calculations do not collect dust beyond specified
+ * scale for IOUs, or fractional amounts for the integral types XRP and MPT.
  *
  * @param asset The relevant asset
  * @param value The value to be rounded
@@ -718,7 +755,7 @@ roundToScale(
  * @param rounding Optional Number rounding mode
  */
 template <AssetType A>
-Number
+[[nodiscard]] Number
 roundToAsset(
     A const& asset,
     Number const& value,

include/xrpl/protocol/STNumber.h

@@ -4,6 +4,7 @@
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/basics/Number.h>
 #include <xrpl/protocol/STBase.h>
+#include <xrpl/protocol/STTakesAsset.h>
 
 #include <ostream>
 
@@ -19,8 +20,19 @@ namespace xrpl {
  * it can represent a value of any token type (XRP, IOU, or MPT)
  * without paying the storage cost of duplicating asset information
  * that may be deduced from the context.
+ *
+ * STNumber derives from STTakesAsset, so that it can be associated with the
+ * related Asset during transaction processing. Which asset is relevant depends
+ * on the object and transaction. As of this writing, only Vault, LoanBroker,
+ * and Loan objects use STNumber fields. All of those fields represent amounts
+ * of the Vault's Asset, so they should be associated with the Vault's Asset.
+ *
+ * e.g.
+ *     associateAsset(*loanSle, asset);
+ *     associateAsset(*brokerSle, asset);
+ *     associateAsset(*vaultSle, asset);
  */
-class STNumber : public STBase, public CountedObject<STNumber>
+class STNumber : public STTakesAsset, public CountedObject<STNumber>
 {
 private:
     Number value_;
@@ -56,6 +68,9 @@ public:
     bool
     isDefault() const override;
 
+    void
+    associateAsset(Asset const& a) override;
+
     operator Number() const
     {
         return value_;

include/xrpl/protocol/STTakesAsset.h

@@ -0,0 +1,63 @@
+#ifndef XRPL_PROTOCOL_STTAKESASSET_H_INCLUDED
+#define XRPL_PROTOCOL_STTAKESASSET_H_INCLUDED
+
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/STBase.h>
+
+namespace xrpl {
+
+/** Intermediate class for any STBase-derived class to store an Asset.
+ *
+ * In the class definition, this class should be specified as a base class
+ * _instead_ of STBase.
+ *
+ * Specifically, the Asset is only stored and used at runtime. It should not be
+ * serialized to the ledger.
+ *
+ * The derived class decides what to do with the Asset, and when. It will not
+ * necessarily be set at any given time. As of this writing, only STNumber uses
+ * it to round the stored Number to the Asset's precision both when associated,
+ * and when serializing the Number.
+ */
+class STTakesAsset : public STBase
+{
+protected:
+    std::optional<Asset> asset_;
+
+public:
+    using STBase::STBase;
+    using STBase::operator=;
+
+    virtual void
+    associateAsset(Asset const& a);
+};
+
+inline void
+STTakesAsset::associateAsset(Asset const& a)
+{
+    asset_.emplace(a);
+}
+
+class STLedgerEntry;
+
+/** Associate an Asset with all sMD_NeedsAsset fields in a ledger entry.
+ *
+ * This function iterates over all fields in the given ledger entry. For each
+ * field that is set and has the SField::sMD_NeedsAsset metadata flag, it calls
+ * `associateAsset` on that field with the given Asset. Such field must be
+ * derived from STTakesAsset - if it is not, the conversion will throw.
+ *
+ * Typically, associateAsset should be called near the end of doApply() of any
+ * Transactor classes on the SLEs of any new or modified ledger entries
+ * containing STNumber fields, after doing all of the modifications t the SLEs.
+ *
+ * @param sle The ledger entry whose fields will be updated.
+ * @param asset The Asset to associate with the relevant fields.
+ *
+ */
+void
+associateAsset(STLedgerEntry& sle, Asset const& asset);
+
+}  // namespace xrpl
+
+#endif

include/xrpl/protocol/SystemParameters.h

@@ -23,6 +23,8 @@ 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::maxRep >= INITIAL_XRP.drops());
 
 /** Returns true if the amount does not exceed the initial XRP in existence. */
 inline bool

include/xrpl/protocol/TxFlags.h

@@ -277,7 +277,7 @@ constexpr std::uint32_t const tfLoanOverpayment = 0x00010000;
 // interest and fees, or it will fail. False: Not a full payment.
 constexpr std::uint32_t const tfLoanFullPayment = 0x00020000;
 // tfLoanLatePayment: True, indicates that the payment is late,
-// and includes late iterest and fees. If the loan is not late,
+// and includes late interest and fees. If the loan is not late,
 // it will fail. False: not a late payment. If the current payment
 // is overdue, the transaction will fail.
 constexpr std::uint32_t const tfLoanLatePayment = 0x00040000;

include/xrpl/protocol/XChainAttestations.h

@@ -33,12 +33,12 @@ struct AttestationBase
     // Account on the sending chain that triggered the event (sent the
     // transaction)
     AccountID sendingAccount;
-    // Amount transfered on the sending chain
+    // Amount transferred on the sending chain
     STAmount sendingAmount;
     // Account on the destination chain that collects a share of the attestation
     // reward
     AccountID rewardAccount;
-    // Amount was transfered on the locking chain
+    // Amount was transferred on the locking chain
     bool wasLockingChainSend;
 
     explicit AttestationBase(
@@ -354,7 +354,7 @@ struct XChainCreateAccountAttestation
         XChainCreateAccountAttestation const& rhs);
 };
 
-// Attestations from witness servers for a particular claimid and bridge.
+// Attestations from witness servers for a particular claim ID and bridge.
 // Only one attestation per signature is allowed.
 template <class TAttestation>
 class XChainAttestationsBase

include/xrpl/protocol/detail/STVar.h

@@ -42,7 +42,7 @@ concept ValidConstructSTArgs =
 class STVar
 {
 private:
-    // The largest "small object" we can accomodate
+    // The largest "small object" we can accommodate
     static std::size_t constexpr max_size = 72;
 
     std::aligned_storage<max_size>::type d_;

include/xrpl/protocol/detail/features.macro

@@ -17,7 +17,8 @@
 // Keep it sorted in reverse chronological order.
 
 XRPL_FIX    (TrustLineOwnerCount,        Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(LendingProtocol,            Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FIX    (BatchInnerSigs,             Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(LendingProtocol,            Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegationV1_1,   Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DirectoryLimit,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (IncludeKeyletFields,        Supported::yes, VoteBehavior::DefaultNo)
@@ -31,7 +32,7 @@ XRPL_FIX    (EnforceNFTokenTrustlineV2,  Supported::yes, VoteBehavior::DefaultNo
 XRPL_FIX    (AMMv1_3,                    Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionedDEX,            Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Batch,                      Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(SingleAssetVault,           Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(SingleAssetVault,           Supported::yes,  VoteBehavior::DefaultNo)
 XRPL_FIX    (PayChanCancelAfter,         Supported::yes, VoteBehavior::DefaultNo)
 // Check flags in Credential transactions
 XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -237,7 +237,7 @@ LEDGER_ENTRY(ltOFFER, 0x006f, Offer, offer, ({
     {sfAdditionalBooks,      soeOPTIONAL},
 }))
 
-/** A ledger object which describes a deposit preauthorization.
+/** A ledger object which describes a deposit pre-authorization.
 
     \sa keylet::depositPreauth
  */
@@ -541,7 +541,7 @@ LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({
     {sfStartDate,            soeREQUIRED},
     {sfPaymentInterval,      soeREQUIRED},
     {sfGracePeriod,          soeDEFAULT},
-    {sfPreviousPaymentDate,  soeDEFAULT},
+    {sfPreviousPaymentDueDate, soeDEFAULT},
     {sfNextPaymentDueDate,   soeDEFAULT},
     // The loan object tracks these values:
     //
@@ -577,7 +577,7 @@ LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({
     // - TrueTotalLoanValue = PaymentRemaining * PeriodicPayment
     //   The unrounded true total value of the loan.
     //
-    // - TrueTotalPrincialOutstanding can be computed using the algorithm
+    // - TrueTotalPrincipalOutstanding can be computed using the algorithm
     //   in the ripple::detail::loanPrincipalFromPeriodicPayment function.
     //
     // - TrueTotalInterestOutstanding = TrueTotalLoanValue -

include/xrpl/protocol/detail/sfields.macro

@@ -102,7 +102,7 @@ TYPED_SFIELD(sfMutableFlags,             UINT32,    53)
 TYPED_SFIELD(sfStartDate,                UINT32,    54)
 TYPED_SFIELD(sfPaymentInterval,          UINT32,    55)
 TYPED_SFIELD(sfGracePeriod,              UINT32,    56)
-TYPED_SFIELD(sfPreviousPaymentDate,      UINT32,    57)
+TYPED_SFIELD(sfPreviousPaymentDueDate,   UINT32,    57)
 TYPED_SFIELD(sfNextPaymentDueDate,       UINT32,    58)
 TYPED_SFIELD(sfPaymentRemaining,         UINT32,    59)
 TYPED_SFIELD(sfPaymentTotal,             UINT32,    60)
@@ -207,22 +207,22 @@ TYPED_SFIELD(sfLoanID,                   UINT256,   38)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2)
-TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3)
-TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4)
-TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5)
-TYPED_SFIELD(sfDebtTotal,                NUMBER,     6)
-TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7)
-TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8)
+TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfLoanOriginationFee,       NUMBER,     9)
 TYPED_SFIELD(sfLoanServiceFee,           NUMBER,     10)
 TYPED_SFIELD(sfLatePaymentFee,           NUMBER,     11)
 TYPED_SFIELD(sfClosePaymentFee,          NUMBER,     12)
-TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13)
+TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
-TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15)
+TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
-TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17)
+TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::sMD_NeedsAsset | SField::sMD_Default)
 
 // int32
 TYPED_SFIELD(sfLoanScale,                INT32,      1)

include/xrpl/protocol/detail/transactions.macro

@@ -3,7 +3,7 @@
 #endif
 
 /**
- * TRANSACTION(tag, value, name, delegatable, amendments, privileges, fields)
+ * TRANSACTION(tag, value, name, delegable, amendments, privileges, fields)
  *
  * To ease maintenance, you may replace any unneeded values with "..."
  * e.g. #define TRANSACTION(tag, value, name, ...)
@@ -25,7 +25,7 @@
 #   include <xrpld/app/tx/detail/Payment.h>
 #endif
 TRANSACTION(ttPAYMENT, 0, Payment,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     createAcct,
     ({
@@ -45,7 +45,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 #   include <xrpld/app/tx/detail/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -59,7 +59,7 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
 
 /** This transaction type completes an existing escrow. */
 TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -76,7 +76,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
 #   include <xrpld/app/tx/detail/SetAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({
@@ -97,7 +97,7 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 #   include <xrpld/app/tx/detail/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -110,7 +110,7 @@ TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
 #   include <xrpld/app/tx/detail/SetRegularKey.h>
 #endif
 TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({
@@ -124,7 +124,7 @@ TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
 #   include <xrpld/app/tx/detail/CreateOffer.h>
 #endif
 TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -140,7 +140,7 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
 #   include <xrpld/app/tx/detail/CancelOffer.h>
 #endif
 TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -154,7 +154,7 @@ TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
 #   include <xrpld/app/tx/detail/CreateTicket.h>
 #endif
 TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -170,7 +170,7 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
 #   include <xrpld/app/tx/detail/SetSignerList.h>
 #endif
 TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({
@@ -183,7 +183,7 @@ TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
 #   include <xrpld/app/tx/detail/PayChan.h>
 #endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -197,7 +197,7 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
 TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -208,7 +208,7 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
 TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -225,7 +225,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
 #   include <xrpld/app/tx/detail/CreateCheck.h>
 #endif
 TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -241,7 +241,7 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
 #   include <xrpld/app/tx/detail/CashCheck.h>
 #endif
 TRANSACTION(ttCHECK_CASH, 17, CheckCash,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -255,7 +255,7 @@ TRANSACTION(ttCHECK_CASH, 17, CheckCash,
 #   include <xrpld/app/tx/detail/CancelCheck.h>
 #endif
 TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -267,7 +267,7 @@ TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
 #   include <xrpld/app/tx/detail/DepositPreauth.h>
 #endif
 TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -282,7 +282,7 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
 #   include <xrpld/app/tx/detail/SetTrust.h>
 #endif
 TRANSACTION(ttTRUST_SET, 20, TrustSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -296,7 +296,7 @@ TRANSACTION(ttTRUST_SET, 20, TrustSet,
 #   include <xrpld/app/tx/detail/DeleteAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     mustDeleteAcct,
     ({
@@ -312,7 +312,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
 #   include <xrpld/app/tx/detail/NFTokenMint.h>
 #endif
 TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     changeNFTCounts,
     ({
@@ -330,7 +330,7 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
 #   include <xrpld/app/tx/detail/NFTokenBurn.h>
 #endif
 TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     changeNFTCounts,
     ({
@@ -343,7 +343,7 @@ TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
 #   include <xrpld/app/tx/detail/NFTokenCreateOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -359,7 +359,7 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
 #   include <xrpld/app/tx/detail/NFTokenCancelOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -371,7 +371,7 @@ TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
 #   include <xrpld/app/tx/detail/NFTokenAcceptOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
-    Delegation::delegatable,
+    Delegation::delegable,
     uint256{},
     noPriv,
     ({
@@ -385,7 +385,7 @@ TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
 #   include <xrpld/app/tx/detail/Clawback.h>
 #endif
 TRANSACTION(ttCLAWBACK, 30, Clawback,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureClawback,
     noPriv,
     ({
@@ -398,7 +398,7 @@ TRANSACTION(ttCLAWBACK, 30, Clawback,
 #   include <xrpld/app/tx/detail/AMMClawback.h>
 #endif
 TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMMClawback,
     mayDeleteAcct | overrideFreeze,
     ({
@@ -413,7 +413,7 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
 #   include <xrpld/app/tx/detail/AMMCreate.h>
 #endif
 TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     createPseudoAcct,
     ({
@@ -427,7 +427,7 @@ TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
 #   include <xrpld/app/tx/detail/AMMDeposit.h>
 #endif
 TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     noPriv,
     ({
@@ -445,7 +445,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
 #   include <xrpld/app/tx/detail/AMMWithdraw.h>
 #endif
 TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     mayDeleteAcct,
     ({
@@ -462,7 +462,7 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
 #   include <xrpld/app/tx/detail/AMMVote.h>
 #endif
 TRANSACTION(ttAMM_VOTE, 38, AMMVote,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     noPriv,
     ({
@@ -476,7 +476,7 @@ TRANSACTION(ttAMM_VOTE, 38, AMMVote,
 #   include <xrpld/app/tx/detail/AMMBid.h>
 #endif
 TRANSACTION(ttAMM_BID, 39, AMMBid,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     noPriv,
     ({
@@ -492,7 +492,7 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
 #   include <xrpld/app/tx/detail/AMMDelete.h>
 #endif
 TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureAMM,
     mustDeleteAcct,
     ({
@@ -505,7 +505,7 @@ TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
 #   include <xrpld/app/tx/detail/XChainBridge.h>
 #endif
 TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -516,7 +516,7 @@ TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
 
 /** This transactions initiates a crosschain transaction */
 TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -528,7 +528,7 @@ TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
 
 /** This transaction completes a crosschain transaction */
 TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -541,7 +541,7 @@ TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
 
 /** This transaction initiates a crosschain account create transaction */
 TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -553,7 +553,7 @@ TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
 
 /** This transaction adds an attestation to a claim */
 TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     createAcct,
     ({
@@ -574,7 +574,7 @@ TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
 /** This transaction adds an attestation to an account */
 TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
     XChainAddAccountCreateAttestation,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     createAcct,
     ({
@@ -595,7 +595,7 @@ TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
 
 /** This transaction modifies a sidechain */
 TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -606,7 +606,7 @@ TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
 
 /** This transactions creates a sidechain */
 TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureXChainBridge,
     noPriv,
     ({
@@ -620,7 +620,7 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
 #   include <xrpld/app/tx/detail/DID.h>
 #endif
 TRANSACTION(ttDID_SET, 49, DIDSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureDID,
     noPriv,
     ({
@@ -631,7 +631,7 @@ TRANSACTION(ttDID_SET, 49, DIDSet,
 
 /** This transaction type deletes a DID */
 TRANSACTION(ttDID_DELETE, 50, DIDDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureDID,
     noPriv,
     ({}))
@@ -641,7 +641,7 @@ TRANSACTION(ttDID_DELETE, 50, DIDDelete,
 #   include <xrpld/app/tx/detail/SetOracle.h>
 #endif
 TRANSACTION(ttORACLE_SET, 51, OracleSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featurePriceOracle,
     noPriv,
     ({
@@ -658,7 +658,7 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
 #   include <xrpld/app/tx/detail/DeleteOracle.h>
 #endif
 TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featurePriceOracle,
     noPriv,
     ({
@@ -670,7 +670,7 @@ TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
 #   include <xrpld/app/tx/detail/LedgerStateFix.h>
 #endif
 TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
-    Delegation::delegatable,
+    Delegation::delegable,
     fixNFTokenPageLinks,
     noPriv,
     ({
@@ -683,7 +683,7 @@ TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
 #   include <xrpld/app/tx/detail/MPTokenIssuanceCreate.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureMPTokensV1,
     createMPTIssuance,
     ({
@@ -700,7 +700,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
 #   include <xrpld/app/tx/detail/MPTokenIssuanceDestroy.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureMPTokensV1,
     destroyMPTIssuance,
     ({
@@ -712,7 +712,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
 #   include <xrpld/app/tx/detail/MPTokenIssuanceSet.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureMPTokensV1,
     noPriv,
     ({
@@ -729,7 +729,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
 #   include <xrpld/app/tx/detail/MPTokenAuthorize.h>
 #endif
 TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureMPTokensV1,
     mustAuthorizeMPT,
     ({
@@ -742,7 +742,7 @@ TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
 #   include <xrpld/app/tx/detail/Credentials.h>
 #endif
 TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureCredentials,
     noPriv,
     ({
@@ -754,7 +754,7 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
 
 /** This transaction type accept an Credential object */
 TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureCredentials,
     noPriv,
     ({
@@ -764,7 +764,7 @@ TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
 
 /** This transaction type delete an Credential object */
 TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureCredentials,
     noPriv,
     ({
@@ -778,7 +778,7 @@ TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
 #   include <xrpld/app/tx/detail/NFTokenModify.h>
 #endif
 TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureDynamicNFT,
     noPriv,
     ({
@@ -792,7 +792,7 @@ TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
 #   include <xrpld/app/tx/detail/PermissionedDomainSet.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featurePermissionedDomains,
     noPriv,
     ({
@@ -805,7 +805,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
 #   include <xrpld/app/tx/detail/PermissionedDomainDelete.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featurePermissionedDomains,
     noPriv,
     ({
@@ -817,7 +817,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
 #   include <xrpld/app/tx/detail/DelegateSet.h>
 #endif
 TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     featurePermissionDelegationV1_1,
     noPriv,
     ({
@@ -830,7 +830,7 @@ TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
 #   include <xrpld/app/tx/detail/VaultCreate.h>
 #endif
 TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     createPseudoAcct | createMPTIssuance | mustModifyVault,
     ({
@@ -848,7 +848,7 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
 #   include <xrpld/app/tx/detail/VaultSet.h>
 #endif
 TRANSACTION(ttVAULT_SET, 66, VaultSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     mustModifyVault,
     ({
@@ -863,7 +863,7 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet,
 #   include <xrpld/app/tx/detail/VaultDelete.h>
 #endif
 TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     mustDeleteAcct | destroyMPTIssuance | mustModifyVault,
     ({
@@ -875,7 +875,7 @@ TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
 #   include <xrpld/app/tx/detail/VaultDeposit.h>
 #endif
 TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     mayAuthorizeMPT | mustModifyVault,
     ({
@@ -888,7 +888,7 @@ TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
 #   include <xrpld/app/tx/detail/VaultWithdraw.h>
 #endif
 TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     mayDeleteMPT | mayAuthorizeMPT | mustModifyVault,
     ({
@@ -903,7 +903,7 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
 #   include <xrpld/app/tx/detail/VaultClawback.h>
 #endif
 TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureSingleAssetVault,
     mayDeleteMPT | mustModifyVault,
     ({
@@ -917,7 +917,7 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
 #   include <xrpld/app/tx/detail/Batch.h>
 #endif
 TRANSACTION(ttBATCH, 71, Batch,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     featureBatch,
     noPriv,
     ({
@@ -932,7 +932,7 @@ TRANSACTION(ttBATCH, 71, Batch,
 #   include <xrpld/app/tx/detail/LoanBrokerSet.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     createPseudoAcct | mayAuthorizeMPT, ({
     {sfVaultID, soeREQUIRED},
@@ -949,7 +949,7 @@ TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
 #   include <xrpld/app/tx/detail/LoanBrokerDelete.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     mustDeleteAcct | mayAuthorizeMPT, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -960,7 +960,7 @@ TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
 #   include <xrpld/app/tx/detail/LoanBrokerCoverDeposit.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -972,7 +972,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
 #   include <xrpld/app/tx/detail/LoanBrokerCoverWithdraw.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     mayAuthorizeMPT, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -987,7 +987,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
 #   include <xrpld/app/tx/detail/LoanBrokerCoverClawback.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanBrokerID, soeOPTIONAL},
@@ -999,7 +999,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
 #   include <xrpld/app/tx/detail/LoanSet.h>
 #endif
 TRANSACTION(ttLOAN_SET, 80, LoanSet,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     mayAuthorizeMPT | mustModifyVault, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -1026,7 +1026,7 @@ TRANSACTION(ttLOAN_SET, 80, LoanSet,
 #   include <xrpld/app/tx/detail/LoanDelete.h>
 #endif
 TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanID, soeREQUIRED},
@@ -1037,7 +1037,7 @@ TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
 #   include <xrpld/app/tx/detail/LoanManage.h>
 #endif
 TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     // All of the LoanManage options will modify the vault, but the
     // transaction can succeed without options, essentially making it
@@ -1051,7 +1051,7 @@ TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
 #   include <xrpld/app/tx/detail/LoanPay.h>
 #endif
 TRANSACTION(ttLOAN_PAY, 84, LoanPay,
-    Delegation::delegatable,
+    Delegation::delegable,
     featureLendingProtocol,
     mayAuthorizeMPT | mustModifyVault, ({
     {sfLoanID, soeREQUIRED},
@@ -1066,7 +1066,7 @@ TRANSACTION(ttLOAN_PAY, 84, LoanPay,
 #   include <xrpld/app/tx/detail/Change.h>
 #endif
 TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({
@@ -1078,7 +1078,7 @@ TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
     For details, see: https://xrpl.org/fee-voting.html
  */
 TRANSACTION(ttFEE, 101, SetFee,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({
@@ -1099,7 +1099,7 @@ TRANSACTION(ttFEE, 101, SetFee,
     For details, see: https://xrpl.org/negative-unl.html
  */
 TRANSACTION(ttUNL_MODIFY, 102, UNLModify,
-    Delegation::notDelegatable,
+    Delegation::notDelegable,
     uint256{},
     noPriv,
     ({

include/xrpl/resource/README.md

@@ -66,7 +66,7 @@ values over time: this is implemented by the DecayingSample class.
 Each server in a cluster creates a list of IP addresses of end points
 that are imposing a significant load. This list is called Gossip, which
 is passed to other nodes in that cluster. Gossip helps individual
-servers in the cluster identify IP addreses that might be unduly loading
+servers in the cluster identify IP addresses that might be unduly loading
 the entire cluster. Again the recourse of the individual servers is to
 drop connections to those IP addresses that occur commonly in the gossip.
 

include/xrpl/resource/detail/Logic.h

@@ -61,7 +61,7 @@ private:
     // List of all active admin entries
     EntryIntrusiveList admin_;
 
-    // List of all inactve entries
+    // List of all inactive entries
     EntryIntrusiveList inactive_;
 
     // All imported gossip data

include/xrpl/server/detail/LowestLayer.h

@@ -9,7 +9,7 @@
 
 namespace xrpl {
 
-// Before boost 1.70, get_lowest_layer required an explicit templat parameter
+// Before boost 1.70, get_lowest_layer required an explicit template parameter
 template <class T>
 decltype(auto)
 get_lowest_layer(T& t) noexcept

include/xrpl/shamap/README.md

@@ -226,7 +226,7 @@ The `fetchNodeNT()` method goes through three phases:
 
     Any SHAMapLeafNode that is immutable has a sequence number of zero
     (sharable). When a mutable `SHAMap` is created then its SHAMapTreeNodes are
-    given non-zero sequence numbers (unsharable). But all nodes in the
+    given non-zero sequence numbers (unshareable). But all nodes in the
     TreeNodeCache are immutable, so if one is found here, its sequence number
     will be 0.
 

include/xrpl/shamap/SHAMapItem.h

@@ -125,13 +125,13 @@ intrusive_ptr_release(SHAMapItem const* x)
     {
         auto p = reinterpret_cast<std::uint8_t const*>(x);
 
-        // The SHAMapItem constuctor isn't trivial (because the destructor
+        // The SHAMapItem constructor isn't trivial (because the destructor
         // for CountedObject isn't) so we can't avoid calling it here, but
         // plan for a future where we might not need to.
         if constexpr (!std::is_trivially_destructible_v<SHAMapItem>)
             std::destroy_at(x);
 
-        // If the slabber doens't claim this pointer, it was allocated
+        // If the slabber doesn't claim this pointer, it was allocated
         // manually, so we free it manually.
         if (!detail::slabber.deallocate(const_cast<std::uint8_t*>(p)))
             delete[] p;