Merge branch 'develop' into mvadari/rearch/account

include/xrpl/basics/Expected.h

@@ -148,17 +148,23 @@ public:
     }
 
     [[nodiscard]] constexpr E const&
-    error() const
+    error() const&
     {
         return Base::error();
     }
 
-    constexpr E&
-    error()
+    [[nodiscard]] constexpr E&
+    error() &
     {
         return Base::error();
     }
 
+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
     constexpr explicit
     operator bool() const
     {
@@ -215,17 +221,23 @@ public:
     }
 
     [[nodiscard]] constexpr E const&
-    error() const
+    error() const&
     {
         return Base::error();
     }
 
-    constexpr E&
-    error()
+    [[nodiscard]] constexpr E&
+    error() &
     {
         return Base::error();
     }
 
+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
     constexpr explicit
     operator bool() const
     {

include/xrpl/basics/Log.h

@@ -10,24 +10,11 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <utility>
 
 namespace xrpl {
 
-// DEPRECATED use beast::severities::Severity instead
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum LogSeverity {
-    LSInvalid = -1,  // used to indicate an invalid severity
-    LSTrace = 0,     // Very low-level progress information, details inside
-                     // an operation
-    LSDebug = 1,     // Function-level progress information, operations
-    LSInfo = 2,      // Server-level progress information, major operations
-    LSWarning = 3,   // Conditions that warrant human attention, may indicate
-                     // a problem
-    LSError = 4,     // A condition that indicates a problem
-    LSFatal = 5      // A severe condition that indicates a server problem
-};
-
 /** Manages partitions for logging. */
 class Logs
 {
@@ -39,17 +26,17 @@ private:
         std::string partition_;
 
     public:
-        Sink(std::string partition, beast::severities::Severity thresh, Logs& logs);
+        Sink(std::string partition, beast::Severity thresh, Logs& logs);
 
         Sink(Sink const&) = delete;
         Sink&
         operator=(Sink const&) = delete;
 
         void
-        write(beast::severities::Severity level, std::string const& text) override;
+        write(beast::Severity level, std::string const& text) override;
 
         void
-        writeAlways(beast::severities::Severity level, std::string const& text) override;
+        writeAlways(beast::Severity level, std::string const& text) override;
     };
 
     /** Manages a system file containing logged output.
@@ -136,12 +123,12 @@ private:
 
     std::mutex mutable mutex_;
     std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
-    beast::severities::Severity thresh_;
+    beast::Severity thresh_;
     File file_;
     bool silent_ = false;
 
 public:
-    Logs(beast::severities::Severity level);
+    Logs(beast::Severity level);
 
     Logs(Logs const&) = delete;
     Logs&
@@ -161,18 +148,18 @@ public:
     beast::Journal
     journal(std::string const& name);
 
-    beast::severities::Severity
+    beast::Severity
     threshold() const;
 
     void
-    threshold(beast::severities::Severity thresh);
+    threshold(beast::Severity thresh);
 
     std::vector<std::pair<std::string, std::string>>
     partitionSeverities() const;
 
     void
     write(
-        beast::severities::Severity level,
+        beast::Severity level,
         std::string const& partition,
         std::string const& text,
         bool console);
@@ -192,36 +179,25 @@ public:
     }
 
     virtual std::unique_ptr<beast::Journal::Sink>
-    makeSink(std::string const& partition, beast::severities::Severity startingLevel);
+    makeSink(std::string const& partition, beast::Severity startingLevel);
 
 public:
-    static LogSeverity
-    fromSeverity(beast::severities::Severity level);
-
-    static beast::severities::Severity
-    toSeverity(LogSeverity level);
-
     static std::string
-    toString(LogSeverity s);
+    toString(beast::Severity s);
 
-    static LogSeverity
+    static std::optional<beast::Severity>
     fromString(std::string const& s);
 
 private:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        // Maximum line length for log messages.
-        // If the message exceeds this length it will be truncated with
-        // ellipses.
-        MaximumMessageCharacters = 12 * 1024
-    };
+    // Maximum line length for log messages.
+    // If the message exceeds this length it will be truncated with ellipses.
+    static constexpr auto kMAXIMUM_MESSAGE_CHARACTERS = 12 * 1024;
 
     static void
     format(
         std::string& output,
         std::string const& message,
-        beast::severities::Severity severity,
+        beast::Severity severity,
         std::string const& partition);
 };
 

include/xrpl/basics/SHAMapHash.h

@@ -21,12 +21,12 @@ public:
     }
 
     [[nodiscard]] uint256 const&
-    asUint256() const
+    asUInt256() const
     {
         return hash_;
     }
     uint256&
-    asUint256()
+    asUInt256()
     {
         return hash_;
     }
@@ -93,7 +93,7 @@ template <>
 inline std::size_t
 extract(SHAMapHash const& key)
 {
-    return *reinterpret_cast<std::size_t const*>(key.asUint256().data());
+    return *reinterpret_cast<std::size_t const*>(key.asUInt256().data());
 }
 
 }  // namespace xrpl

include/xrpl/basics/StringUtilities.h

@@ -7,9 +7,11 @@
 #include <boost/utility/string_view.hpp>
 
 #include <array>
+#include <concepts>
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <type_traits>
 
 namespace xrpl {
 
@@ -26,28 +28,39 @@ namespace xrpl {
 std::string
 sqlBlobLiteral(Blob const& blob);
 
+namespace detail {
+
+template <typename T>
+concept SomeChar = std::same_as<std::remove_cvref_t<T>, int8_t> ||
+    std::same_as<std::remove_cvref_t<T>, char> || std::same_as<std::remove_cvref_t<T>, uint8_t>;
+
+inline constexpr std::array<std::optional<int>, 256> const kDIGIT_LOOKUP_TABLE = []() {
+    std::array<std::optional<int>, 256> t{};
+
+    for (int i = 0; i < 10; ++i)
+        t['0' + i] = i;
+
+    for (int i = 0; i < 6; ++i)
+    {
+        t['A' + i] = 10 + i;
+        t['a' + i] = 10 + i;
+    }
+
+    return t;
+}();
+
+inline std::optional<int>
+hexCharToInt(SomeChar auto hexChar)
+{
+    return kDIGIT_LOOKUP_TABLE[static_cast<uint8_t>(hexChar)];
+}
+
+}  // namespace detail
+
 template <class Iterator>
 std::optional<Blob>
 strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 {
-    static constexpr std::array<int, 256> const kDIGIT_LOOKUP_TABLE = []() {
-        std::array<int, 256> t{};
-
-        for (auto& x : t)
-            x = -1;
-
-        for (int i = 0; i < 10; ++i)
-            t['0' + i] = i;
-
-        for (int i = 0; i < 6; ++i)
-        {
-            t['A' + i] = 10 + i;
-            t['a' + i] = 10 + i;
-        }
-
-        return t;
-    }();
-
     Blob out;
 
     out.reserve((strSize + 1) / 2);
@@ -56,27 +69,26 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     if (strSize & 1)
     {
-        int c = kDIGIT_LOOKUP_TABLE[*iter++];
-
-        if (c < 0)
+        auto const c = detail::hexCharToInt(*iter++);
+        if (!c.has_value())
             return {};
 
-        out.push_back(c);
+        out.push_back(static_cast<unsigned char>(*c));
     }
 
     while (iter != end)
     {
-        int const cHigh = kDIGIT_LOOKUP_TABLE[*iter++];
+        auto const cHigh = detail::hexCharToInt(*iter++);
 
-        if (cHigh < 0)
+        if (!cHigh.has_value())
             return {};
 
-        int const cLow = kDIGIT_LOOKUP_TABLE[*iter++];
+        auto const cLow = detail::hexCharToInt(*iter++);
 
-        if (cLow < 0)
+        if (!cLow.has_value())
             return {};
 
-        out.push_back(static_cast<unsigned char>((cHigh << 4) | cLow));
+        out.push_back(static_cast<unsigned char>((*cHigh << 4) | *cLow));
     }
 
     return {std::move(out)};
@@ -120,7 +132,7 @@ std::string
 trimWhitespace(std::string str);
 
 std::optional<std::uint64_t>
-toUint64(std::string const& s);
+toUInt64(std::string const& s);
 
 /** Determines if the given string looks like a TOML-file hosting domain.
 

include/xrpl/basics/base_uint.h

@@ -46,6 +46,11 @@ struct IsContiguousContainer<Slice> : std::true_type
 {
 };
 
+template <typename...>
+struct AlwaysFalseT : std::bool_constant<false>
+{
+};
+
 }  // namespace detail
 
 /** Integers of any length that is a multiple of 32-bits
@@ -62,7 +67,7 @@ struct IsContiguousContainer<Slice> : std::true_type
                       number of bits.
  */
 template <std::size_t Bits, class Tag = void>
-class BaseUint
+class BaseUInt
 {
     static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32.");
 
@@ -160,7 +165,7 @@ private:
         explicit VoidHelper() = default;
     };
 
-    explicit BaseUint(void const* data, VoidHelper)
+    explicit BaseUInt(void const* data, VoidHelper)
     {
         memcpy(data_.data(), data, kBYTES);
     }
@@ -244,15 +249,15 @@ private:
     }
 
 public:
-    constexpr BaseUint() : data_{}
+    constexpr BaseUInt() : data_{}
     {
     }
 
-    constexpr BaseUint(beast::Zero) : data_{}
+    constexpr BaseUInt(beast::Zero) : data_{}
     {
     }
 
-    explicit BaseUint(std::uint64_t b)
+    explicit BaseUInt(std::uint64_t b)
     {
         *this = b;
     }
@@ -260,7 +265,7 @@ public:
     // This constructor is intended to be used at compile time since it might
     // throw at runtime.  Consider declaring this constructor consteval once
     // we get to C++23.
-    explicit constexpr BaseUint(std::string_view sv) noexcept(false)
+    explicit constexpr BaseUInt(std::string_view sv) noexcept(false)
         : data_(parseFromStringViewThrows(sv))
     {
     }
@@ -270,24 +275,42 @@ public:
         class = std::enable_if_t<
             detail::IsContiguousContainer<Container>::value &&
             std::is_trivially_copyable_v<typename Container::value_type>>>
-    explicit BaseUint(Container const& c)
+    explicit BaseUInt(Container const& c)
     {
+        // Use AlwaysFalseT so the static_assert condition is dependent
+        // and only triggers when this constructor template is instantiated.
+        static_assert(
+            detail::AlwaysFalseT<Container>::value,
+            "This constructor is not intended to be used and will be soon removed. "
+            "Use base_uint::fromRaw instead.");
+    }
+
+    template <
+        class Container,
+        class = std::enable_if_t<
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>>>
+    static BaseUInt
+    fromRaw(Container const& c)
+    {
+        BaseUInt result;
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::base_uint::base_uint(Container auto) : input size match");
-        std::memcpy(data_.data(), c.data(), size());
+            "xrpl::BaseUInt::fromRaw(Container auto) : input size match");
+        std::memcpy(result.data_.data(), c.data(), size());
+        return result;
     }
 
     template <class Container>
     std::enable_if_t<
         detail::IsContiguousContainer<Container>::value &&
             std::is_trivially_copyable_v<typename Container::value_type>,
-        BaseUint&>
+        BaseUInt&>
     operator=(Container const& c)
     {
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::base_uint::operator=(Container auto) : input size match");
+            "xrpl::BaseUInt::operator=(Container auto) : input size match");
         std::memcpy(data_.data(), c.data(), size());
         return *this;
     }
@@ -295,14 +318,14 @@ public:
     /* Construct from a raw pointer.
         The buffer pointed to by `data` must be at least Bits/8 bytes.
     */
-    static BaseUint
+    static BaseUInt
     fromVoid(void const* data)
     {
-        return BaseUint(data, VoidHelper());
+        return BaseUInt(data, VoidHelper());
     }
 
     template <class T>
-    static std::optional<BaseUint>
+    static std::optional<BaseUInt>
     fromVoidChecked(T const& from)
     {
         if (from.size() != size())
@@ -328,10 +351,10 @@ public:
         return *this == beast::kZERO;
     }
 
-    constexpr BaseUint
+    constexpr BaseUInt
     operator~() const
     {
-        BaseUint ret;
+        BaseUInt ret;
 
         for (int i = 0; i < kWIDTH; i++)
             ret.data_[i] = ~data_[i];
@@ -339,7 +362,7 @@ public:
         return ret;
     }
 
-    BaseUint&
+    BaseUInt&
     operator=(std::uint64_t uHost)
     {
         *this = beast::kZERO;
@@ -357,8 +380,8 @@ public:
         return *this;
     }
 
-    BaseUint&
-    operator^=(BaseUint const& b)
+    BaseUInt&
+    operator^=(BaseUInt const& b)
     {
         for (int i = 0; i < kWIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -366,8 +389,8 @@ public:
         return *this;
     }
 
-    BaseUint&
-    operator&=(BaseUint const& b)
+    BaseUInt&
+    operator&=(BaseUInt const& b)
     {
         for (int i = 0; i < kWIDTH; i++)
             data_[i] &= b.data_[i];
@@ -375,8 +398,8 @@ public:
         return *this;
     }
 
-    BaseUint&
-    operator|=(BaseUint const& b)
+    BaseUInt&
+    operator|=(BaseUInt const& b)
     {
         for (int i = 0; i < kWIDTH; i++)
             data_[i] |= b.data_[i];
@@ -384,7 +407,7 @@ public:
         return *this;
     }
 
-    BaseUint&
+    BaseUInt&
     operator++()
     {
         // prefix operator
@@ -398,17 +421,17 @@ public:
         return *this;
     }
 
-    BaseUint
+    BaseUInt
     operator++(int)
     {
         // postfix operator
-        BaseUint const ret = *this;
+        BaseUInt const ret = *this;
         ++(*this);
 
         return ret;
     }
 
-    BaseUint&
+    BaseUInt&
     operator--()
     {
         for (int i = kWIDTH - 1; i >= 0; --i)
@@ -423,32 +446,32 @@ public:
         return *this;
     }
 
-    BaseUint
+    BaseUInt
     operator--(int)
     {
         // postfix operator
-        BaseUint const ret = *this;
+        BaseUInt const ret = *this;
         --(*this);
 
         return ret;
     }
 
-    [[nodiscard]] BaseUint
+    [[nodiscard]] BaseUInt
     next() const
     {
         auto ret = *this;
         return ++ret;
     }
 
-    [[nodiscard]] BaseUint
+    [[nodiscard]] BaseUInt
     prev() const
     {
         auto ret = *this;
         return --ret;
     }
 
-    BaseUint&
-    operator+=(BaseUint const& b)
+    BaseUInt&
+    operator+=(BaseUInt const& b)
     {
         std::uint64_t carry = 0;
 
@@ -466,7 +489,7 @@ public:
 
     template <class Hasher>
     friend void
-    hash_append(Hasher& h, BaseUint const& a) noexcept
+    hash_append(Hasher& h, BaseUInt const& a) noexcept
     {
         // Do not allow any endian transformations on this memory
         h(a.data_.data(), sizeof(a.data_));
@@ -509,7 +532,7 @@ public:
         return kBYTES;
     }
 
-    BaseUint<Bits, Tag>&
+    BaseUInt<Bits, Tag>&
     operator=(beast::Zero)
     {
         data_.fill(0);
@@ -534,14 +557,14 @@ public:
     }
 };
 
-using uint128 = BaseUint<128>;
-using uint160 = BaseUint<160>;
-using uint256 = BaseUint<256>;
-using uint192 = BaseUint<192>;
+using uint128 = BaseUInt<128>;
+using uint160 = BaseUInt<160>;
+using uint256 = BaseUInt<256>;
+using uint192 = BaseUInt<192>;
 
 template <std::size_t Bits, class Tag>
 [[nodiscard]] constexpr std::strong_ordering
-operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
+operator<=>(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 {
     // This comparison might seem wrong on a casual inspection because it
     // compares data internally stored as std::uint32_t byte-by-byte. But
@@ -562,7 +585,7 @@ operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
 
 template <std::size_t Bits, typename Tag>
 [[nodiscard]] constexpr bool
-operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
+operator==(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 {
     return (lhs <=> rhs) == 0;
 }
@@ -570,59 +593,59 @@ operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 constexpr bool
-operator==(BaseUint<Bits, Tag> const& a, std::uint64_t b)
+operator==(BaseUInt<Bits, Tag> const& a, std::uint64_t b)
 {
-    return a == BaseUint<Bits, Tag>(b);
+    return a == BaseUInt<Bits, Tag>(b);
 }
 
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator^(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator^(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) ^= b;
+    return BaseUInt<Bits, Tag>(a) ^= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator&(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator&(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) &= b;
+    return BaseUInt<Bits, Tag>(a) &= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator|(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator|(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) |= b;
+    return BaseUInt<Bits, Tag>(a) |= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator+(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator+(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) += b;
+    return BaseUInt<Bits, Tag>(a) += b;
 }
 
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 inline std::string
-to_string(BaseUint<Bits, Tag> const& a)
+to_string(BaseUInt<Bits, Tag> const& a)
 {
     return strHex(a.cbegin(), a.cend());
 }
 
 template <std::size_t Bits, class Tag>
 inline std::string
-toShortString(BaseUint<Bits, Tag> const& a)
+toShortString(BaseUInt<Bits, Tag> const& a)
 {
-    static_assert(BaseUint<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
+    static_assert(BaseUInt<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
     return strHex(a.cbegin(), a.cbegin() + 4) + "...";
 }
 
 template <std::size_t Bits, class Tag>
 inline std::ostream&
-operator<<(std::ostream& out, BaseUint<Bits, Tag> const& u)
+operator<<(std::ostream& out, BaseUInt<Bits, Tag> const& u)
 {
     return out << to_string(u);
 }
@@ -650,7 +673,7 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
 namespace beast {
 
 template <std::size_t Bits, class Tag>
-struct IsUniquelyRepresented<xrpl::BaseUint<Bits, Tag>> : public std::true_type
+struct IsUniquelyRepresented<xrpl::BaseUInt<Bits, Tag>> : public std::true_type
 {
     explicit IsUniquelyRepresented() = default;
 };

include/xrpl/basics/partitioned_unordered_map.h

@@ -236,7 +236,7 @@ public:
         map_.resize(partitions_);
         XRPL_ASSERT(
             partitions_,
-            "xrpl::partitioned_unordered_map::partitioned_unordered_map : "
+            "xrpl::PartitionedUnorderedMap::PartitionedUnorderedMap : "
             "nonzero partitions");
     }
 

include/xrpl/basics/random.h

@@ -94,7 +94,7 @@ template <class Engine, class Integral>
 std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral min, Integral max)
 {
-    XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
+    XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
 
     // This should have no state and constructing it should
     // be very cheap. If that turns out not to be the case

include/xrpl/basics/safe_cast.h

@@ -81,7 +81,7 @@ safeDowncast(Src* s) noexcept
     return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
 #else
     auto* result = dynamic_cast<Dest>(s);
-    XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid");
+    XRPL_ASSERT(result != nullptr, "xrpl::safeDowncast : pointer downcast is valid");
     return result;
 #endif
 }
@@ -94,7 +94,7 @@ safeDowncast(Src& s) noexcept
 #ifndef NDEBUG
     XRPL_ASSERT(
         dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
-        "xrpl::safe_downcast : reference downcast is valid");
+        "xrpl::safeDowncast : reference downcast is valid");
 #endif
     return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
 }

include/xrpl/basics/scope.h

@@ -205,7 +205,7 @@ class ScopeUnlock
 public:
     explicit ScopeUnlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock_(&lock)
     {
-        XRPL_ASSERT(plock_->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
+        XRPL_ASSERT(plock_->owns_lock(), "xrpl::ScopeUnlock::ScopeUnlock : mutex must be locked");
         plock_->unlock();
     }
 

include/xrpl/basics/spinlock.h

@@ -103,7 +103,7 @@ public:
     {
         XRPL_ASSERT(
             index >= 0 && (mask_ != 0),
-            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
+            "xrpl::PackedSpinlock::PackedSpinlock : valid index and mask");
     }
 
     [[nodiscard]] bool

include/xrpl/beast/asio/io_latency_probe.h

@@ -15,7 +15,7 @@ namespace beast {
 
 /** Measures handler latency on an io_context queue. */
 template <class Clock>
-class IoLatencyProbe
+class IOLatencyProbe
 {
 private:
     using duration = typename Clock::duration;
@@ -30,12 +30,12 @@ private:
     bool cancel_{false};
 
 public:
-    IoLatencyProbe(duration const& period, boost::asio::io_context& ios)
+    IOLatencyProbe(duration const& period, boost::asio::io_context& ios)
         : period_(period), ios_(ios), timer_(ios_)
     {
     }
 
-    ~IoLatencyProbe()
+    ~IOLatencyProbe()
     {
         std::unique_lock<decltype(mutex_)> lock(mutex_);
         cancel(lock, true);
@@ -85,7 +85,7 @@ public:
     {
         std::scoped_lock const lock(mutex_);
         if (cancel_)
-            throw std::logic_error("io_latency_probe is canceled");
+            throw std::logic_error("IOLatencyProbe is canceled");
         boost::asio::post(
             ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
     }
@@ -100,7 +100,7 @@ public:
     {
         std::scoped_lock const lock(mutex_);
         if (cancel_)
-            throw std::logic_error("io_latency_probe is canceled");
+            throw std::logic_error("IOLatencyProbe is canceled");
         boost::asio::post(
             ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
     }
@@ -140,18 +140,18 @@ private:
         Handler handler;
         time_point start;
         bool repeat;
-        IoLatencyProbe* probe;
+        IOLatencyProbe* probe;
 
         SampleOp(
             Handler const& handler,
             time_point const& start,
             bool repeat,
-            IoLatencyProbe* probe)
+            IOLatencyProbe* probe)
             : handler(handler), start(start), repeat(repeat), probe(probe)
         {
             XRPL_ASSERT(
                 probe,
-                "beast::io_latency_probe::sample_op::sample_op : non-null "
+                "beast::IOLatencyProbe::SampleOp::SampleOp : non-null "
                 "probe input");
             probe->addref();
         }
@@ -164,7 +164,7 @@ private:
         {
             XRPL_ASSERT(
                 probe,
-                "beast::io_latency_probe::sample_op::sample_op(sample_op&&) : "
+                "beast::IOLatencyProbe::SampleOp::SampleOp(SampleOp&&) : "
                 "non-null probe input");
             from.probe = nullptr;
         }

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

@@ -1370,7 +1370,7 @@ private:
             buck_.resize(size() + additional, cont_);
         XRPL_ASSERT(
             loadFactor() <= maxLoadFactor(),
-            "beast::detail::AgedUnorderedContainer::maybe_rehash : maximum "
+            "beast::detail::AgedUnorderedContainer::maybeRehash : maximum "
             "load factor");
     }
 

include/xrpl/beast/unit_test/reporter.h

@@ -62,9 +62,7 @@ private:
     {
         using run_time = std::pair<std::string, typename clock_type::duration>;
 
-        // Need to be named before converting
-        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-        enum { MaxTop = 10 };
+        static constexpr auto kMAX_TOP = 10;
 
         std::size_t suites = 0;
         std::size_t cases = 0;
@@ -148,11 +146,11 @@ Reporter<Unused>::Results::add(SuiteResults const& r)
             });
         if (iter != top.end())
         {
-            if (top.size() == MaxTop)
+            if (top.size() == kMAX_TOP)
                 top.resize(top.size() - 1);
             top.emplace(iter, r.name, elapsed);
         }
-        else if (top.size() < MaxTop)
+        else if (top.size() < kMAX_TOP)
         {
             top.emplace_back(r.name, elapsed);
         }

include/xrpl/beast/utility/Journal.h

@@ -2,29 +2,25 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 
+#include <cstdint>
 #include <sstream>
 
 namespace beast {
 
-/** A namespace for easy access to logging severity values. */
-namespace severities {
 /** Severity level / threshold of a Journal message. */
-// Hundreds of usages via logging macros
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum Severity {
-    KAll = 0,
+enum class Severity : std::uint8_t {
+    All = 0,
 
-    KTrace = KAll,
-    KDebug = 1,
-    KInfo = 2,
-    KWarning = 3,
-    KError = 4,
-    KFatal = 5,
+    Trace = All,
+    Debug = 1,
+    Info = 2,
+    Warning = 3,
+    Error = 4,
+    Fatal = 5,
 
-    KDisabled = 6,
-    KNone = KDisabled
+    Disabled = 6,
+    None = Disabled
 };
-}  // namespace severities
 
 /** A generic endpoint for log messages.
 
@@ -44,9 +40,6 @@ public:
     class Sink;
 
 private:
-    // Severity level / threshold of a Journal message.
-    using Severity = severities::Severity;
-
     // Invariant: sink_ always points to a valid Sink
     Sink* sink_;
 
@@ -183,7 +176,7 @@ public:
     {
     public:
         /** Create a stream which produces no output. */
-        explicit Stream() : sink_(getNullSink()), level_(severities::KDisabled)
+        explicit Stream() : sink_(getNullSink()), level_(Severity::Disabled)
         {
         }
 
@@ -194,7 +187,7 @@ public:
         Stream(Sink& sink, Severity level) : sink_(sink), level_(level)
         {
             XRPL_ASSERT(
-                level_ < severities::KDisabled, "beast::Journal::Stream::Stream : maximum level");
+                level_ < Severity::Disabled, "beast::Journal::Stream::Stream : maximum level");
         }
 
         /** Construct or copy another Stream. */
@@ -297,37 +290,37 @@ public:
     [[nodiscard]] Stream
     trace() const
     {
-        return {*sink_, severities::KTrace};
+        return {*sink_, Severity::Trace};
     }
 
     [[nodiscard]] Stream
     debug() const
     {
-        return {*sink_, severities::KDebug};
+        return {*sink_, Severity::Debug};
     }
 
     [[nodiscard]] Stream
     info() const
     {
-        return {*sink_, severities::KInfo};
+        return {*sink_, Severity::Info};
     }
 
     [[nodiscard]] Stream
     warn() const
     {
-        return {*sink_, severities::KWarning};
+        return {*sink_, Severity::Warning};
     }
 
     [[nodiscard]] Stream
     error() const
     {
-        return {*sink_, severities::KError};
+        return {*sink_, Severity::Error};
     }
 
     [[nodiscard]] Stream
     fatal() const
     {
-        return {*sink_, severities::KFatal};
+        return {*sink_, Severity::Fatal};
     }
     /** @} */
 };

include/xrpl/beast/utility/WrappedSink.h

@@ -36,7 +36,7 @@ public:
     }
 
     [[nodiscard]] bool
-    active(beast::severities::Severity level) const override
+    active(beast::Severity level) const override
     {
         return sink_.active(level);
     }
@@ -53,27 +53,27 @@ public:
         sink_.console(output);
     }
 
-    [[nodiscard]] beast::severities::Severity
+    [[nodiscard]] beast::Severity
     threshold() const override
     {
         return sink_.threshold();
     }
 
     void
-    threshold(beast::severities::Severity thresh) override
+    threshold(beast::Severity thresh) override
     {
         sink_.threshold(thresh);
     }
 
     void
-    write(beast::severities::Severity level, std::string const& text) override
+    write(beast::Severity level, std::string const& text) override
     {
         using beast::Journal;
         sink_.write(level, prefix_ + text);
     }
 
     void
-    writeAlways(severities::Severity level, std::string const& text) override
+    writeAlways(Severity level, std::string const& text) override
     {
         using beast::Journal;
         sink_.writeAlways(level, prefix_ + text);

include/xrpl/json/JsonPropertyStream.h

@@ -5,7 +5,7 @@
 
 namespace xrpl {
 
-/** A PropertyStream::Sink which produces a json::Value of type objectValue. */
+/** A PropertyStream::Sink which produces a json::Value of type ValueType::Object. */
 class JsonPropertyStream : public beast::PropertyStream
 {
 public:

include/xrpl/json/json_reader.h

@@ -70,24 +70,22 @@ public:
     static constexpr unsigned kNEST_LIMIT{25};
 
 private:
-    // 53 files, protocol-wide
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum TokenType {
-        TokenEndOfStream = 0,
-        TokenObjectBegin,
-        TokenObjectEnd,
-        TokenArrayBegin,
-        TokenArrayEnd,
-        TokenString,
-        TokenInteger,
-        TokenDouble,
-        TokenTrue,
-        TokenFalse,
-        TokenNull,
-        TokenArraySeparator,
-        TokenMemberSeparator,
-        TokenComment,
-        TokenError
+    enum class TokenType {
+        EndOfStream = 0,
+        ObjectBegin,
+        ObjectEnd,
+        ArrayBegin,
+        ArrayEnd,
+        String,
+        Integer,
+        Double,
+        True,
+        False,
+        Null,
+        ArraySeparator,
+        MemberSeparator,
+        Comment,
+        Error
     };
 
     class Token

include/xrpl/json/json_value.h

@@ -15,22 +15,20 @@ namespace json {
 
 /** \brief Type of the value held by a Value object.
  */
-// Used throughout JSON layer
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum ValueType {
-    NullValue = 0,  ///< 'null' value
-    IntValue,       ///< signed integer value
-    UintValue,      ///< unsigned integer value
-    RealValue,      ///< double value
-    StringValue,    ///< UTF-8 string value
-    BooleanValue,   ///< bool value
-    ArrayValue,     ///< array value (ordered list)
-    ObjectValue     ///< object value (collection of name/value pairs).
+enum class ValueType {
+    Null = 0,  ///< 'null' value
+    Int,       ///< signed integer value
+    UInt,      ///< unsigned integer value
+    Real,      ///< double value
+    String,    ///< UTF-8 string value
+    Boolean,   ///< bool value
+    Array,     ///< array value (ordered list)
+    Object     ///< object value (collection of name/value pairs).
 };
 
 /** \brief Lightweight wrapper to tag static string.
  *
- * Value constructor and objectValue member assignment takes advantage of the
+ * Value constructor and ValueType::Object member assignment takes advantage of the
  * StaticString and avoid the cost of string duplication when storing the
  * string or the member name.
  *
@@ -104,8 +102,8 @@ operator!=(StaticString x, std::string const& y)
 /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
  *
  * This class is a discriminated union wrapper that can represent a:
- * - signed integer [range: Value::minInt - Value::maxInt]
- * - unsigned integer (range: 0 - Value::maxUInt)
+ * - signed integer [range: Value::kMIN_INT - Value::kMAX_INT]
+ * - unsigned integer (range: 0 - Value::kMAX_UINT)
  * - double
  * - UTF-8 string
  * - boolean
@@ -116,16 +114,16 @@ operator!=(StaticString x, std::string const& y)
  * The type of the held value is represented by a #ValueType and
  * can be obtained using type().
  *
- * values of an #objectValue or #arrayValue can be accessed using operator[]()
- * methods. Non const methods will automatically create the a #nullValue element
+ * values of an ValueType::Object or ValueType::Array can be accessed using operator[]()
+ * methods. Non const methods will automatically create the a ValueType::Null element
  * if it does not exist.
- * The sequence of an #arrayValue will be automatically resize and initialized
- * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+ * The sequence of an ValueType::Array will be automatically resize and initialized
+ * with ValueType::Null. resize() can be used to enlarge or truncate an ValueType::Array.
  *
  * The get() methods can be used to obtain a default value in the case the
  * required element does not exist.
  *
- * It is possible to iterate over the list of a #objectValue values using
+ * It is possible to iterate over the list of a ValueType::Object values using
  * the getMemberNames() method.
  */
 class Value
@@ -143,15 +141,13 @@ public:
     static Value const kNULL;
     static constexpr Int kMIN_INT = std::numeric_limits<Int>::min();
     static constexpr Int kMAX_INT = std::numeric_limits<Int>::max();
-    static constexpr UInt kMAX_U_INT = std::numeric_limits<UInt>::max();
+    static constexpr UInt kMAX_UINT = std::numeric_limits<UInt>::max();
 
 private:
     class CZString
     {
     public:
-        // Stored as int field, implicit conversion
-        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-        enum DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy };
+        enum class DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy };
 
         CZString(int index);
         CZString(char const* cstr, DuplicationPolicy allocate);
@@ -182,19 +178,19 @@ public:
     /** \brief Create a default Value of the given type.
 
       This is a very useful constructor.
-      To create an empty array, pass arrayValue.
-      To create an empty object, pass objectValue.
+      To create an empty array, pass ValueType::Array.
+      To create an empty object, pass ValueType::Object.
       Another Value can then be set to this one by assignment.
     This is useful since clear() and resize() will not alter types.
 
            Examples:
     \code
     json::Value null_value; // null
-    json::Value arr_value(json::arrayValue); // []
-    json::Value obj_value(json::objectValue); // {}
+    json::Value arr_value(json::ValueType::Array); // []
+    json::Value obj_value(json::ValueType::Object); // {}
     \endcode
          */
-    Value(ValueType type = NullValue);
+    Value(ValueType type = ValueType::Null);
     Value(Int value);
     Value(UInt value);
     Value(double value);
@@ -290,7 +286,7 @@ public:
     operator bool() const;
 
     /// Remove all object members and array elements.
-    /// \pre type() is arrayValue, objectValue, or nullValue
+    /// \pre type() is ValueType::Array, ValueType::Object, or ValueType::Null
     /// \post type() is unchanged
     void
     clear();
@@ -367,7 +363,7 @@ public:
     ///
     /// Do nothing if it did not exist.
     /// \return the removed Value, or null.
-    /// \pre type() is objectValue or nullValue
+    /// \pre type() is ValueType::Object or ValueType::Null
     /// \post type() is unchanged
     Value
     removeMember(char const* key);
@@ -388,8 +384,8 @@ public:
     /// \brief Return a list of the member names.
     ///
     /// If null, return an empty list.
-    /// \pre type() is objectValue or nullValue
-    /// \post if type() was nullValue, it remains nullValue
+    /// \pre type() is ValueType::Object or ValueType::Null
+    /// \post if type() was ValueType::Null, it remains ValueType::Null
     [[nodiscard]] Members
     getMemberNames() const;
 
@@ -469,16 +465,14 @@ operator>=(Value const& x, Value const& y)
  * string value memory management done by Value.
  *
  * - makeMemberName() and releaseMemberName() are called to respectively
- * duplicate and free an json::objectValue member name.
+ * duplicate and free an json::ValueType::Object member name.
  * - duplicateStringValue() and releaseStringValue() are called similarly to
- *   duplicate and free a json::stringValue value.
+ *   duplicate and free a json::ValueType::String value.
  */
 class ValueAllocator
 {
 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { Unknown = (unsigned)-1 };
+    static constexpr auto kUNKNOWN = (unsigned)-1;
 
     virtual ~ValueAllocator() = default;
 
@@ -487,7 +481,7 @@ public:
     virtual void
     releaseMemberName(char* memberName) = 0;
     virtual char*
-    duplicateStringValue(char const* value, unsigned int length = Unknown) = 0;
+    duplicateStringValue(char const* value, unsigned int length = kUNKNOWN) = 0;
     virtual void
     releaseStringValue(char* value) = 0;
 };
@@ -523,12 +517,12 @@ public:
     [[nodiscard]] Value
     key() const;
 
-    /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+    /// Return the index of the referenced Value. -1 if it is not an ValueType::Array.
     [[nodiscard]] UInt
     index() const;
 
     /// Return the member name of the referenced Value. "" if it is not an
-    /// objectValue.
+    /// ValueType::Object.
     [[nodiscard]] char const*
     memberName() const;
 

include/xrpl/json/json_writer.h

@@ -204,31 +204,31 @@ writeValue(Write const& write, Value const& value)
 {
     switch (value.type())
     {
-        case NullValue:
+        case ValueType::Null:
             write("null", 4);
             break;
 
-        case IntValue:
+        case ValueType::Int:
             writeString(write, valueToString(value.asInt()));
             break;
 
-        case UintValue:
+        case ValueType::UInt:
             writeString(write, valueToString(value.asUInt()));
             break;
 
-        case RealValue:
+        case ValueType::Real:
             writeString(write, valueToString(value.asDouble()));
             break;
 
-        case StringValue:
+        case ValueType::String:
             writeString(write, valueToQuotedString(value.asCString()));
             break;
 
-        case BooleanValue:
+        case ValueType::Boolean:
             writeString(write, valueToString(value.asBool()));
             break;
 
-        case ArrayValue: {
+        case ValueType::Array: {
             write("[", 1);
             int const size = value.size();
             for (int index = 0; index < size; ++index)
@@ -241,7 +241,7 @@ writeValue(Write const& write, Value const& value)
             break;
         }
 
-        case ObjectValue: {
+        case ValueType::Object: {
             Value::Members const members = value.getMemberNames();
             write("{", 1);
             for (auto it = members.begin(); it != members.end(); ++it)

include/xrpl/ledger/AmendmentTable.h

@@ -67,7 +67,7 @@ public:
     [[nodiscard]] virtual json::Value
     getJson(bool isAdmin) const = 0;
 
-    /** Returns a json::objectValue. */
+    /** Returns a json::ValueType::Object. */
     [[nodiscard]] virtual json::Value
     getJson(uint256 const& amendment, bool isAdmin) const = 0;
 

include/xrpl/ledger/helpers/CredentialHelpers.h

@@ -20,14 +20,10 @@ namespace credentials {
 
 // Check if credential sfExpiration field has passed ledger's parentCloseTime
 bool
-checkExpired(std::shared_ptr<SLE const> const& sleCredential, NetClock::time_point const& closed);
-
-// Return true if any expired credential was found in arr (and deleted)
-bool
-removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j);
+checkExpired(SLE const& sleCredential, NetClock::time_point const& closed);
 
 // Actually remove a credentials object from the ledger
-TER
+[[nodiscard]] TER
 deleteSLE(ApplyView& view, std::shared_ptr<SLE> const& sleCredential, beast::Journal j);
 
 // Amendment and parameters checks for sfCredentialIDs field

include/xrpl/ledger/helpers/LendingHelpers.h

@@ -184,6 +184,7 @@ checkLoanGuards(
 
 LoanState
 computeTheoreticalLoanState(
+    Rules const& rules,
     Number const& periodicPayment,
     Number const& periodicRate,
     std::uint32_t const paymentRemaining,
@@ -353,6 +354,7 @@ struct LoanStateDeltas
 
 Expected<std::pair<LoanPaymentParts, LoanProperties>, TER>
 tryOverpayment(
+    Rules const& rules,
     Asset const& asset,
     std::int32_t loanScale,
     ExtendedPaymentComponents const& overpaymentComponents,
@@ -363,11 +365,17 @@ tryOverpayment(
     TenthBips16 const managementFeeRate,
     beast::Journal j);
 
-Number
-computeRaisedRate(Number const& periodicRate, std::uint32_t paymentsRemaining);
+[[nodiscard]] Number
+computePowerMinusOne(Number const& periodicRate, std::uint32_t paymentsRemaining);
 
-Number
-computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining);
+[[nodiscard]] Number
+computePowerMinusOneHybrid(Number const& periodicRate, std::uint32_t paymentsRemaining);
+
+[[nodiscard]] Number
+computePaymentFactor(
+    Rules const& rules,
+    Number const& periodicRate,
+    std::uint32_t paymentsRemaining);
 
 std::pair<Number, Number>
 computeInterestAndFeeParts(
@@ -378,12 +386,14 @@ computeInterestAndFeeParts(
 
 Number
 loanPeriodicPayment(
+    Rules const& rules,
     Number const& principalOutstanding,
     Number const& periodicRate,
     std::uint32_t paymentsRemaining);
 
 Number
 loanPrincipalFromPeriodicPayment(
+    Rules const& rules,
     Number const& periodicPayment,
     Number const& periodicRate,
     std::uint32_t paymentsRemaining);
@@ -415,6 +425,7 @@ computeOverpaymentComponents(
 
 PaymentComponents
 computePaymentComponents(
+    Rules const& rules,
     Asset const& asset,
     std::int32_t scale,
     Number const& totalValueOutstanding,
@@ -438,6 +449,7 @@ operator+(LoanState const& lhs, detail::LoanStateDeltas const& rhs);
 
 LoanProperties
 computeLoanProperties(
+    Rules const& rules,
     Asset const& asset,
     Number const& principalOutstanding,
     TenthBips32 interestRate,
@@ -448,6 +460,7 @@ computeLoanProperties(
 
 LoanProperties
 computeLoanProperties(
+    Rules const& rules,
     Asset const& asset,
     Number const& principalOutstanding,
     Number const& periodicRate,

include/xrpl/nodestore/Types.h

@@ -6,20 +6,16 @@
 
 namespace xrpl::NodeStore {
 
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum {
-    // This is only used to pre-allocate the array for
-    // batch objects and does not affect the amount written.
-    //
-    BatchWritePreallocationSize = 256,
+// This is only used to pre-allocate the array for
+// batch objects and does not affect the amount written.
+//
+static constexpr auto kBATCH_WRITE_PREALLOCATION_SIZE = 256;
 
-    // This sets a limit on the maximum number of writes
-    // in a batch. Actual usage can be twice this since
-    // we have a new batch growing as we write the old.
-    //
-    BatchWriteLimitSize = 65536
-};
+// This sets a limit on the maximum number of writes
+// in a batch. Actual usage can be twice this since
+// we have a new batch growing as we write the old.
+//
+static constexpr auto kBATCH_WRITE_LIMIT_SIZE = 65536;
 
 /** Return codes from Backend operations. */
 enum class Status {

include/xrpl/protocol/AccountID.h

@@ -25,7 +25,7 @@ public:
 }  // namespace detail
 
 /** A 160-bit unsigned that uniquely identifies an account. */
-using AccountID = BaseUint<160, detail::AccountIDTag>;
+using AccountID = BaseUInt<160, detail::AccountIDTag>;
 
 /** Convert AccountID to base58 checked string */
 std::string

include/xrpl/protocol/ApiVersion.h

@@ -61,7 +61,7 @@ setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled)
 {
     XRPL_ASSERT(apiVersion != kAPI_INVALID_VERSION, "xrpl::RPC::setVersion : input is valid");
 
-    auto& retObj = parent[jss::version] = json::ObjectValue;
+    auto& retObj = parent[jss::version] = json::ValueType::Object;
 
     if (apiVersion == kAPI_VERSION_IF_UNSPECIFIED)
     {

include/xrpl/protocol/PublicKey.h

@@ -267,10 +267,10 @@ getOrThrow(json::Value const& v, xrpl::SField const& field)
 {
     using namespace xrpl;
     std::string const b58 = getOrThrow<std::string>(v, field);
-    if (auto pubKeyBlob = strUnHex(b58); pubKeyBlob && publicKeyType(makeSlice(*pubKeyBlob)))
+    if (auto pubKeyBlob = strUnHex(b58);
+        pubKeyBlob.has_value() && publicKeyType(makeSlice(*pubKeyBlob)))
     {
-        return PublicKey{makeSlice(
-            *pubKeyBlob)};  // NOLINT(bugprone-unchecked-optional-access) checked in condition above
+        return PublicKey{makeSlice(*pubKeyBlob)};
     }
     for (auto const tokenType : {TokenType::NodePublic, TokenType::AccountPublic})
     {

include/xrpl/protocol/SField.h

@@ -129,23 +129,20 @@ fieldCode(int id, int index)
 class SField
 {
 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        SMdNever = 0x00,
-        SMdChangeOrig = 0x01,     // original value when it changes
-        SMdChangeNew = 0x02,      // new value when it changes
-        SMdDeleteFinal = 0x04,    // final value when it is deleted
-        SMdCreate = 0x08,         // value when it's created
-        SMdAlways = 0x10,         // value when node containing it is affected at all
-        SMdBaseTen = 0x20,        // value is treated as base 10, overriding behavior
-        SMdPseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
-                                  // _only_, then it is a pseudo-account
-        SMdNeedsAsset = 0x80,     // This field needs to be associated with an
-                                  // asset before it is serialized as a ledger
-                                  // object. Intended for STNumber.
-        SMdDefault = SMdChangeOrig | SMdChangeNew | SMdDeleteFinal | SMdCreate
-    };
+    static constexpr auto kSMD_NEVER = 0x00;
+    static constexpr auto kSMD_CHANGE_ORIG = 0x01;   // original value when it changes
+    static constexpr auto kSMD_CHANGE_NEW = 0x02;    // new value when it changes
+    static constexpr auto kSMD_DELETE_FINAL = 0x04;  // final value when it is deleted
+    static constexpr auto kSMD_CREATE = 0x08;        // value when it's created
+    static constexpr auto kSMD_ALWAYS = 0x10;    // value when node containing it is affected at all
+    static constexpr auto kSMD_BASE_TEN = 0x20;  // value is treated as base 10, overriding behavior
+    static constexpr auto kSMD_PSEUDO_ACCOUNT = 0x40;  // if this field is set in an ACCOUNT_ROOT
+                                                       // _only_, then it is a pseudo-account
+    static constexpr auto kSMD_NEEDS_ASSET = 0x80;     // This field needs to be associated with an
+                                                       // asset before it is serialized as a ledger
+                                                       // object. Intended for STNumber.
+    static constexpr auto kSMD_DEFAULT =
+        kSMD_CHANGE_ORIG | kSMD_CHANGE_NEW | kSMD_DELETE_FINAL | kSMD_CREATE;
 
     enum class IsSigning : unsigned char { No, Yes };
     static IsSigning const kNOT_SIGNING = IsSigning::No;
@@ -175,7 +172,7 @@ public:
         SerializedTypeID tid,
         int fv,
         char const* fn,
-        int meta = SMdDefault,
+        int meta = kSMD_DEFAULT,
         IsSigning signing = IsSigning::Yes);
     explicit SField(PrivateAccessTagT, int fc, char const* fn);
 

include/xrpl/protocol/STAmount.h

@@ -241,7 +241,7 @@ public:
     [[nodiscard]] std::string
     getText() const override;
 
-    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override;
+    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override;
 
     void
     add(Serializer& s) const override;

include/xrpl/protocol/STBase.h

@@ -18,23 +18,23 @@ struct JsonOptions
     using underlying_t = unsigned int;
     underlying_t value;
 
-    // Bitwise flags with operator~
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum Values : underlying_t {
-        // clang-format off
-        KNone                       = 0b0000'0000,
-        KIncludeDate               = 0b0000'0001,
-        KDisableApiPriorV2       = 0b0000'0010,
+    enum class Values : underlying_t {
+        None = 0b0000'0000,
+        IncludeDate = 0b0000'0001,
+        DisableApiPriorV2 = 0b0000'0010,
 
-        // IMPORTANT `kALL` must be union of all of the above; see also operator~
-        KAll                        = 0b0000'0011
-        // clang-format on
+        // IMPORTANT `All` must be union of all of the above; see also operator~
+        All = IncludeDate | DisableApiPriorV2  // 0b0000'0011
     };
 
     constexpr JsonOptions(underlying_t v) noexcept : value(v)
     {
     }
 
+    constexpr JsonOptions(Values v) noexcept : value(static_cast<JsonOptions::underlying_t>(v))
+    {
+    }
+
     [[nodiscard]] constexpr explicit
     operator underlying_t() const noexcept
     {
@@ -69,18 +69,18 @@ struct JsonOptions
     [[nodiscard]] constexpr JsonOptions friend
     operator~(JsonOptions v) noexcept
     {
-        return {~v.value & static_cast<underlying_t>(KAll)};
+        return {~v.value & static_cast<underlying_t>(Values::All)};
     }
 };
 
 template <typename T>
     requires requires(T const& t) {
-        { t.getJson(JsonOptions::KNone) } -> std::convertible_to<json::Value>;
+        { t.getJson(JsonOptions::Values::None) } -> std::convertible_to<json::Value>;
     }
 json::Value
 toJson(T const& t)
 {
-    return t.getJson(JsonOptions::KNone);
+    return t.getJson(JsonOptions::Values::None);
 }
 
 namespace detail {
@@ -148,7 +148,7 @@ public:
     [[nodiscard]] virtual std::string
     getText() const;
 
-    [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::KNone) const;
+    [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::Values::None) const;
 
     virtual void
     add(Serializer& s) const;

include/xrpl/protocol/STBitString.h

@@ -16,7 +16,7 @@ class STBitString final : public STBase, public CountedObject<STBitString<Bits>>
     static_assert(Bits > 0, "Number of bits must be positive");
 
 public:
-    using value_type = BaseUint<Bits>;
+    using value_type = BaseUInt<Bits>;
 
 private:
     value_type value_{};
@@ -46,7 +46,7 @@ public:
 
     template <typename Tag>
     void
-    setValue(BaseUint<Bits, Tag> const& v);
+    setValue(BaseUInt<Bits, Tag> const& v);
 
     [[nodiscard]] value_type const&
     value() const;
@@ -157,7 +157,7 @@ STBitString<Bits>::add(Serializer& s) const
 template <int Bits>
 template <typename Tag>
 void
-STBitString<Bits>::setValue(BaseUint<Bits, Tag> const& v)
+STBitString<Bits>::setValue(BaseUInt<Bits, Tag> const& v)
 {
     value_ = v;
 }

include/xrpl/protocol/STLedgerEntry.h

@@ -38,7 +38,7 @@ public:
     getText() const override;
 
     [[nodiscard]] json::Value
-    getJson(JsonOptions options = JsonOptions::KNone) const override;
+    getJson(JsonOptions options = JsonOptions::Values::None) const override;
 
     /** Returns the 'key' (or 'index') of this item.
         The key identifies this entry's position in

include/xrpl/protocol/STObject.h

@@ -132,7 +132,7 @@ public:
     getText() const override;
 
     // TODO(tom): options should be an enum.
-    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override;
+    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override;
 
     void
     addWithoutSigningFields(Serializer& s) const;
@@ -381,7 +381,7 @@ public:
 
     template <class Tag>
     void
-    setFieldH160(SField const& field, BaseUint<160, Tag> const& v);
+    setFieldH160(SField const& field, BaseUInt<160, Tag> const& v);
 
     STObject&
     peekFieldObject(SField const& field);
@@ -1143,7 +1143,7 @@ STObject::at(OptionaledField<T> const& of) -> OptionalProxy<T>
 
 template <class Tag>
 void
-STObject::setFieldH160(SField const& field, BaseUint<160, Tag> const& v)
+STObject::setFieldH160(SField const& field, BaseUInt<160, Tag> const& v)
 {
     STBase* rf = getPField(field, true);
 

include/xrpl/protocol/STParsedJSON.h

@@ -6,6 +6,13 @@
 
 namespace xrpl {
 
+/** Maximum JSON object nesting depth permitted during parsing. */
+inline constexpr std::size_t kMAX_PARSED_JSON_DEPTH = 64;
+
+/** Maximum number of elements permitted in any JSON array field during parsing.
+    Requests exceeding this limit are rejected with an invalidParams error. */
+inline constexpr std::size_t kMAX_PARSED_JSON_ARRAY_SIZE = 512;
+
 /** Holds the serialized result of parsing an input JSON object.
     This does validation and checking on the provided JSON.
 */

include/xrpl/protocol/STValidation.h

@@ -161,7 +161,7 @@ STValidation::STValidation(SerialIter& sit, LookupNodeID&& lookupNodeID, bool ch
     if (checkSignature && !isValid())
     {
         JLOG(debugLog().error()) << "Invalid signature in validation: "
-                                 << getJson(JsonOptions::KNone);
+                                 << getJson(JsonOptions::Values::None);
         Throw<std::runtime_error>("Invalid signature in validation");
     }
 

include/xrpl/protocol/Serializer.h

@@ -102,7 +102,7 @@ public:
 
     template <std::size_t Bits, class Tag>
     int
-    addBitString(BaseUint<Bits, Tag> const& v)
+    addBitString(BaseUInt<Bits, Tag> const& v)
     {
         return addRaw(v.data(), v.size());
     }
@@ -151,7 +151,7 @@ public:
 
     template <std::size_t Bits, typename Tag = void>
     bool
-    getBitString(BaseUint<Bits, Tag>& data, int offset) const
+    getBitString(BaseUInt<Bits, Tag>& data, int offset) const
     {
         auto success = (offset + (Bits / 8)) <= data_.size();
         if (success)
@@ -369,7 +369,7 @@ public:
     geti64();
 
     template <std::size_t Bits, class Tag = void>
-    BaseUint<Bits, Tag>
+    BaseUInt<Bits, Tag>
     getBitString();
 
     uint128
@@ -428,7 +428,7 @@ public:
 };
 
 template <std::size_t Bits, class Tag>
-BaseUint<Bits, Tag>
+BaseUInt<Bits, Tag>
 SerialIter::getBitString()
 {
     auto const n = Bits / 8;
@@ -442,7 +442,7 @@ SerialIter::getBitString()
     used_ += n;
     remain_ -= n;
 
-    return BaseUint<Bits, Tag>::fromVoid(x);
+    return BaseUInt<Bits, Tag>::fromVoid(x);
 }
 
 }  // namespace xrpl

include/xrpl/protocol/UintTypes.h

@@ -30,21 +30,21 @@ public:
 
 /** Directory is an index into the directory of offer books.
     The last 64 bits of this are the quality. */
-using Directory = BaseUint<256, detail::DirectoryTag>;
+using Directory = BaseUInt<256, detail::DirectoryTag>;
 
 /** Currency is a hash representing a specific currency. */
-using Currency = BaseUint<160, detail::CurrencyTag>;
+using Currency = BaseUInt<160, detail::CurrencyTag>;
 
 /** NodeID is a 160-bit hash representing one node. */
-using NodeID = BaseUint<160, detail::NodeIDTag>;
+using NodeID = BaseUInt<160, detail::NodeIDTag>;
 
 /** MPTID is a 192-bit value representing MPT Issuance ID,
  * which is a concatenation of a 32-bit sequence (big endian)
  * and a 160-bit account */
-using MPTID = BaseUint<192>;
+using MPTID = BaseUInt<192>;
 
 /** Domain is a 256-bit hash representing a specific domain. */
-using Domain = BaseUint<256>;
+using Domain = BaseUInt<256>;
 
 /** XRP currency. */
 Currency const&

include/xrpl/protocol/detail/features.macro

@@ -15,11 +15,10 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
-XRPL_FIX    (Cleanup3_2_0,                Supported::No, VoteBehavior::DefaultNo)
-XRPL_FEATURE(MPTokensV2,                  Supported::No, VoteBehavior::DefaultNo)
-XRPL_FIX    (Security3_1_3,               Supported::No, VoteBehavior::DefaultNo)
-XRPL_FIX    (PermissionedDomainInvariant, Supported::Yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (BatchInnerSigs,              Supported::No, VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_2_0,                Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(MPTokensV2,                  Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_1_3,                Supported::Yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (BatchInnerSigs,              Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocol,             Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegationV1_1,    Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DirectoryLimit,              Supported::Yes, VoteBehavior::DefaultNo)
@@ -34,7 +33,7 @@ XRPL_FIX    (EnforceNFTokenTrustlineV2,   Supported::Yes, VoteBehavior::DefaultN
 XRPL_FIX    (AMMv1_3,                     Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionedDEX,             Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Batch,                       Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(SingleAssetVault,            Supported::Yes,  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)
@@ -46,9 +45,6 @@ XRPL_FEATURE(Credentials,                Supported::Yes, VoteBehavior::DefaultNo
 XRPL_FEATURE(AMMClawback,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (AMMv1_2,                    Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV1,                 Supported::Yes, VoteBehavior::DefaultNo)
-// InvariantsV1_1 will be changes to Supported::yes when all the
-// invariants expected to be included under it are complete.
-XRPL_FEATURE(InvariantsV1_1,             Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (NFTokenPageLinks,           Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (InnerObjTemplate2,          Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (EnforceNFTokenTrustline,    Supported::Yes, VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/sfields.macro

@@ -27,7 +27,7 @@ TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
 TYPED_SFIELD(sfWithdrawalPolicy,         UINT8,     20)
 
 // 16-bit integers (common)
-TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::SMdNever)
+TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::kSMD_NEVER)
 TYPED_SFIELD(sfTransactionType,          UINT16,     2)
 TYPED_SFIELD(sfSignerWeight,             UINT16,     3)
 TYPED_SFIELD(sfTransferFee,              UINT16,     4)
@@ -48,7 +48,7 @@ TYPED_SFIELD(sfNetworkID,                UINT32,     1)
 TYPED_SFIELD(sfFlags,                    UINT32,     2)
 TYPED_SFIELD(sfSourceTag,                UINT32,     3)
 TYPED_SFIELD(sfSequence,                 UINT32,     4)
-TYPED_SFIELD(sfPreviousTxnLgrSeq,        UINT32,     5, SField::SMdDeleteFinal)
+TYPED_SFIELD(sfPreviousTxnLgrSeq,        UINT32,     5, SField::kSMD_DELETE_FINAL)
 TYPED_SFIELD(sfLedgerSequence,           UINT32,     6)
 TYPED_SFIELD(sfCloseTime,                UINT32,     7)
 TYPED_SFIELD(sfParentCloseTime,          UINT32,     8)
@@ -138,12 +138,12 @@ TYPED_SFIELD(sfXChainClaimID,            UINT64,    20)
 TYPED_SFIELD(sfXChainAccountCreateCount, UINT64,    21)
 TYPED_SFIELD(sfXChainAccountClaimCount,  UINT64,    22)
 TYPED_SFIELD(sfAssetPrice,               UINT64,    23)
-TYPED_SFIELD(sfMaximumAmount,            UINT64,    24, SField::SMdBaseTen|SField::SMdDefault)
-TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::SMdBaseTen|SField::SMdDefault)
-TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::SMdBaseTen|SField::SMdDefault)
+TYPED_SFIELD(sfMaximumAmount,            UINT64,    24, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfIssuerNode,               UINT64,    27)
 TYPED_SFIELD(sfSubjectNode,              UINT64,    28)
-TYPED_SFIELD(sfLockedAmount,             UINT64,    29, SField::SMdBaseTen|SField::SMdDefault)
+TYPED_SFIELD(sfLockedAmount,             UINT64,    29, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfVaultNode,                UINT64,    30)
 TYPED_SFIELD(sfLoanBrokerNode,           UINT64,    31)
 
@@ -167,17 +167,17 @@ TYPED_SFIELD(sfLedgerHash,               UINT256,    1)
 TYPED_SFIELD(sfParentHash,               UINT256,    2)
 TYPED_SFIELD(sfTransactionHash,          UINT256,    3)
 TYPED_SFIELD(sfAccountHash,              UINT256,    4)
-TYPED_SFIELD(sfPreviousTxnID,            UINT256,    5, SField::SMdDeleteFinal)
+TYPED_SFIELD(sfPreviousTxnID,            UINT256,    5, SField::kSMD_DELETE_FINAL)
 TYPED_SFIELD(sfLedgerIndex,              UINT256,    6)
 TYPED_SFIELD(sfWalletLocator,            UINT256,    7)
-TYPED_SFIELD(sfRootIndex,                UINT256,    8, SField::SMdAlways)
+TYPED_SFIELD(sfRootIndex,                UINT256,    8, SField::kSMD_ALWAYS)
 TYPED_SFIELD(sfAccountTxnID,             UINT256,    9)
 TYPED_SFIELD(sfNFTokenID,                UINT256,   10)
 TYPED_SFIELD(sfEmitParentTxnID,          UINT256,   11)
 TYPED_SFIELD(sfEmitNonce,                UINT256,   12)
 TYPED_SFIELD(sfEmitHookHash,             UINT256,   13)
 TYPED_SFIELD(sfAMMID,                    UINT256,   14,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)
 
 // 256-bit (uncommon)
 TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
@@ -200,30 +200,30 @@ TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
 TYPED_SFIELD(sfVaultID,                  UINT256,   35,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfParentBatchID,            UINT256,   36)
 TYPED_SFIELD(sfLoanBrokerID,             UINT256,   37,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfLoanID,                   UINT256,   38)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::kSMD_NEEDS_ASSET | SField::kSMD_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, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
-TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
-TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 
 // int32
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
@@ -269,9 +269,9 @@ TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
 TYPED_SFIELD(sfMessageKey,               VL,         2)
 TYPED_SFIELD(sfSigningPubKey,            VL,         3)
-TYPED_SFIELD(sfTxnSignature,             VL,         4, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfTxnSignature,             VL,         4, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfURI,                      VL,         5)
-TYPED_SFIELD(sfSignature,                VL,         6, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfSignature,                VL,         6, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfDomain,                   VL,         7)
 TYPED_SFIELD(sfFundCode,                 VL,         8)
 TYPED_SFIELD(sfRemoveCode,               VL,         9)
@@ -284,7 +284,7 @@ TYPED_SFIELD(sfMemoFormat,               VL,        14)
 // variable length (uncommon)
 TYPED_SFIELD(sfFulfillment,              VL,        16)
 TYPED_SFIELD(sfCondition,                VL,        17)
-TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfUNLModifyValidator,       VL,        19)
 TYPED_SFIELD(sfValidatorToDisable,       VL,        20)
 TYPED_SFIELD(sfValidatorToReEnable,      VL,        21)
@@ -326,7 +326,7 @@ TYPED_SFIELD(sfBorrower,                 ACCOUNT,   25)
 TYPED_SFIELD(sfCounterparty,             ACCOUNT,   26)
 
 // vector of 256-bit
-TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::SMdNever)
+TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::kSMD_NEVER)
 TYPED_SFIELD(sfHashes,                   VECTOR256,  2)
 TYPED_SFIELD(sfAmendments,               VECTOR256,  3)
 TYPED_SFIELD(sfNFTokenOffers,            VECTOR256,  4)
@@ -387,13 +387,13 @@ UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
 UNTYPED_SFIELD(sfRawTransaction,         OBJECT,    34)
 UNTYPED_SFIELD(sfBatchSigner,            OBJECT,    35)
 UNTYPED_SFIELD(sfBook,                   OBJECT,    36)
-UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    37, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    37, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array
 // sfSigningAccounts has never been used.
 //UNTYPED_SFIELD(sfSigningAccounts,        ARRAY,      2)
-UNTYPED_SFIELD(sfSigners,                ARRAY,      3, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfSigners,                ARRAY,      3, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 UNTYPED_SFIELD(sfSignerEntries,          ARRAY,      4)
 UNTYPED_SFIELD(sfTemplate,               ARRAY,      5)
 UNTYPED_SFIELD(sfNecessary,              ARRAY,      6)
@@ -421,4 +421,4 @@ UNTYPED_SFIELD(sfUnauthorizeCredentials, ARRAY,     27)
 UNTYPED_SFIELD(sfAcceptedCredentials,    ARRAY,     28)
 UNTYPED_SFIELD(sfPermissions,            ARRAY,     29)
 UNTYPED_SFIELD(sfRawTransactions,        ARRAY,     30)
-UNTYPED_SFIELD(sfBatchSigners,           ARRAY,     31, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfBatchSigners,           ARRAY,     31, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)

include/xrpl/resource/detail/Entry.h

@@ -67,7 +67,7 @@ struct Entry : public beast::List<Entry>::Node
     int refcount;
 
     // Exponentially decaying balance of resource consumption
-    DecayingSample<DecayWindowSeconds, clock_type> local_balance;
+    DecayingSample<kDECAY_WINDOW_SECONDS, clock_type> local_balance;
 
     // Normalized balance contribution from imports
     int remote_balance;

include/xrpl/resource/detail/Logic.h

@@ -180,16 +180,16 @@ public:
     json::Value
     getJson()
     {
-        return getJson(WarningThreshold);
+        return getJson(kWARNING_THRESHOLD);
     }
 
-    /** Returns a json::objectValue. */
+    /** Returns a json::ValueType::Object. */
     json::Value
     getJson(int threshold)
     {
         clock_type::time_point const now(clock_.now());
 
-        json::Value ret(json::ObjectValue);
+        json::Value ret(json::ValueType::Object);
         std::scoped_lock const _(lock_);
 
         for (auto& inboundEntry : inbound_)
@@ -197,7 +197,7 @@ public:
             int const localBalance = inboundEntry.local_balance.value(now);
             if ((localBalance + inboundEntry.remote_balance) >= threshold)
             {
-                json::Value& entry = (ret[inboundEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[inboundEntry.toString()] = json::ValueType::Object);
                 entry[jss::local] = localBalance;
                 entry[jss::remote] = inboundEntry.remote_balance;
                 entry[jss::type] = "inbound";
@@ -208,7 +208,7 @@ public:
             int const localBalance = outboundEntry.local_balance.value(now);
             if ((localBalance + outboundEntry.remote_balance) >= threshold)
             {
-                json::Value& entry = (ret[outboundEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[outboundEntry.toString()] = json::ValueType::Object);
                 entry[jss::local] = localBalance;
                 entry[jss::remote] = outboundEntry.remote_balance;
                 entry[jss::type] = "outbound";
@@ -219,7 +219,7 @@ public:
             int const localBalance = adminEntry.local_balance.value(now);
             if ((localBalance + adminEntry.remote_balance) >= threshold)
             {
-                json::Value& entry = (ret[adminEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[adminEntry.toString()] = json::ValueType::Object);
                 entry[jss::local] = localBalance;
                 entry[jss::remote] = adminEntry.remote_balance;
                 entry[jss::type] = "admin";
@@ -243,7 +243,7 @@ public:
         {
             Gossip::Item item;
             item.balance = inboundEntry.local_balance.value(now);
-            if (item.balance >= MinimumGossipBalance)
+            if (item.balance >= kMINIMUM_GOSSIP_BALANCE)
             {
                 item.address = inboundEntry.key->address;
                 gossip.items.push_back(item);
@@ -363,10 +363,10 @@ public:
     static Disposition
     disposition(int balance)
     {
-        if (balance >= DropThreshold)
+        if (balance >= kDROP_THRESHOLD)
             return Disposition::Drop;
 
-        if (balance >= WarningThreshold)
+        if (balance >= kWARNING_THRESHOLD)
             return Disposition::Warn;
 
         return Disposition::Ok;
@@ -461,7 +461,7 @@ public:
         std::scoped_lock const _(lock_);
         bool notify(false);
         auto const elapsed = clock_.now();
-        if (entry.balance(clock_.now()) >= WarningThreshold && elapsed != entry.lastWarningTime)
+        if (entry.balance(clock_.now()) >= kWARNING_THRESHOLD && elapsed != entry.lastWarningTime)
         {
             charge(entry, kFEE_WARNING);
             notify = true;
@@ -485,10 +485,10 @@ public:
         bool drop(false);
         clock_type::time_point const now(clock_.now());
         int const balance(entry.balance(now));
-        if (balance >= DropThreshold)
+        if (balance >= kDROP_THRESHOLD)
         {
             JLOG(journal_.warn()) << "Consumer entry " << entry << " dropped with balance "
-                                  << balance << " at or above drop threshold " << DropThreshold;
+                                  << balance << " at or above drop threshold " << kDROP_THRESHOLD;
 
             // Adding feeDrop at this point keeps the dropped connection
             // from re-connecting for at least a little while after it is

include/xrpl/resource/detail/Tuning.h

@@ -5,30 +5,23 @@
 namespace xrpl::Resource {
 
 /** Tunable constants. */
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum {
-    // Balance at which a warning is issued
-    WarningThreshold = 5000
 
-    // Balance at which the consumer is disconnected
-    ,
-    DropThreshold = 25000
+// balance at which a warning is issued
+static constexpr auto kWARNING_THRESHOLD = 5000;
 
-    // The number of seconds in the exponential decay window
-    // (This should be a power of two)
-    ,
-    DecayWindowSeconds = 32
+// balance at which the consumer is disconnected
+static constexpr auto kDROP_THRESHOLD = 25000;
 
-    // The minimum balance required in order to include a load source in gossip
-    ,
-    MinimumGossipBalance = 1000
-};
+// seconds in exponential decay window (power of two)
+static constexpr auto kDECAY_WINDOW_SECONDS = 32;
+
+// minimum balance to include a load source in gossip
+static constexpr auto kMINIMUM_GOSSIP_BALANCE = 1000;
 
 // The number of seconds until an inactive table item is removed
-std::chrono::seconds constexpr kSECONDS_UNTIL_EXPIRATION{300};
+static constexpr std::chrono::seconds kSECONDS_UNTIL_EXPIRATION{300};
 
 // Number of seconds until imported gossip expires
-std::chrono::seconds constexpr kGOSSIP_EXPIRATION_SECONDS{30};
+static constexpr std::chrono::seconds kGOSSIP_EXPIRATION_SECONDS{30};
 
 }  // namespace xrpl::Resource

include/xrpl/server/detail/BaseHTTPPeer.h

@@ -30,7 +30,7 @@ namespace xrpl {
 
 /** Represents an active connection. */
 template <class Handler, class Impl>
-class BaseHTTPPeer : public IoList::Work, public Session
+class BaseHTTPPeer : public IOList::Work, public Session
 {
 protected:
     using clock_type = std::chrono::system_clock;
@@ -38,16 +38,9 @@ protected:
     using endpoint_type = boost::asio::ip::tcp::endpoint;
     using yield_context = boost::asio::yield_context;
 
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        // Size of our read/write buffer
-        BufferSize = 4 * 1024,
-
-        // Max seconds without completing a message
-        TimeoutSeconds = 30,
-        TimeoutSecondsLocal = 3  // used for localhost clients
-    };
+    static constexpr auto kBUFFER_SIZE = 4 * 1024;     // size of read/write buffer
+    static constexpr auto kTIMEOUT_SECONDS = 30;       // max seconds without completing a message
+    static constexpr auto kTIMEOUT_SECONDS_LOCAL = 3;  // used for localhost clients
 
     struct Buffer
     {
@@ -252,7 +245,8 @@ BaseHTTPPeer<Handler, Impl>::startTimer()
     boost::beast::get_lowest_layer(impl().stream_)
         .expires_after(
             std::chrono::seconds(
-                remote_address_.address().is_loopback() ? TimeoutSecondsLocal : TimeoutSeconds));
+                remote_address_.address().is_loopback() ? kTIMEOUT_SECONDS_LOCAL
+                                                        : kTIMEOUT_SECONDS));
 }
 
 // Convenience for discarding the error code
@@ -364,7 +358,7 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
 
     for (;;)
     {
-        if (!writer->prepare(BufferSize, resume))
+        if (!writer->prepare(kBUFFER_SIZE, resume))
             return;
         error_code ec;
         auto const bytesTransferred = boost::asio::async_write(

include/xrpl/server/detail/BasePeer.h

@@ -17,7 +17,7 @@ namespace xrpl {
 
 // Common part of all peers
 template <class Handler, class Impl>
-class BasePeer : public IoList::Work
+class BasePeer : public IOList::Work
 {
 protected:
     using clock_type = std::chrono::system_clock;

include/xrpl/server/detail/Door.h

@@ -39,7 +39,7 @@ namespace xrpl {
 
 /** A listening socket. */
 template <class Handler>
-class Door : public IoList::Work, public std::enable_shared_from_this<Door<Handler>>
+class Door : public IOList::Work, public std::enable_shared_from_this<Door<Handler>>
 {
 private:
     using clock_type = std::chrono::steady_clock;
@@ -53,7 +53,7 @@ private:
     using stream_type = boost::beast::tcp_stream;
 
     // Detects SSL on a socket
-    class Detector : public IoList::Work, public std::enable_shared_from_this<Detector>
+    class Detector : public IOList::Work, public std::enable_shared_from_this<Detector>
     {
     private:
         Port const& port_;

include/xrpl/server/detail/ServerImpl.h

@@ -62,9 +62,7 @@ class ServerImpl : public Server
 private:
     using clock_type = std::chrono::system_clock;
 
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { HistorySize = 100 };
+    static constexpr auto kHISTORY_SIZE = 100;
 
     Handler& handler_;
     beast::Journal const j_;
@@ -78,7 +76,7 @@ private:
     int high_ = 0;
     std::array<std::size_t, 64> hist_{};
 
-    IoList ios_;
+    IOList ios_;
 
 public:
     ServerImpl(Handler& handler, boost::asio::io_context& ioContext, beast::Journal journal);
@@ -97,7 +95,7 @@ public:
     void
     close() override;
 
-    IoList&
+    IOList&
     ios()
     {
         return ios_;

include/xrpl/server/detail/io_list.h

@@ -12,7 +12,7 @@
 namespace xrpl {
 
 /** Manages a set of objects performing asynchronous I/O. */
-class IoList final
+class IOList final
 {
 public:
     class Work
@@ -21,8 +21,8 @@ public:
         void
         destroy();
 
-        friend class IoList;
-        IoList* ios_ = nullptr;
+        friend class IOList;
+        IOList* ios_ = nullptr;
 
     public:
         virtual ~Work()
@@ -30,13 +30,13 @@ public:
             destroy();
         }
 
-        /** Return the IoList associated with the work.
+        /** Return the IOList associated with the work.
 
             Requirements:
-                The call to IoList::emplace to
+                The call to IOList::emplace to
                 create the work has already returned.
         */
-        IoList&
+        IOList&
         ios()
         {
             return *ios_;
@@ -59,17 +59,17 @@ private:
     std::function<void(void)> f_;
 
 public:
-    IoList() = default;
+    IOList() = default;
 
     /** Destroy the list.
 
         Effects:
-            Closes the IoList if it was not previously
+            Closes the IOList if it was not previously
                 closed. No finisher is invoked in this case.
 
             Blocks until all work is destroyed.
     */
-    ~IoList()
+    ~IOList()
     {
         destroy();
     }
@@ -159,7 +159,7 @@ public:
 
 template <class>
 void
-IoList::Work::destroy()
+IOList::Work::destroy()
 {
     if (!ios_)
         return;
@@ -179,7 +179,7 @@ IoList::Work::destroy()
 
 template <class>
 void
-IoList::destroy()
+IOList::destroy()
 {
     close();
     join();
@@ -187,9 +187,9 @@ IoList::destroy()
 
 template <class T, class... Args>
 std::shared_ptr<T>
-IoList::emplace(Args&&... args)
+IOList::emplace(Args&&... args)
 {
-    static_assert(std::is_base_of_v<Work, T>, "T must derive from IoList::Work");
+    static_assert(std::is_base_of_v<Work, T>, "T must derive from IOList::Work");
     if (closed_)
         return nullptr;
     auto sp = std::make_shared<T>(std::forward<Args>(args)...);
@@ -211,7 +211,7 @@ IoList::emplace(Args&&... args)
 
 template <class Finisher>
 void
-IoList::close(Finisher&& f)
+IOList::close(Finisher&& f)
 {
     std::unique_lock<std::mutex> lock(m_);
     if (closed_)
@@ -237,7 +237,7 @@ IoList::close(Finisher&& f)
 
 template <class>
 void
-IoList::join()
+IOList::join()
 {
     std::unique_lock<std::mutex> lock(m_);
     cv_.wait(lock, [&] { return closed_ && n_ == 0; });

include/xrpl/shamap/FullBelowCache.h

@@ -22,9 +22,7 @@ private:
     using CacheType = KeyCache;
 
 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { DefaultCacheTargetSize = 0 };
+    static constexpr auto kDEFAULT_CACHE_TARGET_SIZE = 0;
 
     using key_type = uint256;
     using clock_type = typename CacheType::clock_type;
@@ -41,7 +39,7 @@ public:
         clock_type& clock,
         beast::Journal j,
         beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make(),
-        std::size_t targetSize = DefaultCacheTargetSize,
+        std::size_t targetSize = kDEFAULT_CACHE_TARGET_SIZE,
         std::chrono::seconds expiration = std::chrono::minutes{2})
         : cache_(name, targetSize, expiration, clock, j, collector), gen_(1)
     {

include/xrpl/shamap/SHAMap.h

@@ -624,7 +624,7 @@ private:
 
 inline SHAMap::ConstIterator::ConstIterator(SHAMap const* map) : map_(map)
 {
-    XRPL_ASSERT(map_, "xrpl::SHAMap::const_iterator::const_iterator : non-null input");
+    XRPL_ASSERT(map_, "xrpl::SHAMap::ConstIterator::ConstIterator : non-null input");
 
     if (auto temp = map_->peekFirstItem(stack_))
         item_ = temp->peekItem().get();

include/xrpl/shamap/SHAMapItem.h

@@ -139,7 +139,7 @@ inline boost::intrusive_ptr<SHAMapItem>
 makeShamapitem(uint256 const& tag, Slice data)
 {
     XRPL_ASSERT(
-        data.size() <= megabytes<std::size_t>(16), "xrpl::make_shamapitem : maximum input size");
+        data.size() <= megabytes<std::size_t>(16), "xrpl::makeShamapitem : maximum input size");
 
     // NOLINTNEXTLINE(misc-const-correctness)
     std::uint8_t* raw = detail::gSlabber.allocate(data.size());

include/xrpl/shamap/SHAMapTreeNode.h

@@ -7,6 +7,7 @@
 #include <xrpl/shamap/SHAMapItem.h>
 #include <xrpl/shamap/SHAMapNodeID.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <string>
 
@@ -20,6 +21,9 @@ static constexpr unsigned char const kWIRE_TYPE_INNER = 2;
 static constexpr unsigned char const kWIRE_TYPE_COMPRESSED_INNER = 3;
 static constexpr unsigned char const kWIRE_TYPE_TRANSACTION_WITH_META = 4;
 
+// Lower bound on SHAMap leaf item payload size, in bytes.
+inline constexpr std::size_t kMIN_SHA_MAP_ITEM_BYTES = 12;
+
 enum class SHAMapNodeType {
     TnInner = 1,
     TnTransactionNm = 2,  // transaction, no metadata

include/xrpl/tx/Transactor.h

@@ -125,9 +125,8 @@ public:
     Transactor(Transactor const&) = delete;
     Transactor&
     operator=(Transactor const&) = delete;
-    // 68 transactor subclass files
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum ConsequencesFactoryType { Normal, Blocker, Custom };
+
+    enum class ConsequencesFactoryType { Normal, Blocker, Custom };
 
     /** Process the transaction. */
     ApplyResult

include/xrpl/tx/invariants/InvariantCheckPrivilege.h

@@ -25,7 +25,7 @@ not have the relevant amendments enabled_. It's intentionally a pain in the neck
 so that bad code gets caught and fixed as early as possible.
 */
 
-// Bitwise flags, 86 files
+// Bitwise flags, 86 files, used in macros files
 // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Privilege {
     NoPriv = 0x0000,              // The transaction can not do any of the enumerated operations

include/xrpl/tx/invariants/PermissionedDEXInvariant.h

@@ -11,8 +11,8 @@ namespace xrpl {
 class ValidPermissionedDEX
 {
     bool regularOffers_ = false;
-    bool badHybridsOld_ = false;  // pre-fixSecurity3_1_3: missing field/domain or size > 1
-    bool badHybrids_ = false;     // post-fixSecurity3_1_3: also catches size == 0 (size != 1)
+    bool badHybridsOld_ = false;  // pre-fixCleanup3_1_3: missing field/domain or size > 1
+    bool badHybrids_ = false;     // post-fixCleanup3_1_3: also catches size == 0 (size != 1)
     hash_set<uint256> domains_;
 
 public:

include/xrpl/tx/transactors/account/AccountDelete.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class AccountDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit AccountDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/account/AccountSet.h

@@ -8,7 +8,7 @@ namespace xrpl {
 class AccountSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     explicit AccountSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/account/SetRegularKey.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class SetRegularKey : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit SetRegularKey(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/account/SignerListSet.h

@@ -24,7 +24,7 @@ private:
     std::vector<SignerEntries::SignerEntry> signers_;
 
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit SignerListSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/bridge/XChainBridge.h

@@ -12,7 +12,7 @@ constexpr size_t kXBRIDGE_MAX_ACCOUNT_CREATE_CLAIMS = 128;
 class XChainCreateBridge : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit XChainCreateBridge(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -45,7 +45,7 @@ public:
 class BridgeModify : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit BridgeModify(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -95,7 +95,7 @@ class XChainClaim : public Transactor
 {
 public:
     // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit XChainClaim(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -133,7 +133,7 @@ public:
 class XChainCommit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     static TxConsequences
     makeTxConsequences(PreflightContext const& ctx);
@@ -179,7 +179,7 @@ public:
 class XChainCreateClaimID : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit XChainCreateClaimID(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -222,7 +222,7 @@ class XChainAddClaimAttestation : public Transactor
 {
 public:
     // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit XChainAddClaimAttestation(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -256,7 +256,7 @@ class XChainAddAccountCreateAttestation : public Transactor
 {
 public:
     // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;
 
     explicit XChainAddAccountCreateAttestation(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -314,7 +314,7 @@ public:
 class XChainCreateAccountCommit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit XChainCreateAccountCommit(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/check/CheckCancel.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CheckCancel(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/check/CheckCash.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCash : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CheckCash(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/check/CheckCreate.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CheckCreate(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/credentials/CredentialAccept.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialAccept : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/credentials/CredentialCreate.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/credentials/CredentialDelete.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/delegate/DelegateSet.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class DelegateSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit DelegateSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMBid.h

@@ -45,7 +45,7 @@ namespace xrpl {
 class AMMBid : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMBid(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMClawback.h

@@ -7,7 +7,7 @@ class Sandbox;
 class AMMClawback : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMClawback(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMCreate.h

@@ -37,7 +37,7 @@ namespace xrpl {
 class AMMCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMCreate(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMDelete.h

@@ -13,7 +13,7 @@ namespace xrpl {
 class AMMDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMDeposit.h

@@ -42,7 +42,7 @@ class Sandbox;
 class AMMDeposit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMDeposit(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMVote.h

@@ -30,7 +30,7 @@ namespace xrpl {
 class AMMVote : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMVote(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/AMMWithdraw.h

@@ -50,7 +50,7 @@ enum class WithdrawAll : bool { No = false, Yes };
 class AMMWithdraw : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit AMMWithdraw(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/OfferCancel.h

@@ -8,7 +8,7 @@ namespace xrpl {
 class OfferCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit OfferCancel(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/dex/OfferCreate.h

@@ -12,7 +12,7 @@ class Sandbox;
 class OfferCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     /** Construct a Transactor subclass that creates an offer in the ledger. */
     explicit OfferCreate(ApplyContext& ctx) : Transactor(ctx)

include/xrpl/tx/transactors/did/DIDDelete.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class DIDDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit DIDDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/did/DIDSet.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class DIDSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/escrow/EscrowCancel.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/escrow/EscrowCreate.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/escrow/EscrowFinish.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowFinish : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverClawback : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanBrokerCoverClawback(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverDeposit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanBrokerCoverDeposit(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverWithdraw : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanBrokerCoverWithdraw(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanBrokerDelete.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanBrokerDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanBrokerSet.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanBrokerSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanDelete.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanManage.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanManage : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanManage(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanPay.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanPay : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanPay(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/lending/LoanSet.h

@@ -8,7 +8,7 @@ namespace xrpl {
 class LoanSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit LoanSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h

@@ -20,7 +20,7 @@ private:
     transferNFToken(AccountID const& buyer, AccountID const& seller, uint256 const& nfTokenID);
 
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenAcceptOffer(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenBurn.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class NFTokenBurn : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenBurn(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class NFTokenCancelOffer : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenCancelOffer(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class NFTokenCreateOffer : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenCreateOffer(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenMint.h

@@ -9,7 +9,7 @@ namespace xrpl {
 class NFTokenMint : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenMint(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/nft/NFTokenModify.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class NFTokenModify : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit NFTokenModify(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/oracle/OracleDelete.h

@@ -16,7 +16,7 @@ namespace xrpl {
 class OracleDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit OracleDelete(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/oracle/OracleSet.h

@@ -16,7 +16,7 @@ namespace xrpl {
 class OracleSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit OracleSet(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/payment/DepositPreauth.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class DepositPreauth : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit DepositPreauth(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/payment/Payment.h

@@ -13,7 +13,7 @@ class Payment : public Transactor
     static std::size_t const kMAX_PATH_LENGTH = 8;
 
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     explicit Payment(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class PaymentChannelClaim : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;
 
     explicit PaymentChannelClaim(ApplyContext& ctx) : Transactor(ctx)
     {

include/xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h

@@ -7,7 +7,7 @@ namespace xrpl {
 class PaymentChannelCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;
 
     explicit PaymentChannelCreate(ApplyContext& ctx) : Transactor(ctx)
     {