Merge branch 'develop' into bthomee/node_depth

Co-authored-by: Alex Kremer <akremer@ripple.com>

.clang-tidy

@@ -45,54 +45,20 @@ Checks: "-*,
   llvm-namespace-comment,
 
   misc-*,
-  -misc-anonymous-namespace-in-header,
-  -misc-confusable-identifiers,
-  -misc-coroutine-hostile-raii,
-  -misc-misleading-bidirectional,
-  -misc-misleading-identifier,
   -misc-multiple-inheritance,
-  -misc-new-delete-overloads,
   -misc-no-recursion,
-  -misc-non-copyable-objects,
   -misc-non-private-member-variables-in-classes,
   -misc-override-with-different-visibility,
-  -misc-predictable-rand,
-  -misc-unconventional-assign-operator,
-  -misc-uniqueptr-reset-release,
   -misc-unused-parameters,
   -misc-use-anonymous-namespace,
   -misc-use-internal-linkage,
 
   modernize-*,
-  -modernize-avoid-bind,
   -modernize-avoid-c-arrays,
   -modernize-avoid-c-style-cast,
-  -modernize-avoid-setjmp-longjmp,
-  -modernize-avoid-variadic-functions,
-  -modernize-deprecated-ios-base-aliases,
-  -modernize-loop-convert,
-  -modernize-macro-to-enum,
-  -modernize-min-max-use-initializer-list,
-  -modernize-raw-string-literal,
-  -modernize-redundant-void-arg,
-  -modernize-replace-auto-ptr,
-  -modernize-replace-disallow-copy-and-assign-macro,
-  -modernize-replace-random-shuffle,
   -modernize-return-braced-init-list,
-  -modernize-shrink-to-fit,
-  -modernize-unary-static-assert,
-  -modernize-use-auto,
-  -modernize-use-bool-literals,
-  -modernize-use-constraints,
-  -modernize-use-default-member-init,
   -modernize-use-integer-sign-comparison,
-  -modernize-use-noexcept,
-  -modernize-use-nullptr,
-  -modernize-use-std-format,
-  -modernize-use-std-print,
   -modernize-use-trailing-return-type,
-  -modernize-use-transparent-functors,
-  -modernize-use-uncaught-exceptions,
 
   performance-*,
   -performance-avoid-endl,

.cspell.config.yaml

@@ -36,9 +36,7 @@ overrides:
       - /'[^']*'/g # single-quoted strings
       - /`[^`]*`/g # backtick strings
 suggestWords:
-  - xprl->xrpl
-  - xprld->xrpld # cspell: disable-line not sure what this problem is....
-  - unsynched->unsynced # cspell: disable-line not sure what this problem is....
+  - unsynched->unsynced
   - synched->synced
   - synch->sync
 words:
@@ -281,8 +279,6 @@ words:
   - sles
   - soci
   - socidb
-  - sponsee
-  - sponsees
   - SRPMS
   - sslws
   - statsd
@@ -331,7 +327,6 @@ words:
   - unserviced
   - unshareable
   - unshares
-  - unsponsored
   - unsquelch
   - unsquelched
   - unsquelching

.github/scripts/levelization/results/ordering.txt

@@ -72,7 +72,6 @@ test.app > xrpl.server
 test.app > xrpl.shamap
 test.app > xrpl.tx
 test.basics > test.jtx
-test.basics > test.unit_test
 test.basics > xrpl.basics
 test.basics > xrpl.core
 test.basics > xrpld.rpc
@@ -162,9 +161,6 @@ test.protocol > test.unit_test
 test.protocol > xrpl.basics
 test.protocol > xrpl.json
 test.protocol > xrpl.protocol
-test.resource > test.unit_test
-test.resource > xrpl.basics
-test.resource > xrpl.resource
 test.rpc > test.jtx
 test.rpc > xrpl.basics
 test.rpc > xrpl.config
@@ -188,12 +184,6 @@ test.server > xrpld.core
 test.server > xrpl.json
 test.server > xrpl.protocol
 test.server > xrpl.server
-test.shamap > test.unit_test
-test.shamap > xrpl.basics
-test.shamap > xrpl.config
-test.shamap > xrpl.nodestore
-test.shamap > xrpl.protocol
-test.shamap > xrpl.shamap
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
@@ -205,6 +195,7 @@ tests.libxrpl > xrpl.net
 tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
+tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx

.pre-commit-config.yaml

@@ -90,20 +90,19 @@ repos:
   - repo: https://github.com/streetsidesoftware/cspell-cli
     rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
     hooks:
-      - id: cspell # Spell check changed files
+      - id: cspell
+        name: check changed files spelling
         exclude: |
           (?x)^(
-              .config/cspell.config.yaml|
+              \.cspell\.config\.yaml|
               include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
           )$
-      - id: cspell # Spell check the commit message
+      - id: cspell
         name: check commit message spelling
         args:
           - --no-must-find-files
           - --no-progress
           - --no-summary
-          - --files
-          - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
   - repo: local

BUILD.md

@@ -25,7 +25,7 @@ You can verify that the required tools are installed and runnable with:
 | ----------- | --------------- |
 | GCC         | 15.2            |
 | Clang       | 22              |
-| Apple Clang | 17              |
+| Apple Clang | 21              |
 | MSVC        | 19.44[^windows] |
 
 ## Operating Systems

bin/pre-commit/clang_tidy_check.py

@@ -17,9 +17,11 @@ import subprocess
 import sys
 from pathlib import Path
 
+CLANG_TIDY_VERSION = 22
+
 
 def find_run_clang_tidy() -> str | None:
-    for candidate in ("run-clang-tidy-21", "run-clang-tidy"):
+    for candidate in (f"run-clang-tidy-{CLANG_TIDY_VERSION}", "run-clang-tidy"):
         if path := shutil.which(candidate):
             return path
     return None
@@ -44,8 +46,8 @@ def main():
     run_clang_tidy = find_run_clang_tidy()
     if not run_clang_tidy:
         print(
-            "clang-tidy check failed: TIDY is enabled but neither "
-            "'run-clang-tidy-21' nor 'run-clang-tidy' was found in PATH.",
+            f"clang-tidy check failed: TIDY is enabled but neither "
+            f"'run-clang-tidy-{CLANG_TIDY_VERSION}' nor 'run-clang-tidy' was found in PATH.",
             file=sys.stderr,
         )
         return 1

include/xrpl/basics/Slice.h

@@ -11,6 +11,7 @@
 #include <limits>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -211,15 +212,17 @@ operator<<(Stream& s, Slice const& v)
 }
 
 template <class T, std::size_t N>
-std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
+Slice
 makeSlice(std::array<T, N> const& a)
+    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(a.data(), a.size());
 }
 
 template <class T, class Alloc>
-std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
+Slice
 makeSlice(std::vector<T, Alloc> const& v)
+    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(v.data(), v.size());
 }
@@ -231,4 +234,11 @@ makeSlice(std::basic_string<char, Traits, Alloc> const& s)
     return Slice(s.data(), s.size());
 }
 
+template <class Traits>
+Slice
+makeSlice(std::basic_string_view<char, Traits> s)
+{
+    return Slice(s.data(), s.size());
+}
+
 }  // namespace xrpl

include/xrpl/basics/TaggedCache.h

@@ -212,11 +212,13 @@ public:
     */
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
+    insert(key_type const& key, T const& value) -> ReturnType
+        requires(!IsKeyCache);
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
+    insert(key_type const& key) -> ReturnType
+        requires IsKeyCache;
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.

include/xrpl/basics/TaggedCache.ipp

@@ -57,7 +57,10 @@ inline TaggedCache<
         beast::insight::Collector::ptr const& collector)
     : journal_(journal)
     , clock_(clock)
-    , stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
+    , stats_(
+          name,
+          [this] { collectMetrics(); },
+          collector)
     , name_(name)
     , targetSize_(size)
     , targetAge_(expiration)
@@ -500,7 +503,8 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
+    insert(key_type const& key, T const& value) -> ReturnType
+    requires(!IsKeyCache)
 {
     static_assert(
         std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -530,7 +534,8 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+    insert(key_type const& key) -> ReturnType
+    requires IsKeyCache
 {
     std::scoped_lock const lock(mutex_);
     clock_type::time_point const now(clock_.now());

include/xrpl/basics/ToString.h

@@ -12,8 +12,9 @@ namespace xrpl {
  */
 
 template <class T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::string>
+std::string
 to_string(T t)  // NOLINT(readability-identifier-naming)
+    requires(std::is_arithmetic_v<T>)
 {
     return std::to_string(t);
 }

include/xrpl/basics/base_uint.h

@@ -97,7 +97,7 @@ public:
     //
 
     static constexpr std::size_t kBytes = Bits / 8;
-    static_assert(sizeof(data_) == kBytes, "");
+    static_assert(sizeof(data_) == kBytes);
 
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
@@ -280,12 +280,11 @@ public:
     {
     }
 
-    template <
-        class Container,
-        class = std::enable_if_t<
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>>>
+    template <class Container>
     explicit BaseUInt(Container const& c)
+        requires(
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         // Use AlwaysFalseT so the static_assert condition is dependent
         // and only triggers when this constructor template is instantiated.
@@ -295,13 +294,12 @@ public:
             "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>>>
+    template <class Container>
     static BaseUInt
     fromRaw(Container const& c)
+        requires(
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         BaseUInt result;
         XRPL_ASSERT(
@@ -312,11 +310,11 @@ public:
     }
 
     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)
+        requires(
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),

include/xrpl/basics/comparators.h

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <functional>
-
-namespace xrpl {
-
-#ifdef _MSC_VER
-
-/*
- * MSVC 2019 version 16.9.0 added [[nodiscard]] to the std comparison
- * operator() functions. boost::bimap checks that the comparator is a
- * BinaryFunction, in part by calling the function and ignoring the value.
- * These two things don't play well together. These wrapper classes simply
- * strip [[nodiscard]] from operator() for use in boost::bimap.
- *
- * See also:
- *  https://www.boost.org/doc/libs/1_75_0/libs/bimap/doc/html/boost_bimap/the_tutorial/controlling_collection_types.html
- */
-
-template <class T = void>
-struct less
-{
-    using result_type = bool;
-
-    constexpr bool
-    operator()(T const& left, T const& right) const
-    {
-        return std::less<T>()(left, right);
-    }
-};
-
-template <class T = void>
-struct equal_to
-{
-    using result_type = bool;
-
-    constexpr bool
-    operator()(T const& left, T const& right) const
-    {
-        return std::equal_to<T>()(left, right);
-    }
-};
-
-#else
-
-template <class T = void>
-using less = std::less<T>;
-
-template <class T = void>
-using equal_to = std::equal_to<T>;
-
-#endif
-
-}  // namespace xrpl

include/xrpl/basics/random.h

@@ -91,8 +91,9 @@ defaultPrng()
 */
 /** @{ */
 template <class Engine, class Integral>
-std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
+Integral
 randInt(Engine& engine, Integral min, Integral max)
+    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
 
@@ -103,36 +104,41 @@ randInt(Engine& engine, Integral min, Integral max)
 }
 
 template <class Integral>
-std::enable_if_t<std::is_integral_v<Integral>, Integral>
+Integral
 randInt(Integral min, Integral max)
+    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), min, max);
 }
 
 template <class Engine, class Integral>
-std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
+Integral
 randInt(Engine& engine, Integral max)
+    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, Integral(0), max);
 }
 
 template <class Integral>
-std::enable_if_t<std::is_integral_v<Integral>, Integral>
+Integral
 randInt(Integral max)
+    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), max);
 }
 
 template <class Integral, class Engine>
-std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
+Integral
 randInt(Engine& engine)
+    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, std::numeric_limits<Integral>::max());
 }
 
 template <class Integral = int>
-std::enable_if_t<std::is_integral_v<Integral>, Integral>
+Integral
 randInt()
+    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
 }
@@ -141,19 +147,20 @@ randInt()
 /** Return a random byte */
 /** @{ */
 template <class Byte, class Engine>
-std::enable_if_t<
-    (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
-        detail::is_engine<Engine>::value,
-    Byte>
+Byte
 randByte(Engine& engine)
+    requires(
+        (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
+        detail::is_engine<Engine>::value)
 {
     return static_cast<Byte>(randInt<Engine, std::uint32_t>(
         engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
+Byte
 randByte()
+    requires(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>)
 {
     return randByte<Byte>(defaultPrng());
 }

include/xrpl/basics/safe_cast.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xrpl/beast/utility/instrumentation.h>  // IWYU pragma: keep
+
 #include <type_traits>
 
 namespace xrpl {
@@ -15,8 +17,9 @@ concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
                                                      : sizeof(Dest) >= sizeof(Src));
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
+constexpr Dest
 safeCast(Src s) noexcept
+    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
@@ -28,15 +31,17 @@ safeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
+constexpr Dest
 safeCast(Src s) noexcept
+    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(safeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
+constexpr Dest
 safeCast(Src s) noexcept
+    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return safeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
@@ -46,8 +51,9 @@ safeCast(Src s) noexcept
 // underlying types become safe, it can be converted to a safe_cast.
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
+constexpr Dest
 unsafeCast(Src s) noexcept
+    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         !SafeToCast<Src, Dest>,
@@ -57,15 +63,17 @@ unsafeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
+constexpr Dest
 unsafeCast(Src s) noexcept
+    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(unsafeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
+constexpr Dest
 unsafeCast(Src s) noexcept
+    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return unsafeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }

include/xrpl/basics/scope.h

@@ -46,11 +46,9 @@ public:
     operator=(ScopeExit&&) = delete;
 
     template <class EFP>
-    explicit ScopeExit(
-        EFP&& f,
-        std::enable_if_t<
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> &&
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
+    explicit ScopeExit(EFP&& f) noexcept
+        requires(
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> && std::is_constructible_v<EF, EFP>)
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -93,11 +91,9 @@ public:
     operator=(ScopeFail&&) = delete;
 
     template <class EFP>
-    explicit ScopeFail(
-        EFP&& f,
-        std::enable_if_t<
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> &&
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
+    explicit ScopeFail(EFP&& f) noexcept
+        requires(
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> && std::is_constructible_v<EF, EFP>)
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -140,12 +136,11 @@ public:
     operator=(ScopeSuccess&&) = delete;
 
     template <class EFP>
-    explicit ScopeSuccess(
-        EFP&& f,
-        std::enable_if_t<
+    explicit ScopeSuccess(EFP&& f) noexcept(
+        std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
+        requires(
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
-            std::is_constructible_v<EF, EFP>>* =
-            0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
+            std::is_constructible_v<EF, EFP>)
         : exitFunction_{std::forward<EFP>(f)}
     {
     }

include/xrpl/basics/tagged_integer.h

@@ -43,10 +43,10 @@ public:
 
     TaggedInteger() = default;
 
-    template <
-        class OtherInt,
-        class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
-    explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
+    template <class OtherInt>
+    explicit constexpr TaggedInteger(OtherInt value) noexcept
+        requires(std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int))
+        : value_(value)
     {
         static_assert(sizeof(TaggedInteger) == sizeof(Int), "tagged_integer is adding padding");
     }

include/xrpl/beast/container/aged_container_utility.h

@@ -4,14 +4,14 @@
 
 #include <chrono>
 #include <cstddef>
-#include <type_traits>
 
 namespace beast {
 
 /** Expire aged container items past the specified age. */
 template <class AgedContainer, class Rep, class Period>
-std::enable_if_t<IsAgedContainer<AgedContainer>::value, std::size_t>
+std::size_t
 expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
+    requires(IsAgedContainer<AgedContainer>::value)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);

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

@@ -30,20 +30,19 @@ public:
 
     // Disable constructing a const_iterator from a non-const_iterator.
     // Converting between reverse and non-reverse iterators should be explicit.
-    template <
-        bool OtherIsConst,
-        class OtherIterator,
-        class = std::enable_if_t<
-            (!OtherIsConst || IsConst) &&
-            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>)>>
+    template <bool OtherIsConst, class OtherIterator>
     explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
+        requires(
+            (!OtherIsConst || IsConst) &&
+            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>))
         : iter_(other.iter_)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <bool OtherIsConst, class = std::enable_if_t<!OtherIsConst || IsConst>>
+    template <bool OtherIsConst>
     AgedContainerIterator(AgedContainerIterator<OtherIsConst, Iterator> const& other)
+        requires(!OtherIsConst || IsConst)
         : iter_(other.iter_)
     {
     }
@@ -52,7 +51,8 @@ public:
     template <bool OtherIsConst, class OtherIterator>
     auto
     operator=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-        -> std::enable_if_t<!OtherIsConst || IsConst, AgedContainerIterator&>
+        -> AgedContainerIterator&
+        requires(!OtherIsConst || IsConst)
     {
         iter_ = other.iter_;
         return *this;

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

@@ -111,10 +111,9 @@ private:
         {
         }
 
-        template <
-            class... Args,
-            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
+        template <class... Args>
         Element(time_point const& when, Args&&... args)
+            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -608,35 +607,25 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <
-        class K,
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k);
+    at(K const& k)
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        class K,
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const;
+    at(K const& k) const
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key);
+    operator[](Key const& key)
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key);
+    operator[](Key&& key)
+        requires(MaybeMap && !MaybeMulti);
 
     //--------------------------------------------------------------------------
     //
@@ -770,35 +759,40 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    insert(value_type const& value) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
+    insert(value_type const& value) -> iterator
+        requires MaybeMulti;
 
     // set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value)
-        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
+    insert(value_type&& value) -> std::pair<iterator, bool>
+        requires(!MaybeMulti && !MaybeMap);
 
     // multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
+    insert(value_type&& value) -> iterator
+        requires(MaybeMulti && !MaybeMap);
 
     //---
 
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>;
+    insert(const_iterator hint, value_type const& value) -> iterator
+        requires(!MaybeMulti);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type const& value)
+        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(value);
@@ -807,12 +801,14 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>;
+    insert(const_iterator hint, value_type&& value) -> iterator
+        requires(!MaybeMulti);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type&& value)
+        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(std::move(value));
@@ -820,20 +816,18 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::enable_if_t<
-        MaybeMap && std::is_constructible_v<value_type, P&&>,
-        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
+    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(P&& value)
+        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::enable_if_t<
-        MaybeMap && std::is_constructible_v<value_type, P&&>,
-        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
+    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(const_iterator hint, P&& value)
+        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -855,46 +849,45 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    emplace(Args&&... args) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
+    emplace(Args&&... args) -> iterator
+        requires MaybeMulti;
 
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator hint, Args&&... args)
-        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    emplaceHint(const_iterator hint, Args&&... args) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     emplaceHint(const_iterator /*hint*/, Args&&... args)
+        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return emplace<MaybeMulti>(std::forward<Args>(args)...);
     }
 
-    // enable_if prevents erase (reverse_iterator pos) from compiling
-    template <
-        bool IsConst,
-        class Iterator,
-        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
+    // The constraint prevents erase (reverse_iterator pos) from compiling
+    template <bool IsConst, class Iterator>
     beast::detail::AgedContainerIterator<false, Iterator>
-    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos);
+    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
+        requires(!IsBoostReverseIterator<Iterator>::value);
 
-    // enable_if prevents erase (reverse_iterator first, reverse_iterator last)
+    // The constraint prevents erase (reverse_iterator first, reverse_iterator last)
     // from compiling
-    template <
-        bool IsConst,
-        class Iterator,
-        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
+    template <bool IsConst, class Iterator>
     beast::detail::AgedContainerIterator<false, Iterator>
     erase(
         beast::detail::AgedContainerIterator<IsConst, Iterator> first,
-        beast::detail::AgedContainerIterator<IsConst, Iterator> last);
+        beast::detail::AgedContainerIterator<IsConst, Iterator> last)
+        requires(!IsBoostReverseIterator<Iterator>::value);
 
     template <class K>
     auto
@@ -905,13 +898,11 @@ public:
 
     //--------------------------------------------------------------------------
 
-    // enable_if prevents touch (reverse_iterator pos) from compiling
-    template <
-        bool IsConst,
-        class Iterator,
-        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
+    // The constraint prevents touch (reverse_iterator pos) from compiling
+    template <bool IsConst, class Iterator>
     void
     touch(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
+        requires(!IsBoostReverseIterator<Iterator>::value)
     {
         touch(pos, clock().now());
     }
@@ -1142,25 +1133,25 @@ public:
     }
 
 private:
-    // enable_if prevents erase (reverse_iterator pos, now) from compiling
-    template <
-        bool IsConst,
-        class Iterator,
-        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
+    // The constraint prevents erase (reverse_iterator pos, now) from compiling
+    template <bool IsConst, class Iterator>
     void
     touch(
         beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-        clock_type::time_point const& now);
+        clock_type::time_point const& now)
+        requires(!IsBoostReverseIterator<Iterator>::value);
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    std::enable_if_t<MaybePropagate>
-    swapData(AgedOrderedContainer& other) noexcept;
+    void
+    swapData(AgedOrderedContainer& other) noexcept
+        requires MaybePropagate;
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    std::enable_if_t<!MaybePropagate>
-    swapData(AgedOrderedContainer& other) noexcept;
+    void
+    swapData(AgedOrderedContainer& other) noexcept
+        requires(!MaybePropagate);
 
 private:
     ConfigT config_;
@@ -1369,9 +1360,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap, class>
+template <class K, bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
+    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1380,9 +1372,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap, class>
+template <class K, bool MaybeMulti, bool MaybeMap>
 std::conditional<IsMap, T, void*>::type const&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k) const
+    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1391,9 +1384,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap, class>
+template <bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
+    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1409,9 +1403,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap, class>
+template <bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
+    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1445,7 +1440,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    value_type const& value) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1464,7 +1460,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
+    value_type const& value) -> iterator
+    requires MaybeMulti
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(value));
@@ -1478,7 +1475,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
+    -> std::pair<iterator, bool>
+    requires(!MaybeMulti && !MaybeMap)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1497,7 +1495,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
+    -> iterator
+    requires(MaybeMulti && !MaybeMap)
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(std::move(value)));
@@ -1514,7 +1513,8 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>
+    value_type const& value) -> iterator
+    requires(!MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1535,7 +1535,8 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>
+    value_type&& value) -> iterator
+    requires(!MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1555,7 +1556,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1577,7 +1579,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> std::enable_if_t<MaybeMulti, iterator>
+    -> iterator
+    requires MaybeMulti
 {
     Element* const p(newElement(std::forward<Args>(args)...));
     auto const before(cont_.upper_bound(extract(p->value), std::cref(config_.keyCompare())));
@@ -1592,7 +1595,8 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplaceHint(
     const_iterator hint,
-    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    Args&&... args) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1611,21 +1615,23 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator, class>
+template <bool IsConst, class Iterator>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
+    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     unlinkAndDeleteElement(&*((pos++).iterator()));
     return beast::detail::AgedContainerIterator<false, Iterator>(pos.iterator());
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator, class>
+template <bool IsConst, class Iterator>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> first,
     beast::detail::AgedContainerIterator<IsConst, Iterator> last)
+    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     for (; first != last;)
         unlinkAndDeleteElement(&*((first++).iterator()));
@@ -1728,11 +1734,12 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator, class>
+template <bool IsConst, class Iterator>
 void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
     clock_type::time_point const& now)
+    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     auto& e(*pos.iterator());
     e.when = now;
@@ -1742,9 +1749,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-std::enable_if_t<MaybePropagate>
+void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
+    requires MaybePropagate
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.alloc(), other.config_.alloc());
@@ -1753,9 +1761,10 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapDat
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-std::enable_if_t<!MaybePropagate>
+void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
+    requires(!MaybePropagate)
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.clock, other.config_.clock);

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

@@ -117,10 +117,9 @@ private:
         {
         }
 
-        template <
-            class... Args,
-            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
+        template <class... Args>
         Element(time_point const& when, Args&&... args)
+            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -841,35 +840,25 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <
-        class K,
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k);
+    at(K const& k)
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        class K,
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const;
+    at(K const& k) const
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key);
+    operator[](Key const& key)
+        requires(MaybeMap && !MaybeMulti);
 
-    template <
-        bool MaybeMulti = IsMulti,
-        bool MaybeMap = IsMap,
-        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
+    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key);
+    operator[](Key&& key)
+        requires(MaybeMap && !MaybeMulti);
 
     //--------------------------------------------------------------------------
     //
@@ -967,28 +956,32 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    insert(value_type const& value) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
+    insert(value_type const& value) -> iterator
+        requires MaybeMulti;
 
     // map, set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value)
-        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
+    insert(value_type&& value) -> std::pair<iterator, bool>
+        requires(!MaybeMulti && !MaybeMap);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
+    insert(value_type&& value) -> iterator
+        requires(MaybeMulti && !MaybeMap);
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<!MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type const& value)
+        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -997,8 +990,9 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type const& value)
+        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1007,8 +1001,9 @@ public:
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<!MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type&& value)
+        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -1017,8 +1012,9 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     insert(const_iterator /*hint*/, value_type&& value)
+        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1027,20 +1023,18 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::enable_if_t<
-        MaybeMap && std::is_constructible_v<value_type, P&&>,
-        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
+    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(P&& value)
+        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::enable_if_t<
-        MaybeMap && std::is_constructible_v<value_type, P&&>,
-        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
+    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(const_iterator hint, P&& value)
+        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -1061,23 +1055,26 @@ public:
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    emplace(Args&&... args) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
+    emplace(Args&&... args) -> iterator
+        requires MaybeMulti;
 
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator /*hint*/, Args&&... args)
-        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    emplaceHint(const_iterator /*hint*/, Args&&... args) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    std::enable_if_t<MaybeMulti, iterator>
+    iterator
     emplaceHint(const_iterator /*hint*/, Args&&... args)
+        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used for multi, to let
         //             the client order equal ranges
@@ -1308,7 +1305,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    std::enable_if_t<!MaybeMulti, bool>
+    bool
     operator==(AgedUnorderedContainer<
                false,
                OtherIsMap,
@@ -1317,7 +1314,8 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const;
+               OtherAllocator> const& other) const
+        requires(!MaybeMulti);
 
     template <
         bool OtherIsMap,
@@ -1327,7 +1325,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    std::enable_if_t<MaybeMulti, bool>
+    bool
     operator==(AgedUnorderedContainer<
                true,
                OtherIsMap,
@@ -1336,7 +1334,8 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const;
+               OtherAllocator> const& other) const
+        requires MaybeMulti;
 
     template <
         bool OtherIsMulti,
@@ -1381,13 +1380,14 @@ private:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value)
-        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
+    insertUnchecked(value_type const& value) -> std::pair<iterator, bool>
+        requires(!MaybeMulti);
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
+    insertUnchecked(value_type const& value) -> iterator
+        requires MaybeMulti;
 
     template <class InputIt>
     void
@@ -1428,8 +1428,9 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    std::enable_if_t<MaybePropagate>
+    void
     swapData(AgedUnorderedContainer& other) noexcept
+        requires MaybePropagate
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -1439,8 +1440,9 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    std::enable_if_t<!MaybePropagate>
+    void
     swapData(AgedUnorderedContainer& other) noexcept
+        requires(!MaybePropagate)
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -2094,9 +2096,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap, class>
+template <class K, bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
+    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2114,10 +2117,11 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap, class>
+template <class K, bool MaybeMulti, bool MaybeMap>
 std::conditional<IsMap, T, void*>::type const&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(
     K const& k) const
+    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2135,10 +2139,11 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap, class>
+template <bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key const& key)
+    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2164,10 +2169,11 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap, class>
+template <bool MaybeMulti, bool MaybeMap>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key&& key)
+    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2220,7 +2226,8 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    value_type const& value) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2249,7 +2256,8 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
+    value_type const& value) -> iterator
+    requires MaybeMulti
 {
     maybeRehash(1);
     Element* const p(newElement(value));
@@ -2271,7 +2279,8 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
+    value_type&& value) -> std::pair<iterator, bool>
+    requires(!MaybeMulti && !MaybeMap)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2300,7 +2309,8 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
+    value_type&& value) -> iterator
+    requires(MaybeMulti && !MaybeMap)
 {
     maybeRehash(1);
     Element* const p(newElement(std::move(value)));
@@ -2309,7 +2319,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     return iterator(iter);
 }
 
-#if 1  // Use insert() instead of insert_check() insert_commit()
 // set, map
 template <
     bool IsMulti,
@@ -2323,7 +2332,8 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    Args&&... args) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2338,42 +2348,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     deleteElement(p);
     return std::make_pair(iterator(result.first), false);
 }
-#else   // As original, use insert_check() / insert_commit () pair.
-// set, map
-template <
-    bool IsMulti,
-    bool IsMap,
-    class Key,
-    class T,
-    class Clock,
-    class Hash,
-    class KeyEqual,
-    class Allocator>
-template <bool maybe_multi, class... Args>
-auto
-AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
-{
-    maybe_rehash(1);
-    // VFALCO NOTE Its unfortunate that we need to
-    //             construct element here
-    element* const p(new_element(std::forward<Args>(args)...));
-    typename cont_type::insert_commit_data d;
-    auto const result(m_cont.insert_check(
-        extract(p->value),
-        std::cref(m_config.hashFunction()),
-        std::cref(m_config.keyValueEqual()),
-        d));
-    if (result.second)
-    {
-        auto const iter(m_cont.insert_commit(*p, d));
-        chronological.list.push_back(*p);
-        return std::make_pair(iterator(iter), true);
-    }
-    delete_element(p);
-    return std::make_pair(iterator(result.first), false);
-}
-#endif  // 0
 
 // multiset, multimap
 template <
@@ -2388,7 +2362,8 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>
+    Args&&... args) -> iterator
+    requires MaybeMulti
 {
     maybeRehash(1);
     Element* const p(newElement(std::forward<Args>(args)...));
@@ -2411,7 +2386,8 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplaceHint(
     const_iterator /*hint*/,
-    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    Args&&... args) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2562,7 +2538,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-std::enable_if_t<!MaybeMulti, bool>
+bool
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         false,
@@ -2573,6 +2549,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
+    requires(!MaybeMulti)
 {
     if (size() != other.size())
         return false;
@@ -2602,7 +2579,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-std::enable_if_t<MaybeMulti, bool>
+bool
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         true,
@@ -2613,6 +2590,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
+    requires MaybeMulti
 {
     if (size() != other.size())
         return false;
@@ -2649,7 +2627,8 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
+    value_type const& value) -> std::pair<iterator, bool>
+    requires(!MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(
@@ -2677,7 +2656,8 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
+    value_type const& value) -> iterator
+    requires MaybeMulti
 {
     Element* const p(newElement(value));
     chronological.list_.push_back(*p);

include/xrpl/beast/core/LexicalCast.h

@@ -29,16 +29,18 @@ struct LexicalCast<std::string, In>
     explicit LexicalCast() = default;
 
     template <class Arithmetic = In>
-    std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool>
+    bool
     operator()(std::string& out, Arithmetic in)
+        requires(std::is_arithmetic_v<Arithmetic>)
     {
         out = std::to_string(in);
         return true;
     }
 
     template <class Enumeration = In>
-    std::enable_if_t<std::is_enum_v<Enumeration>, bool>
+    bool
     operator()(std::string& out, Enumeration in)
+        requires(std::is_enum_v<Enumeration>)
     {
         out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
         return true;
@@ -56,8 +58,9 @@ struct LexicalCast<Out, std::string_view>
         "beast::LexicalCast can only be used with integral types");
 
     template <class Integral = Out>
-    std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>
+    bool
     operator()(Integral& out, std::string_view in) const
+        requires(std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>)
     {
         auto first = in.data();
         auto last = in.data() + in.size();

include/xrpl/beast/core/LockFreeStack.h

@@ -41,7 +41,7 @@ public:
     operator=(NodePtr node)
     {
         node_ = node;
-        return static_cast<LockFreeStackIterator&>(*this);
+        return *this;
     }
 
     LockFreeStackIterator&

include/xrpl/beast/hash/hash_append.h

@@ -26,7 +26,7 @@ template <class T>
 inline void
 reverseBytes(T& t)
 {
-    unsigned char* bytes =
+    auto* bytes =
         static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
     for (unsigned i = 0; i < sizeof(T) / 2; ++i)
         std::swap(bytes[i], bytes[sizeof(T) - 1 - i]);
@@ -200,26 +200,29 @@ struct IsContiguouslyHashable<T[N], HashAlgorithm>
 // scalars
 
 template <class Hasher, class T>
-inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
+inline void
 hash_append(Hasher& h, T const& t) noexcept
+    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     // NOLINTNEXTLINE(bugprone-sizeof-expression)
     h(static_cast<void const*>(std::addressof(t)), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline std::enable_if_t<
-    !IsContiguouslyHashable<T, Hasher>::value &&
-    (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
+inline void
 hash_append(Hasher& h, T t) noexcept
+    requires(
+        !IsContiguouslyHashable<T, Hasher>::value &&
+        (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>))
 {
     detail::reverseBytes(t);
     h(std::addressof(t), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline std::enable_if_t<std::is_floating_point_v<T>>
+inline void
 hash_append(Hasher& h, T t) noexcept
+    requires(std::is_floating_point_v<T>)
 {
     if (t == 0)
         t = 0;
@@ -239,36 +242,44 @@ hash_append(Hasher& h, std::nullptr_t) noexcept
 // Forward declarations for ADL purposes
 
 template <class Hasher, class T, std::size_t N>
-std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
-hash_append(Hasher& h, T (&a)[N]) noexcept;
+void
+hash_append(Hasher& h, T (&a)[N]) noexcept
+    requires(!IsContiguouslyHashable<T, Hasher>::value);
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
+void
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
+    requires(!IsContiguouslyHashable<CharT, Hasher>::value);
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
+void
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
+    requires(IsContiguouslyHashable<CharT, Hasher>::value);
 
 template <class Hasher, class T, class U>
-std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
-hash_append(Hasher& h, std::pair<T, U> const& p) noexcept;
+void
+hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
+    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value);
 
 template <class Hasher, class T, class Alloc>
-std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
+void
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
+    requires(!IsContiguouslyHashable<T, Hasher>::value);
 
 template <class Hasher, class T, class Alloc>
-std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
+void
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
+    requires(IsContiguouslyHashable<T, Hasher>::value);
 
 template <class Hasher, class T, std::size_t N>
-std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
-hash_append(Hasher& h, std::array<T, N> const& a) noexcept;
+void
+hash_append(Hasher& h, std::array<T, N> const& a) noexcept
+    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value);
 
 template <class Hasher, class... T>
-std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
-hash_append(Hasher& h, std::tuple<T...> const& t) noexcept;
+void
+hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
+    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value);
 
 template <class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
 void
@@ -279,11 +290,13 @@ void
 hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
 
 template <class Hasher, class Key, class Compare, class Alloc>
-std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
+void
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
+    requires(!IsContiguouslyHashable<Key, Hasher>::value);
 template <class Hasher, class Key, class Compare, class Alloc>
-std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
+void
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
+    requires(IsContiguouslyHashable<Key, Hasher>::value);
 template <class Hasher, class T0, class T1, class... T>
 void
 hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
@@ -291,8 +304,9 @@ hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
 // c-array
 
 template <class Hasher, class T, std::size_t N>
-std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+void
 hash_append(Hasher& h, T (&a)[N]) noexcept
+    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
@@ -301,8 +315,9 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
 // basic_string
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
+    requires(!IsContiguouslyHashable<CharT, Hasher>::value)
 {
     for (auto c : s)
         hash_append(h, c);
@@ -310,8 +325,9 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 }
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
+    requires(IsContiguouslyHashable<CharT, Hasher>::value)
 {
     h(s.data(), s.size() * sizeof(CharT));
     hash_append(h, s.size());
@@ -320,8 +336,9 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 // pair
 
 template <class Hasher, class T, class U>
-inline std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
+    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value)
 {
     hash_append(h, p.first, p.second);
 }
@@ -329,8 +346,9 @@ hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
 // vector
 
 template <class Hasher, class T, class Alloc>
-inline std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
+    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
@@ -338,8 +356,9 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 }
 
 template <class Hasher, class T, class Alloc>
-inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
+    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     h(v.data(), v.size() * sizeof(T));
     hash_append(h, v.size());
@@ -348,57 +367,37 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 // array
 
 template <class Hasher, class T, std::size_t N>
-std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
+void
 hash_append(Hasher& h, std::array<T, N> const& a) noexcept
+    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
 }
 
 template <class Hasher, class Key, class Compare, class Alloc>
-std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
+void
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
+    requires(!IsContiguouslyHashable<Key, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
 }
 template <class Hasher, class Key, class Compare, class Alloc>
-std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
+void
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
+    requires(IsContiguouslyHashable<Key, Hasher>::value)
 {
     h(&(v.begin()), v.size() * sizeof(Key));
 }
 // tuple
 
-namespace detail {
-
-inline void
-forEachItem(...) noexcept
-{
-}
-
-template <class Hasher, class T>
-inline int
-hashOne(Hasher& h, T const& t) noexcept
-{
-    hash_append(h, t);
-    return 0;
-}
-
-template <class Hasher, class... T, std::size_t... I>
-inline void
-tuple_hash(Hasher& h, std::tuple<T...> const& t, std::index_sequence<I...>) noexcept
-{
-    for_each_item(hash_one(h, std::get<I>(t))...);
-}
-
-}  // namespace detail
-
 template <class Hasher, class... T>
-inline std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
+inline void
 hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
+    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)
 {
-    detail::tuple_hash(h, t, std::index_sequence_for<T...>{});
+    std::apply([&h](auto const&... item) { (hash_append(h, item), ...); }, t);
 }
 
 // shared_ptr

include/xrpl/beast/hash/xxhasher.h

@@ -124,14 +124,18 @@ public:
         }
     }
 
-    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
-    explicit Xxhasher(Seed seed) : seed_(seed)
+    template <class Seed>
+    explicit Xxhasher(Seed seed)
+        requires(std::is_unsigned_v<Seed>)
+        : seed_(seed)
     {
         resetBuffers();
     }
 
-    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
-    Xxhasher(Seed seed, Seed) : seed_(seed)
+    template <class Seed>
+    Xxhasher(Seed seed, Seed)
+        requires(std::is_unsigned_v<Seed>)
+        : seed_(seed)
     {
         resetBuffers();
     }

include/xrpl/beast/insight/Gauge.h

@@ -49,6 +49,11 @@ public:
             impl_->set(value);
     }
 
+    // This is a write-through handle: assignment sets the value of the
+    // referenced metric.  It is const-qualified and returns Gauge const&
+    // (a non-const Gauge& would require a const_cast), so it does not follow
+    // the conventional assignment-operator signature.
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     Gauge const&
     operator=(value_type value) const
     {

include/xrpl/beast/unit_test/suite_list.h

@@ -10,9 +10,9 @@
 #include <boost/assert.hpp>
 
 #include <set>
-#include <string>
-#include <typeindex>
-#include <unordered_set>
+#include <string>         // IWYU pragma: keep
+#include <typeindex>      // IWYU pragma: keep
+#include <unordered_set>  // IWYU pragma: keep
 
 namespace beast::unit_test {
 

include/xrpl/beast/unit_test/thread.h

@@ -45,7 +45,10 @@ public:
     template <class F, class... Args>
     explicit Thread(Suite& s, F&& f, Args&&... args) : s_(&s)
     {
-        std::function<void(void)> b = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
+        std::function<void(void)> b = [f = std::forward<F>(f),
+                                       ... args = std::forward<Args>(args)]() mutable {
+            std::invoke(f, args...);
+        };
         t_ = std::thread(&Thread::run, this, std::move(b));
     }
 

include/xrpl/beast/utility/Journal.h

@@ -108,12 +108,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<Sink>, "");
-    static_assert(!std::is_copy_constructible_v<Sink>, "");
-    static_assert(!std::is_move_constructible_v<Sink>, "");
-    static_assert(!std::is_copy_assignable_v<Sink>, "");
-    static_assert(!std::is_move_assignable_v<Sink>, "");
-    static_assert(std::is_nothrow_destructible_v<Sink>, "");
+    static_assert(!std::is_default_constructible_v<Sink>);
+    static_assert(!std::is_copy_constructible_v<Sink>);
+    static_assert(!std::is_move_constructible_v<Sink>);
+    static_assert(!std::is_copy_assignable_v<Sink>);
+    static_assert(!std::is_move_assignable_v<Sink>);
+    static_assert(std::is_nothrow_destructible_v<Sink>);
 #endif
 
     /** Returns a Sink which does nothing. */
@@ -164,12 +164,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<ScopedStream>, "");
-    static_assert(std::is_copy_constructible_v<ScopedStream>, "");
-    static_assert(std::is_move_constructible_v<ScopedStream>, "");
-    static_assert(!std::is_copy_assignable_v<ScopedStream>, "");
-    static_assert(!std::is_move_assignable_v<ScopedStream>, "");
-    static_assert(std::is_nothrow_destructible_v<ScopedStream>, "");
+    static_assert(!std::is_default_constructible_v<ScopedStream>);
+    static_assert(std::is_copy_constructible_v<ScopedStream>);
+    static_assert(std::is_move_constructible_v<ScopedStream>);
+    static_assert(!std::is_copy_assignable_v<ScopedStream>);
+    static_assert(!std::is_move_assignable_v<ScopedStream>);
+    static_assert(std::is_nothrow_destructible_v<ScopedStream>);
 #endif
 
     //--------------------------------------------------------------------------
@@ -246,12 +246,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(std::is_default_constructible_v<Stream>, "");
-    static_assert(std::is_copy_constructible_v<Stream>, "");
-    static_assert(std::is_move_constructible_v<Stream>, "");
-    static_assert(!std::is_copy_assignable_v<Stream>, "");
-    static_assert(!std::is_move_assignable_v<Stream>, "");
-    static_assert(std::is_nothrow_destructible_v<Stream>, "");
+    static_assert(std::is_default_constructible_v<Stream>);
+    static_assert(std::is_copy_constructible_v<Stream>);
+    static_assert(std::is_move_constructible_v<Stream>);
+    static_assert(!std::is_copy_assignable_v<Stream>);
+    static_assert(!std::is_move_assignable_v<Stream>);
+    static_assert(std::is_nothrow_destructible_v<Stream>);
 #endif
 
     //--------------------------------------------------------------------------
@@ -329,12 +329,12 @@ public:
 };
 
 #ifndef __INTELLISENSE__
-static_assert(!std::is_default_constructible_v<Journal>, "");
-static_assert(std::is_copy_constructible_v<Journal>, "");
-static_assert(std::is_move_constructible_v<Journal>, "");
-static_assert(std::is_copy_assignable_v<Journal>, "");
-static_assert(std::is_move_assignable_v<Journal>, "");
-static_assert(std::is_nothrow_destructible_v<Journal>, "");
+static_assert(!std::is_default_constructible_v<Journal>);
+static_assert(std::is_copy_constructible_v<Journal>);
+static_assert(std::is_move_constructible_v<Journal>);
+static_assert(std::is_copy_assignable_v<Journal>);
+static_assert(std::is_move_assignable_v<Journal>);
+static_assert(std::is_nothrow_destructible_v<Journal>);
 #endif
 
 //------------------------------------------------------------------------------

include/xrpl/beast/utility/Zero.h

@@ -26,9 +26,7 @@ struct Zero
     explicit Zero() = default;
 };
 
-namespace {
-constexpr Zero kZero{};
-}  // namespace
+inline constexpr Zero kZero{};
 
 /** Default implementation of signum calls the method on the class. */
 template <typename T>

include/xrpl/beast/utility/rngfill.h

@@ -3,7 +3,6 @@
 #include <array>
 #include <cstdint>
 #include <cstring>
-#include <type_traits>
 
 namespace beast {
 
@@ -14,7 +13,7 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     using result_type = Generator::result_type;
     constexpr std::size_t kResultSize = sizeof(result_type);
 
-    std::uint8_t* const bufferStart = static_cast<std::uint8_t*>(buffer);
+    auto* const bufferStart = static_cast<std::uint8_t*>(buffer);
     std::size_t const completeIterations = bytes / kResultSize;
     std::size_t const bytesRemaining = bytes % kResultSize;
 
@@ -33,16 +32,14 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     }
 }
 
-template <
-    class Generator,
-    std::size_t N,
-    class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
+template <class Generator, std::size_t N>
 void
 rngfill(std::array<std::uint8_t, N>& a, Generator& g)
+    requires(N % sizeof(typename Generator::result_type) == 0)
 {
     using result_type = Generator::result_type;
     auto i = N / sizeof(result_type);
-    result_type* p = reinterpret_cast<result_type*>(a.data());
+    auto* p = reinterpret_cast<result_type*>(a.data());
     while (i--)
         *p++ = g();
 }

include/xrpl/core/HashRouter.h

@@ -127,7 +127,7 @@ private:
         }
 
         [[nodiscard]] HashRouterFlags
-        getFlags(void) const
+        getFlags() const
         {
             return flags_;
         }

include/xrpl/core/JobQueue.h

@@ -154,16 +154,14 @@ public:
 
         @param type The type of job.
         @param name Name of the job.
-        @param jobHandler Lambda with signature void (Job&).  Called when the
-       job is executed.
+        @param jobHandler Callable with signature void(). Called when the job is executed.
 
         @return true if jobHandler added to queue.
     */
-    template <
-        typename JobHandler,
-        typename = std::enable_if_t<std::is_same_v<decltype(std::declval<JobHandler&&>()()), void>>>
+    template <typename JobHandler>
     bool
     addJob(JobType type, std::string const& name, JobHandler&& jobHandler)
+        requires(std::is_void_v<std::invoke_result_t<JobHandler>>)
     {
         if (auto optionalCountedJob = jobCounter_.wrap(std::forward<JobHandler>(jobHandler)))
         {

include/xrpl/core/JobTypes.h

@@ -118,7 +118,7 @@ public:
     [[nodiscard]] JobTypeInfo const&
     get(JobType jt) const
     {
-        Map::const_iterator const iter(map.find(jt));
+        auto const iter = map.find(jt);
         XRPL_ASSERT(iter != map.end(), "xrpl::JobTypes::get : valid input");
 
         if (iter != map.end())

include/xrpl/json/json_reader.h

@@ -154,7 +154,7 @@ private:
         Location end,
         unsigned int& unicode);
     bool
-    addError(std::string const& message, Token& token, Location extra = 0);
+    addError(std::string const& message, Token& token, Location extra = nullptr);
     bool
     recoverFromError(TokenType skipUntilToken);
     bool

include/xrpl/ledger/ApplyView.h

@@ -5,13 +5,12 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/Issue.h>  // IWYU pragma: keep
 #include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/STVector256.h>
 
 #include <cstdint>
@@ -412,12 +411,6 @@ public:
     emptyDirDelete(Keylet const& directory);
 };
 
-struct ApplyViewContext
-{
-    ApplyView& view;
-    STTx const& tx;
-};
-
 namespace directory {
 /** Helper functions for managing low-level directory operations.
     These are not part of the ApplyView interface.

include/xrpl/ledger/CachedView.h

@@ -141,7 +141,7 @@ template <class Base>
 class CachedView : public detail::CachedViewImpl
 {
 private:
-    static_assert(std::is_base_of_v<DigestAwareReadView, Base>, "");
+    static_assert(std::is_base_of_v<DigestAwareReadView, Base>);
 
     std::shared_ptr<Base const> sp_;
 

include/xrpl/ledger/OpenView.h

@@ -82,7 +82,7 @@ private:
     using txs_map = std::map<
         key_type,
         TxData,
-        std::less<key_type>,
+        std::less<>,
         boost::container::pmr::polymorphic_allocator<std::pair<key_type const, TxData>>>;
 
     // monotonic_resource_ must outlive `items_`. Make a pointer so it may be

include/xrpl/ledger/ReadView.h

@@ -7,7 +7,7 @@
 #include <xrpl/ledger/detail/ReadViewFwdRange.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/Issue.h>  // IWYU pragma: keep
 #include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/LedgerHeader.h>
 #include <xrpl/protocol/MPTIssue.h>

include/xrpl/ledger/View.h

@@ -210,7 +210,8 @@ canWithdraw(ReadView const& view, STTx const& tx);
 
 [[nodiscard]] TER
 doWithdraw(
-    ApplyViewContext ctx,
+    ApplyView& view,
+    STTx const& tx,
     AccountID const& senderAcct,
     AccountID const& dstAcct,
     AccountID const& sourceAcct,

include/xrpl/ledger/detail/RawStateTable.h

@@ -105,7 +105,7 @@ private:
     using items_t = std::map<
         key_type,
         SleAction,
-        std::less<key_type>,
+        std::less<>,
         boost::container::pmr::polymorphic_allocator<std::pair<key_type const, SleAction>>>;
     // monotonic_resource_ must outlive `items_`. Make a pointer so it may be
     // easily moved.

include/xrpl/ledger/detail/ReadViewFwdRange.h

@@ -108,8 +108,8 @@ public:
         std::optional<value_type> mutable cache_;
     };
 
-    static_assert(std::is_nothrow_move_constructible<Iterator>{}, "");
-    static_assert(std::is_nothrow_move_assignable<Iterator>{}, "");
+    static_assert(std::is_nothrow_move_constructible<Iterator>{});
+    static_assert(std::is_nothrow_move_assignable<Iterator>{});
 
     using const_iterator = Iterator;
 

include/xrpl/ledger/helpers/AccountRootHelpers.h

@@ -14,7 +14,6 @@
 
 #include <cstdint>
 #include <expected>
-#include <optional>
 #include <set>
 #include <vector>
 
@@ -27,225 +26,21 @@ namespace xrpl {
 [[nodiscard]] bool
 isGlobalFrozen(ReadView const& view, AccountID const& issuer);
 
-/** Calculate liquid XRP balance for an account.
- *
- *  This function may be used to calculate the amount of XRP that
- *  the holder is able to freely spend. It subtracts reserve requirements.
- *
- *  ownerCountAdj adjusts the owner count in case the caller calculates
- *  before ledger entries are added or removed. Positive to add, negative
- *  to subtract.
- *
- *  @param view The ledger view to read from
- *  @param id The account ID to check
- *  @param ownerCountAdj Positive to add to count, negative to reduce count
- *  @param j Journal for logging
- *  @return The liquid XRP amount available to the account
- */
+// Calculate liquid XRP balance for an account.
+// This function may be used to calculate the amount of XRP that
+// the holder is able to freely spend. It subtracts reserve requirements.
+//
+// ownerCountAdj adjusts the owner count in case the caller calculates
+// before ledger entries are added or removed. Positive to add, negative
+// to subtract.
+//
+// @param ownerCountAdj positive to add to count, negative to reduce count.
 [[nodiscard]] XRPAmount
 xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
 
-struct Adjustment
-{
-    std::int32_t ownerCountDelta = 0;
-    std::int32_t accountCountDelta = 0;
-};
-
-/** Returns the account reserve, in drops.
- *
- *  Actual owner count can be adjusted by delta in ownerCountAdj
- *  Actual reserve count can be adjusted by delta in accountCountAdj
- *  The reserve is calculated as:
- *  (ownerCount + "sponsoring object count" - "sponsored object count" + additionalOwnerCount) *
- *  increment + (1 if not sponsored account + sponsoringAccountCount) * "reserve base"
- *
- *  @param view The ledger view to read from
- *  @param sle The ledger entry for the account
- *  @param j Journal for logging
- *  @param ownerCountAdj Adjustment to the owner count (default: 0)
- *  @param accountCountAdj Adjustment to the account count (default: 0)
- *  @return The account reserve amount in drops
- */
-[[nodiscard]] XRPAmount
-accountReserve(ReadView const& view, SLE::const_ref sle, beast::Journal j, Adjustment adj = {});
-
-/** Convenience overload that accepts AccountID instead of SLE.
- *
- *  @param view The ledger view to read from
- *  @param id The account ID
- *  @param j Journal for logging
- *  @param ownerCountAdj Adjustment to the owner count (default: 0)
- *  @param accountCountAdj Adjustment to the account count (default: 0)
- *  @return The account reserve amount in drops
- */
-[[nodiscard]] inline XRPAmount
-accountReserve(ReadView const& view, AccountID const& id, beast::Journal j, Adjustment adj = {})
-{
-    return accountReserve(view, view.read(keylet::account(id)), j, adj);
-}
-
-/** Check if an account has sufficient reserve.
- *
- *  @param view The ledger view to read from
- *  @param tx The transaction being processed
- *  @param accSle The account's ledger entry
- *  @param accBalance The account's balance
- *  @param sponsorSle The sponsor's ledger entry (if applicable)
- *  @param ownerCountAdj Adjustment to the owner count
- *  @param accountCountAdj Adjustment to the account count (default: 0)
- *  @param j Journal for logging (default: null sink)
- *  @return Transaction result code
- */
-[[nodiscard]] TER
-checkReserve(
-    ApplyViewContext ctx,
-    SLE::const_ref accSle,
-    STAmount const& accBalance,
-    SLE::const_ref sponsorSle,
-    Adjustment adj,
-    beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
-
-/** Return number of the objects which reserve is covered by the account(sle) (so called "owner
- *  count"). Actual owner count can be adjusted by delta in ownerCountAdj.
- *
- *  @param sle The account's ledger entry
- *  @param j Journal for logging
- *  @param ownerCountAdj Adjustment to the owner count (default: 0)
- *  @return The adjusted owner count
- */
-std::uint32_t
-ownerCount(SLE::const_ref sle, beast::Journal j, std::int32_t ownerCountAdj = 0);
-
-/** Increase owner-count fields when the caller supplies the sponsor.
- *
- *  This helper does not create a ledger object. It updates reserve accounting
- *  after the caller has created/updated an object.
- *  If sponsorSle is provided, this also adjusts the account's sponsored count
- *  and the sponsor's sponsoring count.
- *
- *  @param view The apply view for making changes
- *  @param accountSle The account's ledger entry
- *  @param sponsorSle The sponsor's ledger entry (if applicable)
- *  @param count Amount to add to the owner count
- *  @param j Journal for logging
- */
+/** Adjust the owner count up or down. */
 void
-increaseOwnerCount(
-    ApplyView& view,
-    SLE::ref accountSle,
-    SLE::ref sponsorSle,
-    std::uint32_t count,
-    beast::Journal j);
-
-/** Convenience overload that accepts AccountID instead of SLE references.
- *
- *  @param view The apply view for making changes
- *  @param account The account ID
- *  @param sponsor The optional sponsor account ID
- *  @param count Amount to add to the owner count
- *  @param j Journal for logging
- */
-inline void
-increaseOwnerCount(
-    ApplyView& view,
-    AccountID const& account,
-    std::optional<AccountID> const& sponsor,
-    std::uint32_t count,
-    beast::Journal j)
-{
-    increaseOwnerCount(
-        view,
-        view.peek(keylet::account(account)),
-        sponsor ? view.peek(keylet::account(*sponsor)) : SLE::pointer(),
-        count,
-        j);
-}
-
-/** Decrease owner-count fields when the caller supplies the sponsor.
- *
- *  This helper does not delete a ledger object. It updates reserve accounting
- *  after the caller has removed an owner-counted reserve, or for special
- *  owner-count changes whose sponsor cannot be derived from an object's
- *  sfSponsor field.
- *
- *  @param view The apply view for making changes
- *  @param accountSle The account's ledger entry
- *  @param sponsorSle The sponsor's ledger entry (if applicable)
- *  @param count Amount to remove from the owner count
- *  @param j Journal for logging
- */
-void
-decreaseOwnerCount(
-    ApplyView& view,
-    SLE::ref accountSle,
-    SLE::ref sponsorSle,
-    std::uint32_t count,
-    beast::Journal j);
-
-/** Convenience overload that accepts AccountID instead of SLE references.
- *
- *  @param view The apply view for making changes
- *  @param account The account ID
- *  @param sponsor The optional sponsor account ID
- *  @param count Amount to remove from the owner count
- *  @param j Journal for logging
- */
-inline void
-decreaseOwnerCount(
-    ApplyView& view,
-    AccountID const& account,
-    std::optional<AccountID> const& sponsor,
-    std::uint32_t count,
-    beast::Journal j)
-{
-    decreaseOwnerCount(
-        view,
-        view.peek(keylet::account(account)),
-        sponsor ? view.peek(keylet::account(*sponsor)) : SLE::pointer(),
-        count,
-        j);
-}
-
-/** Decrease owner-count fields for an existing ledger object.
- *
- *  This helper derives the reserve sponsor from objectSle's sfSponsor field,
- *  then updates the same owner-count fields as decreaseOwnerCount. Use this
- *  when removing an existing object whose reserve sponsor is stored on that
- *  object.
- *
- *  @param view The apply view for making changes
- *  @param accountSle The account's ledger entry
- *  @param objectSle The object's ledger entry
- *  @param count Amount to remove from the owner count
- *  @param j Journal for logging
- */
-void
-decreaseOwnerCountForObject(
-    ApplyView& view,
-    SLE::ref accountSle,
-    SLE::ref objectSle,
-    std::uint32_t count,
-    beast::Journal j);
-
-/** Convenience overload that accepts AccountID instead of account SLE reference.
- *
- *  @param view The apply view for making changes
- *  @param account The account ID
- *  @param objectSle The object's ledger entry
- *  @param count Amount to remove from the owner count
- *  @param j Journal for logging
- */
-inline void
-decreaseOwnerCountForObject(
-    ApplyView& view,
-    AccountID const& account,
-    SLE::ref objectSle,
-    std::uint32_t count,
-    beast::Journal j)
-{
-    SLE::ref accountSle = view.peek(keylet::account(account));
-    decreaseOwnerCountForObject(view, accountSle, objectSle, count, j);
-}
+adjustOwnerCount(ApplyView& view, SLE::ref sle, std::int32_t amount, beast::Journal j);
 
 /** Returns IOU issuer transfer fee as Rate. Rate specifies
  * the fee as fractions of 1 billion. For example, 1% transfer rate
@@ -265,25 +60,25 @@ pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
 /** Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account
     if set.
 
- The list is constructed during initialization and is const after that.
- Pseudo-account designator fields MUST be maintained by including the
- SField::sMD_PseudoAccount flag in the SField definition.
+    The list is constructed during initialization and is const after that.
+    Pseudo-account designator fields MUST be maintained by including the
+    SField::sMD_PseudoAccount flag in the SField definition.
 */
 [[nodiscard]] std::vector<SField const*> const&
 getPseudoAccountFields();
 
-/** Convenience overload that reads the account from the view. */
-[[nodiscard]] bool
-isPseudoAccount(SLE::const_ref sleAcct, std::set<SField const*> const& pseudoFieldFilter = {});
+/** Returns true if and only if sleAcct is a pseudo-account or specific
+    pseudo-accounts in pseudoFieldFilter.
 
-/** Convenience overload that reads the account from the view.
- *
- *  @param view The ledger view to read from
- *  @param accountId The account ID to check
- *  @param pseudoFieldFilter Optional set of specific pseudo-account fields to filter (default:
- * empty)
- *  @return true if the account is a pseudo-account (or matches the filter), false otherwise
- */
+    Returns false if sleAcct is:
+    - NOT a pseudo-account OR
+    - NOT a ltACCOUNT_ROOT OR
+    - null pointer
+*/
+[[nodiscard]] bool
+isPseudoAccount(SLE::const_pointer sleAcct, std::set<SField const*> const& pseudoFieldFilter = {});
+
+/** Convenience overload that reads the account from the view. */
 [[nodiscard]] inline bool
 isPseudoAccount(
     ReadView const& view,
@@ -306,8 +101,8 @@ createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const
 
 /** Checks the destination and tag.
 
-- Checks that the SLE is not null.
-- If the SLE requires a destination tag, checks that there is a tag.
+   - Checks that the SLE is not null.
+   - If the SLE requires a destination tag, checks that there is a tag.
 */
 [[nodiscard]] TER
 checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);

include/xrpl/ledger/helpers/DirectoryHelpers.h

@@ -19,11 +19,7 @@ namespace xrpl {
 
 namespace detail {
 
-template <
-    class V,
-    class N,
-    class = std::enable_if_t<
-        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
+template <class V, class N>
 bool
 internalDirNext(
     V& view,
@@ -31,6 +27,7 @@ internalDirNext(
     std::shared_ptr<N>& page,
     unsigned int& index,
     uint256& entry)
+    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
 {
     auto const& svIndexes = page->getFieldV256(sfIndexes);
     XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
@@ -68,11 +65,7 @@ internalDirNext(
     return true;
 }
 
-template <
-    class V,
-    class N,
-    class = std::enable_if_t<
-        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
+template <class V, class N>
 bool
 internalDirFirst(
     V& view,
@@ -80,6 +73,7 @@ internalDirFirst(
     std::shared_ptr<N>& page,
     unsigned int& index,
     uint256& entry)
+    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
 {
     if constexpr (std::is_const_v<N>)
     {

include/xrpl/ledger/helpers/EscrowHelpers.h

@@ -6,7 +6,6 @@
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/RippleStateHelpers.h>
-#include <xrpl/ledger/helpers/SponsorHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Concepts.h>
@@ -23,12 +22,14 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
 
+#include <cstdint>
+
 namespace xrpl {
 
 template <ValidIssueType T>
 TER
 escrowUnlockApplyHelper(
-    ApplyViewContext ctx,
+    ApplyView& view,
     Rate lockedRate,
     SLE::ref sleDest,
     STAmount const& xrpBalance,
@@ -42,7 +43,7 @@ escrowUnlockApplyHelper(
 template <>
 inline TER
 escrowUnlockApplyHelper<Issue>(
-    ApplyViewContext ctx,
+    ApplyView& view,
     Rate lockedRate,
     SLE::ref sleDest,
     STAmount const& xrpBalance,
@@ -53,7 +54,7 @@ escrowUnlockApplyHelper<Issue>(
     bool createAsset,
     beast::Journal journal)
 {
-    Issue const& issue = amount.get<Issue>();
+    auto const& issue = amount.get<Issue>();
     Keylet const trustLineKey = keylet::trustLine(receiver, issue);
     bool const recvLow = issuer > receiver;
     bool const senderIssuer = issuer == sender;
@@ -65,16 +66,11 @@ escrowUnlockApplyHelper<Issue>(
     if (receiverIssuer)
         return tesSUCCESS;
 
-    if (!ctx.view.exists(trustLineKey) && createAsset)
+    if (!view.exists(trustLineKey) && createAsset)
     {
         // Can the account cover the trust line's reserve?
-        auto const sponsorSle = getTxReserveSponsor(ctx);
-        if (!sponsorSle)
-            return sponsorSle.error();  // LCOV_EXCL_LINE
-
-        if (auto const ret = checkReserve(
-                ctx, sleDest, xrpBalance, *sponsorSle, {.ownerCountDelta = 1}, journal);
-            !isTesSuccess(ret))
+        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
+            xrpBalance < view.fees().accountReserve(ownerCount + 1))
         {
             JLOG(journal.trace()) << "Trust line does not exist. "
                                      "Insufficient reserve to create line.";
@@ -87,7 +83,7 @@ escrowUnlockApplyHelper<Issue>(
         initialBalance.get<Issue>().account = noAccount();
 
         if (TER const ter = trustCreate(
-                ctx.view,                            // payment sandbox
+                view,                                // payment sandbox
                 recvLow,                             // is dest low?
                 issuer,                              // source
                 receiver,                            // destination
@@ -101,20 +97,19 @@ escrowUnlockApplyHelper<Issue>(
                 Issue(currency, receiver),           // limit of zero
                 0,                                   // quality in
                 0,                                   // quality out
-                *sponsorSle,                         // sponsor
                 journal);                            // journal
             !isTesSuccess(ter))
         {
             return ter;  // LCOV_EXCL_LINE
         }
 
-        ctx.view.update(sleDest);
+        view.update(sleDest);
     }
 
-    if (!ctx.view.exists(trustLineKey) && !receiverIssuer)
+    if (!view.exists(trustLineKey) && !receiverIssuer)
         return tecNO_LINE;
 
-    auto const xferRate = transferRate(ctx.view, amount);
+    auto const xferRate = transferRate(view, amount);
     // update if issuer rate is less than locked rate
     if (xferRate < lockedRate)
         lockedRate = xferRate;
@@ -142,7 +137,7 @@ escrowUnlockApplyHelper<Issue>(
     // of the funds
     if (!createAsset)
     {
-        auto const sleRippleState = ctx.view.peek(trustLineKey);
+        auto const sleRippleState = view.peek(trustLineKey);
         if (!sleRippleState)
             return tecINTERNAL;  // LCOV_EXCL_LINE
 
@@ -168,7 +163,7 @@ escrowUnlockApplyHelper<Issue>(
     // if destination is not the issuer then transfer funds
     if (!receiverIssuer)
     {
-        auto const ter = directSendNoFee(ctx.view, issuer, receiver, finalAmt, true, journal);
+        auto const ter = directSendNoFee(view, issuer, receiver, finalAmt, true, journal);
         if (!isTesSuccess(ter))
             return ter;  // LCOV_EXCL_LINE
     }
@@ -178,7 +173,7 @@ escrowUnlockApplyHelper<Issue>(
 template <>
 inline TER
 escrowUnlockApplyHelper<MPTIssue>(
-    ApplyViewContext ctx,
+    ApplyView& view,
     Rate lockedRate,
     SLE::ref sleDest,
     STAmount const& xrpBalance,
@@ -194,34 +189,27 @@ escrowUnlockApplyHelper<MPTIssue>(
 
     auto const mptID = amount.get<MPTIssue>().getMptID();
     auto const issuanceKey = keylet::mptokenIssuance(mptID);
-    auto const mptKeylet = keylet::mptoken(issuanceKey.key, receiver);
-    if (!ctx.view.exists(mptKeylet) && createAsset && !receiverIssuer)
+    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && createAsset && !receiverIssuer)
     {
-        auto const sponsorSle = getTxReserveSponsor(ctx);
-        if (!sponsorSle)
-            return sponsorSle.error();  // LCOV_EXCL_LINE
+        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
+            xrpBalance < view.fees().accountReserve(ownerCount + 1))
+        {
+            return tecINSUFFICIENT_RESERVE;
+        }
 
-        if (auto const ret = checkReserve(
-                ctx, sleDest, xrpBalance, *sponsorSle, {.ownerCountDelta = 1}, journal);
-            !isTesSuccess(ret))
-            return ret;
-
-        if (auto const ter = createMPToken(ctx.view, mptID, receiver, *sponsorSle, 0);
-            !isTesSuccess(ter))
+        if (auto const ter = createMPToken(view, mptID, receiver, 0); !isTesSuccess(ter))
         {
             return ter;  // LCOV_EXCL_LINE
         }
 
         // update owner count.
-        increaseOwnerCount(ctx.view, sleDest, *sponsorSle, 1, journal);
-        auto mptSle = ctx.view.peek(mptKeylet);
-        addSponsorToLedgerEntry(mptSle, *sponsorSle);
+        adjustOwnerCount(view, sleDest, 1, journal);
     }
 
-    if (!ctx.view.exists(mptKeylet) && !receiverIssuer)
+    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && !receiverIssuer)
         return tecNO_PERMISSION;
 
-    auto const xferRate = transferRate(ctx.view, amount);
+    auto const xferRate = transferRate(view, amount);
     // update if issuer rate is less than locked rate
     if (xferRate < lockedRate)
         lockedRate = xferRate;
@@ -244,11 +232,11 @@ escrowUnlockApplyHelper<MPTIssue>(
         finalAmt = amount.value() - xferFee;
     }
     return unlockEscrowMPT(
-        ctx.view,
+        view,
         sender,
         receiver,
         finalAmt,
-        ctx.view.rules().enabled(fixTokenEscrowV1) ? amount : finalAmt,
+        view.rules().enabled(fixTokenEscrowV1) ? amount : finalAmt,
         journal);
 }
 

include/xrpl/ledger/helpers/LendingHelpers.h

@@ -8,7 +8,7 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>

include/xrpl/ledger/helpers/MPTokenHelpers.h

@@ -86,7 +86,7 @@ canAddHolding(ReadView const& view, MPTIssue const& mptIssue);
 
 [[nodiscard]] TER
 authorizeMPToken(
-    ApplyViewContext ctx,
+    ApplyView& view,
     XRPAmount const& priorBalance,
     MPTID const& mptIssuanceID,
     AccountID const& account,
@@ -117,7 +117,7 @@ requireAuth(
  */
 [[nodiscard]] TER
 enforceMPTokenAuthorization(
-    ApplyViewContext ctx,
+    ApplyView& view,
     MPTID const& mptIssuanceID,
     AccountID const& account,
     XRPAmount const& priorBalance,
@@ -203,7 +203,7 @@ canMPTTradeAndTransfer(
 
 [[nodiscard]] TER
 addEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     XRPAmount priorBalance,
     MPTIssue const& mptIssue,
@@ -211,7 +211,7 @@ addEmptyHolding(
 
 [[nodiscard]] TER
 removeEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     MPTIssue const& mptIssue,
     beast::Journal journal);
@@ -243,7 +243,6 @@ createMPToken(
     ApplyView& view,
     MPTID const& mptIssuanceID,
     AccountID const& account,
-    SLE::ref sponsorSle,
     std::uint32_t const flags);
 
 TER
@@ -251,7 +250,6 @@ checkCreateMPT(
     xrpl::ApplyView& view,
     xrpl::MPTIssue const& mptIssue,
     xrpl::AccountID const& holder,
-    SLE::ref sponsorSle,
     beast::Journal j);
 
 //------------------------------------------------------------------------------

include/xrpl/ledger/helpers/OracleHelpers.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace xrpl {
-
-constexpr uint32_t kMinOracleReserveCount = 1;
-constexpr uint32_t kMaxOracleReserveCount = 2;
-constexpr std::size_t kOracleReserveCountThreshold = 5;
-
-inline uint32_t
-calculateOracleReserve(std::size_t priceDataSeriesCount)
-{
-    return priceDataSeriesCount > kOracleReserveCountThreshold ? kMaxOracleReserveCount
-                                                               : kMinOracleReserveCount;
-}
-
-}  // namespace xrpl

include/xrpl/ledger/helpers/RippleStateHelpers.h

@@ -156,7 +156,6 @@ trustCreate(
                                 // Issuer should be the account being set.
     std::uint32_t uQualityIn,
     std::uint32_t uQualityOut,
-    SLE::ref sponsorSle,
     beast::Journal j);
 
 [[nodiscard]] TER
@@ -236,7 +235,7 @@ canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, Acc
 /// canAddHolding() in preflight with the same View and Asset
 [[nodiscard]] TER
 addEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     XRPAmount priorBalance,
     Issue const& issue,
@@ -244,7 +243,7 @@ addEmptyHolding(
 
 [[nodiscard]] TER
 removeEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     Issue const& issue,
     beast::Journal journal);

include/xrpl/ledger/helpers/SponsorHelpers.h

@@ -1,193 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/ledger/helpers/OracleHelpers.h>
-#include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-
-#include <cstdint>
-#include <expected>
-#include <optional>
-
-namespace xrpl {
-
-inline bool
-isFeeSponsored(STTx const& tx)
-{
-    return (tx.getFieldU32(sfSponsorFlags) & spfSponsorFee) != 0u;
-}
-
-inline bool
-isReserveSponsored(STTx const& tx)
-{
-    return (tx.getFieldU32(sfSponsorFlags) & spfSponsorReserve) != 0u;
-}
-
-std::optional<AccountID>
-getTxReserveSponsorAccountID(STTx const& tx);
-
-std::expected<SLE::pointer, TER>
-getTxReserveSponsor(ApplyViewContext ctx);
-
-std::expected<SLE::const_pointer, TER>
-getTxReserveSponsor(ReadView const& view, STTx const& tx);
-
-std::optional<AccountID>
-getLedgerEntryReserveSponsorAccountID(SLE::const_ref sle, SF_ACCOUNT const& field = sfSponsor);
-
-SLE::pointer
-getLedgerEntryReserveSponsor(
-    ApplyView& view,
-    SLE::const_ref sle,
-    SF_ACCOUNT const& field = sfSponsor);
-
-SLE::const_pointer
-getLedgerEntryReserveSponsor(
-    ReadView const& view,
-    SLE::const_ref sle,
-    SF_ACCOUNT const& field = sfSponsor);
-
-void
-addSponsorToLedgerEntry(
-    SLE::ref sle,
-    SLE::const_ref sponsorSle,
-    SF_ACCOUNT const& field = sfSponsor);
-
-void
-removeSponsorFromLedgerEntry(SLE::ref sle, SF_ACCOUNT const& field = sfSponsor);
-
-template <typename T>
-inline std::optional<AccountID>
-getLedgerEntryOwner(ReadView const& view, T const& sle, AccountID const& account)
-{
-    switch (sle->getType())
-    {
-        case ltCHECK:
-        case ltESCROW:
-        case ltPAYCHAN:
-        case ltMPTOKEN:
-        case ltDELEGATE:
-        case ltDEPOSIT_PREAUTH:
-            return sle->getAccountID(sfAccount);
-        case ltMPTOKEN_ISSUANCE:
-            return sle->getAccountID(sfIssuer);
-        case ltSIGNER_LIST: {
-            auto const signerList = view.read(keylet::signerList(account));
-            if (!signerList)
-                return std::nullopt;
-            if (signerList->key() == sle->key())
-                return account;
-            return std::nullopt;
-        }
-        case ltCREDENTIAL: {
-            if (sle->isFlag(lsfAccepted))
-                return sle->getAccountID(sfSubject);
-            return sle->getAccountID(sfIssuer);
-        }
-        case ltRIPPLE_STATE: {
-            if (sle->isFlag(lsfHighReserve))
-            {
-                auto const highAccount = sle->getFieldAmount(sfHighLimit).getIssuer();
-                if (highAccount == account)
-                    return highAccount;
-            }
-            if (sle->isFlag(lsfLowReserve))
-            {
-                auto const lowAccount = sle->getFieldAmount(sfLowLimit).getIssuer();
-                if (lowAccount == account)
-                    return lowAccount;
-            }
-            return std::nullopt;
-        }
-        default:
-            UNREACHABLE("Object is not supported by sponsorship.");
-            return std::nullopt;
-    };
-}
-
-template <typename T>
-inline bool
-isLedgerEntrySupportedBySponsorship(T const& sle)
-{
-    switch (sle->getType())
-    {
-        case ltCHECK:
-        case ltESCROW:
-        case ltPAYCHAN:
-        case ltMPTOKEN:
-        case ltDELEGATE:
-        case ltDEPOSIT_PREAUTH:
-        case ltMPTOKEN_ISSUANCE:
-        case ltSIGNER_LIST:
-        case ltCREDENTIAL:
-        case ltRIPPLE_STATE:
-            return true;
-        default:
-            return false;
-    };
-}
-
-template <typename T>
-inline std::uint32_t
-getLedgerEntryOwnerCount(T const& sle)
-{
-    switch (sle->getType())
-    {
-        case ltORACLE: {
-            return calculateOracleReserve(sle->getFieldArray(sfPriceDataSeries).size());
-        }
-        // Vaults require 2 owner counts (the vault and a pseudo-account)
-        case ltVAULT:
-            return 2;
-        case ltSIGNER_LIST: {
-            // Mirror SignerListSet's owner-count accounting so that create and
-            // delete agree. Modern lists (post-MultiSignReserve) carry the
-            // lsfOneOwnerCount flag and cost a single owner count. Legacy
-            // pre-MultiSignReserve lists cost 2 + signer_count owner counts
-            if (sle->isFlag(lsfOneOwnerCount))
-                return 1;
-            return 2 + static_cast<std::uint32_t>(sle->getFieldArray(sfSignerEntries).size());
-        }
-        default:
-            return 1;
-    }
-};
-
-template <typename T>
-inline SF_ACCOUNT const&
-getLedgerEntrySponsorField(T const& sle, AccountID const& owner)
-{
-    switch (sle->getType())
-    {
-        case ltRIPPLE_STATE: {
-            if (sle->isFlag(lsfHighReserve))
-            {
-                auto const highAccount = sle->getFieldAmount(sfHighLimit).getIssuer();
-                if (highAccount == owner)
-                    return sfHighSponsor;
-            }
-            if (sle->isFlag(lsfLowReserve))
-            {
-                auto const lowAccount = sle->getFieldAmount(sfLowLimit).getIssuer();
-                if (lowAccount == owner)
-                    return sfLowSponsor;
-            }
-            // LCOV_EXCL_START
-            UNREACHABLE("Should not happen. Owner should be checked before calling this function.");
-            return sfSponsor;
-            // LCOV_EXCL_STOP
-        }
-        default:
-            return sfSponsor;
-    }
-};
-
-}  // namespace xrpl

include/xrpl/ledger/helpers/TokenHelpers.h

@@ -10,7 +10,6 @@
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/Rate.h>
 #include <xrpl/protocol/STAmount.h>
-#include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
 #include <xrpl/protocol/XRPAmount.h>
@@ -303,7 +302,7 @@ canAddHolding(ReadView const& view, Asset const& asset);
 
 [[nodiscard]] TER
 addEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     XRPAmount priorBalance,
     Asset const& asset,
@@ -311,7 +310,7 @@ addEmptyHolding(
 
 [[nodiscard]] TER
 removeEmptyHolding(
-    ApplyViewContext ctx,
+    ApplyView& view,
     AccountID const& accountID,
     Asset const& asset,
     beast::Journal journal);
@@ -372,7 +371,6 @@ accountSend(
     AccountID const& to,
     STAmount const& saAmount,
     beast::Journal j,
-    SLE::ref sponsorSle = {},
     WaiveTransferFee waiveFee = WaiveTransferFee::No,
     AllowMPTOverflow allowOverflow = AllowMPTOverflow::No);
 
@@ -390,7 +388,6 @@ accountSendMulti(
     Asset const& asset,
     MultiplePaymentDestinations const& receivers,
     beast::Journal j,
-    SLE::ref sponsorSle,
     WaiveTransferFee waiveFee = WaiveTransferFee::No);
 
 [[nodiscard]] TER

include/xrpl/net/AutoSocket.h

@@ -120,12 +120,9 @@ public:
             socket_->next_layer().async_receive(
                 boost::asio::buffer(buffer_),
                 boost::asio::socket_base::message_peek,
-                std::bind(
-                    &AutoSocket::handleAutodetect,
-                    this,
-                    cbFunc,
-                    std::placeholders::_1,
-                    std::placeholders::_2));
+                [this, cbFunc](error_code const& ec, size_t bytesTransferred) {
+                    handleAutodetect(cbFunc, ec, bytesTransferred);
+                });
         }
     }
 

include/xrpl/net/HTTPClientSSLContext.h

@@ -13,7 +13,6 @@
 #include <openssl/err.h>
 #include <openssl/tls1.h>
 
-#include <functional>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
@@ -84,13 +83,12 @@ public:
      *
      * @return error_code indicating failures, if any
      */
-    template <
-        class T,
-        class = std::enable_if_t<
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
+    template <class T>
     boost::system::error_code
     preConnectVerify(T& strm, std::string const& host)
+        requires(
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>)
     {
         boost::system::error_code ec;
         if (!SSL_set_tlsext_host_name(strm.native_handle(), host.c_str()))
@@ -104,11 +102,7 @@ public:
         return ec;
     }
 
-    template <
-        class T,
-        class = std::enable_if_t<
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
+    template <class T>
     /**
      * @brief invoked after connect/async_connect but before sending data
      * on an ssl stream - to setup name verification.
@@ -118,6 +112,9 @@ public:
      */
     boost::system::error_code
     postConnectVerify(T& strm, std::string const& host)
+        requires(
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>)
     {
         boost::system::error_code ec;
 
@@ -127,8 +124,9 @@ public:
             if (!ec)
             {
                 strm.set_verify_callback(
-                    std::bind(
-                        &rfc6125Verify, host, std::placeholders::_1, std::placeholders::_2, j_),
+                    [host, j = j_](bool preverified, boost::asio::ssl::verify_context& ctx) {
+                        return rfc6125Verify(host, preverified, ctx, j);
+                    },
                     ec);
             }
         }

include/xrpl/nodestore/detail/codec.h

@@ -62,7 +62,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     std::array<std::uint8_t, varint_traits<std::size_t>::kMax> vi{};
     auto const n = writeVarint(vi.data(), inSize);
     auto const outMax = LZ4_compressBound(inSize);
-    std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
+    auto* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
     result.first = out;
     std::memcpy(out, vi.data(), n);
     auto const outSize = LZ4_compress_default(
@@ -90,7 +90,7 @@ nodeobjectDecompress(void const* in, std::size_t inSize, BufferFactory&& bf)
 {
     using namespace nudb::detail;
 
-    std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(in);
+    auto const* p = reinterpret_cast<std::uint8_t const*>(in);
     std::size_t type = 0;
     auto const vn = readVarint(p, inSize, type);
     if (vn == 0)
@@ -237,7 +237,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
                 auto const vs = sizeVarint(type);
                 result.second = vs + field<std::uint16_t>::size +  // mask
                     (n * 32);                                      // hashes
-                std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
+                auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
                 result.first = out;
                 ostream os(out, result.second);
                 write<varint>(os, type);
@@ -249,7 +249,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
             auto const type = 3U;
             auto const vs = sizeVarint(type);
             result.second = vs + (n * 32);  // hashes
-            std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
+            auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
             result.first = out;
             ostream os(out, result.second);
             write<varint>(os, type);

include/xrpl/nodestore/detail/varint.h

@@ -39,7 +39,7 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
     if (buflen == 0)
         return 0;
     t = 0;
-    std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(buf);
+    auto const* p = reinterpret_cast<std::uint8_t const*>(buf);
     std::size_t n = 0;
     while (p[n] & 0x80)
     {
@@ -68,9 +68,10 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
     return used;
 }
 
-template <class T, std::enable_if_t<std::is_unsigned_v<T>>* = nullptr>
+template <class T>
 std::size_t
 sizeVarint(T v)
+    requires(std::is_unsigned_v<T>)
 {
     std::size_t n = 0;
     do
@@ -86,7 +87,7 @@ std::size_t
 writeVarint(void* p0, std::size_t v)
 {
     // NOLINTNEXTLINE(misc-const-correctness)
-    std::uint8_t* p = reinterpret_cast<std::uint8_t*>(p0);
+    auto* p = reinterpret_cast<std::uint8_t*>(p0);
     do
     {
         std::uint8_t d = v % 127;
@@ -100,9 +101,10 @@ writeVarint(void* p0, std::size_t v)
 
 // input stream
 
-template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
+template <class T>
 void
 read(nudb::detail::istream& is, std::size_t& u)
+    requires(std::is_same_v<T, varint>)
 {
     auto p0 = is(1);
     auto p1 = p0;
@@ -113,9 +115,10 @@ read(nudb::detail::istream& is, std::size_t& u)
 
 // output stream
 
-template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
+template <class T>
 void
 write(nudb::detail::ostream& os, std::size_t t)
+    requires(std::is_same_v<T, varint>)
 {
     writeVarint(os.data(sizeVarint(t)), t);
 }

include/xrpl/proto/xrpl.proto

@@ -246,7 +246,15 @@ message TMGetObjectByHash {
 
 message TMLedgerNode {
   required bytes nodedata = 1;
-  optional bytes nodeid = 2;  // missing for ledger base data
+
+  // Used when protocol version <2.3. Not set for ledger base data.
+  optional bytes nodeid = 2;
+
+  // Used when protocol version >=2.3. Neither value is set for ledger base data.
+  oneof reference {
+    bytes id = 3;      // Set for inner nodes.
+    uint32 depth = 4;  // Set for leaf nodes.
+  }
 }
 
 enum TMLedgerInfoType {

include/xrpl/protocol/AmountConversions.h

@@ -13,7 +13,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 
 #include <cstdint>
-#include <limits>
+#include <limits>  // IWYU pragma: keep
 #include <stdexcept>
 #include <type_traits>
 

include/xrpl/protocol/Fees.h

@@ -2,6 +2,7 @@
 
 #include <xrpl/protocol/XRPAmount.h>
 
+#include <cstddef>
 #include <cstdint>
 
 namespace xrpl {
@@ -38,13 +39,13 @@ struct Fees
 
     /** Returns the account reserve given the owner count, in drops.
 
-        The reserve is calculated as the reserve base times the number of accounts plus the reserve
-        increment times the number of increments.
+        The reserve is calculated as the reserve base plus
+        the reserve increment times the number of increments.
     */
     [[nodiscard]] XRPAmount
-    accountReserve(std::uint32_t ownerCount, std::uint32_t accountCount) const
+    accountReserve(std::size_t ownerCount) const
     {
-        return (reserve * accountCount) + (increment * ownerCount);
+        return reserve + ownerCount * increment;
     }
 };
 

include/xrpl/protocol/Indexes.h

@@ -142,10 +142,6 @@ ticket(uint256 const& key)
 Keylet
 signerList(AccountID const& account) noexcept;
 
-/** A Sponsorship */
-Keylet
-sponsorship(AccountID const& sponsor, AccountID const& sponsee) noexcept;
-
 /** A Check */
 /** @{ */
 Keylet

include/xrpl/protocol/LedgerFormats.h

@@ -208,11 +208,7 @@ enum LedgerEntryType : std::uint16_t {
     LEDGER_OBJECT(Loan,                                                                                                            \
         LSF_FLAG(lsfLoanDefault, 0x00010000)                                                                                       \
         LSF_FLAG(lsfLoanImpaired, 0x00020000)                                                                                      \
-        LSF_FLAG(lsfLoanOverpayment, 0x00040000))               /* True, loan allows overpayments */                               \
-                                                                                                                                   \
-    LEDGER_OBJECT(Sponsorship,                                                                                                     \
-        LSF_FLAG(lsfSponsorshipRequireSignForFee, 0x00010000)                                                                      \
-        LSF_FLAG(lsfSponsorshipRequireSignForReserve, 0x00020000))
+        LSF_FLAG(lsfLoanOverpayment, 0x00040000))               /* True, loan allows overpayments */
 
 // clang-format on
 

include/xrpl/protocol/Quality.h

@@ -282,7 +282,7 @@ public:
         auto const maxVMantissa = mantissa(maxV);
         auto const expDiff = exponent(maxV) - exponent(minV);
 
-        double const minVD = static_cast<double>(minVMantissa);
+        auto const minVD = static_cast<double>(minVMantissa);
         double const maxVD =
             (expDiff != 0) ? maxVMantissa * pow(10, expDiff) : static_cast<double>(maxVMantissa);
 

include/xrpl/protocol/STArray.h

@@ -32,17 +32,13 @@ public:
     STArray() = default;
     STArray(STArray const&) = default;
 
-    template <
-        class Iter,
-        class = std::enable_if_t<
-            std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
-    explicit STArray(Iter first, Iter last);
+    template <class Iter>
+    explicit STArray(Iter first, Iter last)
+        requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
 
-    template <
-        class Iter,
-        class = std::enable_if_t<
-            std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
-    STArray(SField const& f, Iter first, Iter last);
+    template <class Iter>
+    STArray(SField const& f, Iter first, Iter last)
+        requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
 
     STArray&
     operator=(STArray const&) = default;
@@ -170,13 +166,17 @@ private:
     friend class detail::STVar;
 };
 
-template <class Iter, class>
-STArray::STArray(Iter first, Iter last) : v_(first, last)
+template <class Iter>
+STArray::STArray(Iter first, Iter last)
+    requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
+    : v_(first, last)
 {
 }
 
-template <class Iter, class>
-STArray::STArray(SField const& f, Iter first, Iter last) : STBase(f), v_(first, last)
+template <class Iter>
+STArray::STArray(SField const& f, Iter first, Iter last)
+    requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
+    : STBase(f), v_(first, last)
 {
 }
 

include/xrpl/protocol/STBitString.h

@@ -148,7 +148,7 @@ template <int Bits>
 bool
 STBitString<Bits>::isEquivalent(STBase const& t) const
 {
-    STBitString const* v = dynamic_cast<STBitString const*>(&t);
+    auto const* v = dynamic_cast<STBitString const*>(&t);
     return v && (value_ == v->value_);
 }
 

include/xrpl/protocol/STInteger.h

@@ -115,7 +115,7 @@ template <typename Integer>
 inline bool
 STInteger<Integer>::isEquivalent(STBase const& t) const
 {
-    STInteger const* v = dynamic_cast<STInteger const*>(&t);
+    auto const* v = dynamic_cast<STInteger const*>(&t);
     return v && (value_ == v->value_);
 }
 

include/xrpl/protocol/STObject.h

@@ -229,10 +229,10 @@ public:
     [[nodiscard]] AccountID
     getAccountID(SField const& field) const;
 
-    /** The account responsible for the authorization: the delegate when
+    /** The account responsible for the fee and authorization: the delegate when
         sfDelegate is present, otherwise the account. */
     [[nodiscard]] AccountID
-    getInitiator() const;
+    getFeePayer() const;
 
     [[nodiscard]] Blob
     getFieldVL(SField const& field) const;
@@ -555,9 +555,14 @@ public:
     ValueProxy&
     operator=(ValueProxy const&) = delete;
 
+    // Write-through proxy: assignment sets the referenced field to the given
+    // value, so it intentionally takes the assigned value rather than a
+    // ValueProxy.
     template <class U>
-    std::enable_if_t<std::is_assignable_v<T, U>, ValueProxy&>
-    operator=(U&& u);
+    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
+    ValueProxy&
+    operator=(U&& u)
+        requires(std::is_assignable_v<T, U>);
 
     // Convenience operators for value types supporting
     // arithmetic operations
@@ -691,8 +696,9 @@ public:
     operator=(optional_type const& v);
 
     template <class U>
-    std::enable_if_t<std::is_assignable_v<T, U>, OptionalProxy&>
-    operator=(U&& u);
+    OptionalProxy&
+    operator=(U&& u)
+        requires(std::is_assignable_v<T, U>);
 
 private:
     friend class STObject;
@@ -798,8 +804,10 @@ STObject::Proxy<T>::assign(U&& u)
 
 template <class T>
 template <class U>
-std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T>&>
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
+STObject::ValueProxy<T>&
 STObject::ValueProxy<T>::operator=(U&& u)
+    requires(std::is_assignable_v<T, U>)
 {
     this->assign(std::forward<U>(u));
     return *this;
@@ -902,8 +910,9 @@ STObject::OptionalProxy<T>::operator=(optional_type const& v) -> OptionalProxy&
 
 template <class T>
 template <class U>
-std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T>&>
+STObject::OptionalProxy<T>&
 STObject::OptionalProxy<T>::operator=(U&& u)
+    requires(std::is_assignable_v<T, U>)
 {
     this->assign(std::forward<U>(u));
     return *this;
@@ -1241,7 +1250,7 @@ template <typename T, typename V>
 void
 STObject::setFieldUsingSetValue(SField const& field, V value)
 {
-    static_assert(!std::is_lvalue_reference_v<V>, "");
+    static_assert(!std::is_lvalue_reference_v<V>);
 
     STBase* rf = getPField(field, true);
 

include/xrpl/protocol/STTx.h

@@ -141,9 +141,6 @@ public:
     [[nodiscard]] std::vector<uint256> const&
     getBatchTransactionIDs() const;
 
-    [[nodiscard]] AccountID
-    getFeePayerID() const;
-
 private:
     /** Check the signature.
         @param rules The current ledger rules.

include/xrpl/protocol/Serializer.h

@@ -334,7 +334,7 @@ public:
     template <int N>
     explicit SerialIter(std::uint8_t const (&data)[N]) : SerialIter(&data[0], N)
     {
-        static_assert(N > 0, "");
+        static_assert(N > 0);
     }
 
     [[nodiscard]] bool

include/xrpl/protocol/TER.h

@@ -225,7 +225,6 @@ enum TERcodes : TERUnderlyingType {
                                 // create a pseudo-account
     terNO_DELEGATE_PERMISSION,  // Delegate does not have permission
     terLOCKED,                  // MPT is locked
-    terNO_SPONSORSHIP,          // No sponsorship found
 };
 
 //------------------------------------------------------------------------------
@@ -369,7 +368,6 @@ enum TECcodes : TERUnderlyingType {
     // reclaimed after those networks reset.
     tecNO_DELEGATE_PERMISSION = 198,
     tecBAD_PROOF = 199,
-    tecNO_SPONSOR_PERMISSION = 200,
 };
 
 //------------------------------------------------------------------------------
@@ -413,7 +411,7 @@ TERtoInt(TECcodes v)
 
 //------------------------------------------------------------------------------
 // Template class that is specific to selected ranges of error codes.  The
-// Trait tells std::enable_if which ranges are allowed.
+// Trait tells the requires-clause which ranges are allowed.
 template <template <typename> class Trait>
 class TERSubset
 {
@@ -439,11 +437,11 @@ public:
         return TERSubset(from);
     }
 
-    // Trait tells enable_if which types are allowed for construction.
-    template <
-        typename T,
-        typename = std::enable_if_t<Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value>>
-    constexpr TERSubset(T rhs) : code_(TERtoInt(rhs))
+    // Trait tells the requires-clause which types are allowed for construction.
+    template <typename T>
+    constexpr TERSubset(T rhs)
+        requires(Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value)
+        : code_(TERtoInt(rhs))
     {
     }
 
@@ -453,10 +451,11 @@ public:
     constexpr TERSubset&
     operator=(TERSubset&& rhs) = default;
 
-    // Trait tells enable_if which types are allowed for assignment.
+    // Trait tells the requires-clause which types are allowed for assignment.
     template <typename T>
     constexpr auto
-    operator=(T rhs) -> std::enable_if_t<Trait<T>::value, TERSubset&>
+    operator=(T rhs) -> TERSubset&
+        requires(Trait<T>::value)
     {
         code_ = TERtoInt(rhs);
         return *this;
@@ -510,54 +509,60 @@ public:
 // Only enabled if both arguments return int if TERtiInt is called with them.
 template <typename L, typename R>
 constexpr auto
-operator==(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator==(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) == TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator!=(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator!=(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) != TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator<(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator<(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) < TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator<=(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator<=(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) <= TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator>(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator>(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) > TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator>=(L const& lhs, R const& rhs) -> std::enable_if_t<
-    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
-    bool>
+operator>=(L const& lhs, R const& rhs) -> bool
+    requires(
+        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
+        std::is_same_v<decltype(TERtoInt(rhs)), int>)
 {
     return TERtoInt(lhs) >= TERtoInt(rhs);
 }

include/xrpl/protocol/TxFlags.h

@@ -102,8 +102,7 @@ inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
     TRANSACTION(Payment,                                                                                                                                       \
         TF_FLAG(tfNoRippleDirect, 0x00010000)                                                                                                                  \
         TF_FLAG(tfPartialPayment, 0x00020000)                                                                                                                  \
-        TF_FLAG(tfLimitQuality, 0x00040000)                                                                                                                    \
-        TF_FLAG(tfSponsorCreatedAccount, 0x00080000),                                                                                                          \
+        TF_FLAG(tfLimitQuality, 0x00040000),                                                                                                                   \
         MASK_ADJ(0))                                                                                                                                           \
                                                                                                                                                                \
     TRANSACTION(TrustSet,                                                                                                                                      \
@@ -216,20 +215,6 @@ inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
         TF_FLAG(tfLoanDefault, 0x00010000)                                                                                                                     \
         TF_FLAG(tfLoanImpair, 0x00020000)                                                                                                                      \
         TF_FLAG(tfLoanUnimpair, 0x00040000),                                                                                                                   \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(SponsorshipSet,                                                                                                                                \
-        TF_FLAG(tfSponsorshipSetRequireSignForFee, 0x00010000)                                                                                                 \
-        TF_FLAG(tfSponsorshipClearRequireSignForFee, 0x00020000)                                                                                               \
-        TF_FLAG(tfSponsorshipSetRequireSignForReserve, 0x00040000)                                                                                             \
-        TF_FLAG(tfSponsorshipClearRequireSignForReserve, 0x00080000)                                                                                          \
-        TF_FLAG(tfDeleteObject, 0x00100000),                                                                                                                   \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(SponsorshipTransfer,                                                                                                                           \
-        TF_FLAG(tfSponsorshipEnd, 0x00000001)                                                                                                                  \
-        TF_FLAG(tfSponsorshipCreate, 0x00000002)                                                                                                               \
-        TF_FLAG(tfSponsorshipReassign, 0x00000004),                                                                                                            \
         MASK_ADJ(0))
 
 // clang-format on
@@ -459,12 +444,6 @@ getAsfFlagMap()
 #pragma pop_macro("ACCOUNTSET_FLAG_TO_MAP")
 #pragma pop_macro("ACCOUNTSET_FLAGS")
 
-// Sponsor flags (spf)
-
-inline constexpr FlagValue spfSponsorFee = 1;
-inline constexpr FlagValue spfSponsorReserve = 2;
-inline constexpr FlagValue spfSponsorFlagMask = ~(spfSponsorFee | spfSponsorReserve);
-
 }  // namespace xrpl
 
 // NOLINTEND(readability-identifier-naming)

include/xrpl/protocol/detail/features.macro

@@ -15,10 +15,9 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
-XRPL_FEATURE(Sponsor,                     Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(BatchV1_1,                   Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(BatchV1_1,                   Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocolV1_1,         Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(ConfidentialTransfer,        Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(ConfidentialTransfer,        Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_3_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_2_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV2,                  Supported::No,  VoteBehavior::DefaultNo)
@@ -61,7 +60,6 @@ XRPL_FEATURE(PriceOracle,                Supported::Yes, VoteBehavior::DefaultNo
 XRPL_FIX    (AMMOverflowOffer,           Supported::Yes, VoteBehavior::DefaultYes)
 XRPL_FIX    (FillOrKill,                 Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DID,                        Supported::Yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (DisallowIncomingV1,         Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(XChainBridge,               Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(AMM,                        Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(XRPFees,                    Supported::Yes, VoteBehavior::DefaultNo)
@@ -101,6 +99,7 @@ XRPL_RETIRE_FIX(1623)
 XRPL_RETIRE_FIX(1781)
 XRPL_RETIRE_FIX(AmendmentMajorityCalc)
 XRPL_RETIRE_FIX(CheckThreading)
+XRPL_RETIRE_FIX(DisallowIncomingV1)
 XRPL_RETIRE_FIX(InnerObjTemplate)
 XRPL_RETIRE_FIX(MasterKeyAsRegularKey)
 XRPL_RETIRE_FIX(NonFungibleTokensV1_2)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -127,32 +127,29 @@ LEDGER_ENTRY(ltTICKET, 0x0054, Ticket, ticket, ({
     \sa keylet::account
  */
 LEDGER_ENTRY(ltACCOUNT_ROOT, 0x0061, AccountRoot, account, ({
-    {sfAccount,                SoeRequired},
-    {sfSequence,               SoeRequired},
-    {sfBalance,                SoeRequired},
-    {sfOwnerCount,             SoeRequired},
-    {sfPreviousTxnID,          SoeRequired},
-    {sfPreviousTxnLgrSeq,      SoeRequired},
-    {sfAccountTxnID,           SoeOptional},
-    {sfRegularKey,             SoeOptional},
-    {sfEmailHash,              SoeOptional},
-    {sfWalletLocator,          SoeOptional},
-    {sfWalletSize,             SoeOptional},
-    {sfMessageKey,             SoeOptional},
-    {sfTransferRate,           SoeOptional},
-    {sfDomain,                 SoeOptional},
-    {sfTickSize,               SoeOptional},
-    {sfTicketCount,            SoeOptional},
-    {sfNFTokenMinter,          SoeOptional},
-    {sfMintedNFTokens,         SoeDefault},
-    {sfBurnedNFTokens,         SoeDefault},
-    {sfFirstNFTokenSequence,   SoeOptional},
-    {sfSponsoredOwnerCount,    SoeDefault},
-    {sfSponsoringOwnerCount,   SoeDefault},
-    {sfSponsoringAccountCount, SoeDefault},
-    {sfAMMID,                  SoeOptional}, // pseudo-account designator
-    {sfVaultID,                SoeOptional}, // pseudo-account designator
-    {sfLoanBrokerID,           SoeOptional}, // pseudo-account designator
+    {sfAccount,              SoeRequired},
+    {sfSequence,             SoeRequired},
+    {sfBalance,              SoeRequired},
+    {sfOwnerCount,           SoeRequired},
+    {sfPreviousTxnID,        SoeRequired},
+    {sfPreviousTxnLgrSeq,    SoeRequired},
+    {sfAccountTxnID,         SoeOptional},
+    {sfRegularKey,           SoeOptional},
+    {sfEmailHash,            SoeOptional},
+    {sfWalletLocator,        SoeOptional},
+    {sfWalletSize,           SoeOptional},
+    {sfMessageKey,           SoeOptional},
+    {sfTransferRate,         SoeOptional},
+    {sfDomain,               SoeOptional},
+    {sfTickSize,             SoeOptional},
+    {sfTicketCount,          SoeOptional},
+    {sfNFTokenMinter,        SoeOptional},
+    {sfMintedNFTokens,       SoeDefault},
+    {sfBurnedNFTokens,       SoeDefault},
+    {sfFirstNFTokenSequence, SoeOptional},
+    {sfAMMID,                SoeOptional}, // pseudo-account designator
+    {sfVaultID,              SoeOptional}, // pseudo-account designator
+    {sfLoanBrokerID,         SoeOptional}, // pseudo-account designator
 }))
 
 /** A ledger object which contains a list of object identifiers.
@@ -289,8 +286,6 @@ LEDGER_ENTRY(ltRIPPLE_STATE, 0x0072, RippleState, state, ({
     {sfHighNode,             SoeOptional},
     {sfHighQualityIn,        SoeOptional},
     {sfHighQualityOut,       SoeOptional},
-    {sfHighSponsor,          SoeOptional},
-    {sfLowSponsor,           SoeOptional},
 }))
 
 /** The ledger object which lists the network's fee settings.
@@ -621,20 +616,5 @@ LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({
     {sfLoanScale,                SoeDefault},
 }))
 
-/** A ledger object representing a sponsorship.
-    \sa keylet::sponsorship
- */
-LEDGER_ENTRY(ltSPONSORSHIP, 0x0090, Sponsorship, sponsorship, ({
-    {sfPreviousTxnID,        SoeRequired},
-    {sfPreviousTxnLgrSeq,    SoeRequired},
-    {sfOwner,                SoeRequired},
-    {sfSponsee,              SoeRequired},
-    {sfFeeAmount,            SoeOptional},
-    {sfMaxFee,               SoeOptional},
-    {sfRemainingOwnerCount,  SoeDefault},
-    {sfOwnerNode,            SoeRequired},
-    {sfSponseeNode,          SoeRequired},
-}))
-
 #undef EXPAND
 #undef LEDGER_ENTRY_DUPLICATE

include/xrpl/protocol/detail/sfields.macro

@@ -114,11 +114,6 @@ TYPED_SFIELD(sfLateInterestRate,         UINT32,    66) // 1/10 basis points (bi
 TYPED_SFIELD(sfCloseInterestRate,        UINT32,    67) // 1/10 basis points (bips)
 TYPED_SFIELD(sfOverpaymentInterestRate,  UINT32,    68) // 1/10 basis points (bips)
 TYPED_SFIELD(sfConfidentialBalanceVersion, UINT32,  69)
-TYPED_SFIELD(sfSponsoredOwnerCount,      UINT32,    70)
-TYPED_SFIELD(sfSponsoringOwnerCount,     UINT32,    71)
-TYPED_SFIELD(sfSponsoringAccountCount,   UINT32,    72)
-TYPED_SFIELD(sfRemainingOwnerCount,      UINT32,    73)
-TYPED_SFIELD(sfSponsorFlags,             UINT32,    74)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -153,7 +148,6 @@ TYPED_SFIELD(sfLockedAmount,             UINT64,    29, SField::kSmdBaseTen|SFie
 TYPED_SFIELD(sfVaultNode,                UINT64,    30)
 TYPED_SFIELD(sfLoanBrokerNode,           UINT64,    31)
 TYPED_SFIELD(sfConfidentialOutstandingAmount, UINT64, 32, SField::kSmdBaseTen|SField::kSmdDefault)
-TYPED_SFIELD(sfSponseeNode,              UINT64,    33)
 
 // 128-bit
 TYPED_SFIELD(sfEmailHash,                UINT128,    1)
@@ -215,7 +209,6 @@ TYPED_SFIELD(sfLoanBrokerID,             UINT256,   37,
 TYPED_SFIELD(sfLoanID,                   UINT256,   38)
 TYPED_SFIELD(sfReferenceHolding,         UINT256,   39)
 TYPED_SFIELD(sfBlindingFactor,           UINT256,   40)
-TYPED_SFIELD(sfObjectID,                 UINT256,   41)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
@@ -275,8 +268,6 @@ TYPED_SFIELD(sfPrice,                    AMOUNT,    28)
 TYPED_SFIELD(sfSignatureReward,          AMOUNT,    29)
 TYPED_SFIELD(sfMinAccountCreateAmount,   AMOUNT,    30)
 TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
-TYPED_SFIELD(sfFeeAmount,                AMOUNT,    32)
-TYPED_SFIELD(sfMaxFee,                   AMOUNT,    33)
 
 // variable length (common)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
@@ -352,11 +343,6 @@ TYPED_SFIELD(sfIssuingChainDoor,         ACCOUNT,   23)
 TYPED_SFIELD(sfSubject,                  ACCOUNT,   24)
 TYPED_SFIELD(sfBorrower,                 ACCOUNT,   25)
 TYPED_SFIELD(sfCounterparty,             ACCOUNT,   26)
-TYPED_SFIELD(sfSponsor,                  ACCOUNT,   27)
-TYPED_SFIELD(sfHighSponsor,              ACCOUNT,   28)
-TYPED_SFIELD(sfLowSponsor,               ACCOUNT,   29)
-TYPED_SFIELD(sfCounterpartySponsor,      ACCOUNT,   30)
-TYPED_SFIELD(sfSponsee,                  ACCOUNT,   31)
 
 // vector of 256-bit
 TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::kSmdNever)
@@ -421,7 +407,6 @@ UNTYPED_SFIELD(sfRawTransaction,         OBJECT,    34)
 UNTYPED_SFIELD(sfBatchSigner,            OBJECT,    35)
 UNTYPED_SFIELD(sfBook,                   OBJECT,    36)
 UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    37, SField::kSmdDefault, SField::kNotSigning)
-UNTYPED_SFIELD(sfSponsorSignature,       OBJECT,    38, SField::kSmdDefault, SField::kNotSigning)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array

include/xrpl/protocol/detail/transactions.macro

@@ -1163,33 +1163,6 @@ TRANSACTION(ttCONFIDENTIAL_MPT_CLAWBACK, 89, ConfidentialMPTClawback,
     {sfHolder, SoeRequired},
     {sfMPTAmount, SoeRequired},
     {sfZKProof, SoeRequired},
-}))/** This transaction transfer sponsorship */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/sponsor/SponsorshipTransfer.h>
-#endif
-TRANSACTION(ttSPONSORSHIP_TRANSFER, 90, SponsorshipTransfer,
-    Delegation::NotDelegable,
-    featureSponsor,
-    NoPriv,
-    ({
-    {sfObjectID, SoeOptional},
-    {sfSponsee, SoeOptional},
-}))
-
-/** This transaction create sponsorship object */
-#if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/sponsor/SponsorshipSet.h>
-#endif
-TRANSACTION(ttSPONSORSHIP_SET, 91, SponsorshipSet,
-    Delegation::Delegable,
-    featureSponsor,
-    NoPriv,
-    ({
-    {sfCounterpartySponsor, SoeOptional},
-    {sfSponsee, SoeOptional},
-    {sfFeeAmount, SoeOptional},
-    {sfMaxFee, SoeOptional},
-    {sfRemainingOwnerCount, SoeOptional},
 }))
 
 /** This system-generated transaction type is used to update the status of the various amendments.

include/xrpl/protocol/jss.h

@@ -558,9 +558,6 @@ JSS(source_account);              // in: PathRequest, RipplePathFind
 JSS(source_amount);               // in: PathRequest, RipplePathFind
 JSS(source_currencies);           // in: PathRequest, RipplePathFind
 JSS(source_tag);                  // out: AccountChannels
-JSS(sponsee);                     // in: LedgerEntry
-JSS(sponsor);                     // in: LedgerEntry
-JSS(sponsored);                   // in: AccountObjects
 JSS(stand_alone);                 // out: NetworkOPs
 JSS(standard_deviation);          // out: get_aggregate_price
 JSS(start);                       // in: TxHistory

include/xrpl/protocol_autogen/ledger_entries/AccountRoot.h

@@ -447,78 +447,6 @@ public:
         return this->sle_->isFieldPresent(sfFirstNFTokenSequence);
     }
 
-    /**
-     * @brief Get sfSponsoredOwnerCount (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getSponsoredOwnerCount() const
-    {
-        if (hasSponsoredOwnerCount())
-            return this->sle_->at(sfSponsoredOwnerCount);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfSponsoredOwnerCount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasSponsoredOwnerCount() const
-    {
-        return this->sle_->isFieldPresent(sfSponsoredOwnerCount);
-    }
-
-    /**
-     * @brief Get sfSponsoringOwnerCount (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getSponsoringOwnerCount() const
-    {
-        if (hasSponsoringOwnerCount())
-            return this->sle_->at(sfSponsoringOwnerCount);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfSponsoringOwnerCount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasSponsoringOwnerCount() const
-    {
-        return this->sle_->isFieldPresent(sfSponsoringOwnerCount);
-    }
-
-    /**
-     * @brief Get sfSponsoringAccountCount (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getSponsoringAccountCount() const
-    {
-        if (hasSponsoringAccountCount())
-            return this->sle_->at(sfSponsoringAccountCount);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfSponsoringAccountCount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasSponsoringAccountCount() const
-    {
-        return this->sle_->isFieldPresent(sfSponsoringAccountCount);
-    }
-
     /**
      * @brief Get sfAMMID (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -858,39 +786,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Set sfSponsoredOwnerCount (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    AccountRootBuilder&
-    setSponsoredOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfSponsoredOwnerCount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponsoringOwnerCount (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    AccountRootBuilder&
-    setSponsoringOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfSponsoringOwnerCount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponsoringAccountCount (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    AccountRootBuilder&
-    setSponsoringAccountCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfSponsoringAccountCount] = value;
-        return *this;
-    }
-
     /**
      * @brief Set sfAMMID (SoeOptional)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/ledger_entries/RippleState.h

@@ -243,54 +243,6 @@ public:
     {
         return this->sle_->isFieldPresent(sfHighQualityOut);
     }
-
-    /**
-     * @brief Get sfHighSponsor (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
-    getHighSponsor() const
-    {
-        if (hasHighSponsor())
-            return this->sle_->at(sfHighSponsor);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfHighSponsor is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasHighSponsor() const
-    {
-        return this->sle_->isFieldPresent(sfHighSponsor);
-    }
-
-    /**
-     * @brief Get sfLowSponsor (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
-    getLowSponsor() const
-    {
-        if (hasLowSponsor())
-            return this->sle_->at(sfLowSponsor);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfLowSponsor is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasLowSponsor() const
-    {
-        return this->sle_->isFieldPresent(sfLowSponsor);
-    }
 };
 
 /**
@@ -458,28 +410,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Set sfHighSponsor (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    RippleStateBuilder&
-    setHighSponsor(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfHighSponsor] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfLowSponsor (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    RippleStateBuilder&
-    setLowSponsor(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfLowSponsor] = value;
-        return *this;
-    }
-
     /**
      * @brief Build and return the completed RippleState wrapper.
      * @param index The ledger entry index.

include/xrpl/protocol_autogen/ledger_entries/Sponsorship.h

@@ -1,344 +0,0 @@
-// This file is auto-generated. Do not edit.
-#pragma once
-
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STParsedJSON.h>
-#include <xrpl/protocol/jss.h>
-#include <xrpl/protocol_autogen/LedgerEntryBase.h>
-#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
-#include <xrpl/json/json_value.h>
-
-#include <stdexcept>
-#include <optional>
-
-namespace xrpl::ledger_entries {
-
-class SponsorshipBuilder;
-
-/**
- * @brief Ledger Entry: Sponsorship
- *
- * Type: ltSPONSORSHIP (0x0090)
- * RPC Name: sponsorship
- *
- * Immutable wrapper around SLE providing type-safe field access.
- * Use SponsorshipBuilder to construct new ledger entries.
- */
-class Sponsorship : public LedgerEntryBase
-{
-public:
-    static constexpr LedgerEntryType entryType = ltSPONSORSHIP;
-
-    /**
-     * @brief Construct a Sponsorship ledger entry wrapper from an existing SLE object.
-     * @throws std::runtime_error if the ledger entry type doesn't match.
-     */
-    explicit Sponsorship(SLE::const_pointer sle)
-        : LedgerEntryBase(std::move(sle))
-    {
-        // Verify ledger entry type
-        if (sle_->getType() != entryType)
-        {
-            throw std::runtime_error("Invalid ledger entry type for Sponsorship");
-        }
-    }
-
-    // Ledger entry-specific field getters
-
-    /**
-     * @brief Get sfPreviousTxnID (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_UINT256::type::value_type
-    getPreviousTxnID() const
-    {
-        return this->sle_->at(sfPreviousTxnID);
-    }
-
-    /**
-     * @brief Get sfPreviousTxnLgrSeq (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_UINT32::type::value_type
-    getPreviousTxnLgrSeq() const
-    {
-        return this->sle_->at(sfPreviousTxnLgrSeq);
-    }
-
-    /**
-     * @brief Get sfOwner (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_ACCOUNT::type::value_type
-    getOwner() const
-    {
-        return this->sle_->at(sfOwner);
-    }
-
-    /**
-     * @brief Get sfSponsee (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_ACCOUNT::type::value_type
-    getSponsee() const
-    {
-        return this->sle_->at(sfSponsee);
-    }
-
-    /**
-     * @brief Get sfFeeAmount (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
-    getFeeAmount() const
-    {
-        if (hasFeeAmount())
-            return this->sle_->at(sfFeeAmount);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfFeeAmount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasFeeAmount() const
-    {
-        return this->sle_->isFieldPresent(sfFeeAmount);
-    }
-
-    /**
-     * @brief Get sfMaxFee (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
-    getMaxFee() const
-    {
-        if (hasMaxFee())
-            return this->sle_->at(sfMaxFee);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfMaxFee is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasMaxFee() const
-    {
-        return this->sle_->isFieldPresent(sfMaxFee);
-    }
-
-    /**
-     * @brief Get sfRemainingOwnerCount (SoeDefault)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getRemainingOwnerCount() const
-    {
-        if (hasRemainingOwnerCount())
-            return this->sle_->at(sfRemainingOwnerCount);
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfRemainingOwnerCount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasRemainingOwnerCount() const
-    {
-        return this->sle_->isFieldPresent(sfRemainingOwnerCount);
-    }
-
-    /**
-     * @brief Get sfOwnerNode (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_UINT64::type::value_type
-    getOwnerNode() const
-    {
-        return this->sle_->at(sfOwnerNode);
-    }
-
-    /**
-     * @brief Get sfSponseeNode (SoeRequired)
-     * @return The field value.
-     */
-    [[nodiscard]]
-    SF_UINT64::type::value_type
-    getSponseeNode() const
-    {
-        return this->sle_->at(sfSponseeNode);
-    }
-};
-
-/**
- * @brief Builder for Sponsorship ledger entries.
- *
- * Provides a fluent interface for constructing ledger entries with method chaining.
- * Uses STObject internally for flexible ledger entry construction.
- * Inherits common field setters from LedgerEntryBuilderBase.
- */
-class SponsorshipBuilder : public LedgerEntryBuilderBase<SponsorshipBuilder>
-{
-public:
-    /**
-     * @brief Construct a new SponsorshipBuilder with required fields.
-     * @param previousTxnID The sfPreviousTxnID field value.
-     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
-     * @param owner The sfOwner field value.
-     * @param sponsee The sfSponsee field value.
-     * @param ownerNode The sfOwnerNode field value.
-     * @param sponseeNode The sfSponseeNode field value.
-     */
-    SponsorshipBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_ACCOUNT::type::value_type> const& sponsee,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& sponseeNode)
-        : LedgerEntryBuilderBase<SponsorshipBuilder>(ltSPONSORSHIP)
-    {
-        setPreviousTxnID(previousTxnID);
-        setPreviousTxnLgrSeq(previousTxnLgrSeq);
-        setOwner(owner);
-        setSponsee(sponsee);
-        setOwnerNode(ownerNode);
-        setSponseeNode(sponseeNode);
-    }
-
-    /**
-     * @brief Construct a SponsorshipBuilder from an existing SLE object.
-     * @param sle The existing ledger entry to copy from.
-     * @throws std::runtime_error if the ledger entry type doesn't match.
-     */
-    SponsorshipBuilder(SLE::const_pointer sle)
-    {
-        if (sle->at(sfLedgerEntryType) != ltSPONSORSHIP)
-        {
-            throw std::runtime_error("Invalid ledger entry type for Sponsorship");
-        }
-        object_ = *sle;
-    }
-
-    /** @brief Ledger entry-specific field setters */
-
-    /**
-     * @brief Set sfPreviousTxnID (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
-    {
-        object_[sfPreviousTxnID] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfPreviousTxnLgrSeq (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfPreviousTxnLgrSeq] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfOwner (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfOwner] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponsee (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setSponsee(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfSponsee] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfFeeAmount (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setFeeAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
-    {
-        object_[sfFeeAmount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfMaxFee (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setMaxFee(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
-    {
-        object_[sfMaxFee] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfRemainingOwnerCount (SoeDefault)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setRemainingOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfRemainingOwnerCount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfOwnerNode (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
-    {
-        object_[sfOwnerNode] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponseeNode (SoeRequired)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipBuilder&
-    setSponseeNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
-    {
-        object_[sfSponseeNode] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Build and return the completed Sponsorship wrapper.
-     * @param index The ledger entry index.
-     * @return The constructed ledger entry wrapper.
-     */
-    Sponsorship
-    build(uint256 const& index)
-    {
-        return Sponsorship{std::make_shared<SLE>(std::move(object_), index)};
-    }
-};
-
-}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/transactions/SponsorshipSet.h

@@ -1,290 +0,0 @@
-// This file is auto-generated. Do not edit.
-#pragma once
-
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/STParsedJSON.h>
-#include <xrpl/protocol/jss.h>
-#include <xrpl/protocol_autogen/TransactionBase.h>
-#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
-#include <xrpl/json/json_value.h>
-
-#include <stdexcept>
-#include <optional>
-
-namespace xrpl::transactions {
-
-class SponsorshipSetBuilder;
-
-/**
- * @brief Transaction: SponsorshipSet
- *
- * Type: ttSPONSORSHIP_SET (91)
- * Delegable: Delegation::Delegable
- * Amendment: featureSponsor
- * Privileges: NoPriv
- *
- * Immutable wrapper around STTx providing type-safe field access.
- * Use SponsorshipSetBuilder to construct new transactions.
- */
-class SponsorshipSet : public TransactionBase
-{
-public:
-    static constexpr xrpl::TxType txType = ttSPONSORSHIP_SET;
-
-    /**
-     * @brief Construct a SponsorshipSet transaction wrapper from an existing STTx object.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    explicit SponsorshipSet(std::shared_ptr<STTx const> tx)
-        : TransactionBase(std::move(tx))
-    {
-        // Verify transaction type
-        if (tx_->getTxnType() != txType)
-        {
-            throw std::runtime_error("Invalid transaction type for SponsorshipSet");
-        }
-    }
-
-    // Transaction-specific field getters
-
-    /**
-     * @brief Get sfCounterpartySponsor (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
-    getCounterpartySponsor() const
-    {
-        if (hasCounterpartySponsor())
-        {
-            return this->tx_->at(sfCounterpartySponsor);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfCounterpartySponsor is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasCounterpartySponsor() const
-    {
-        return this->tx_->isFieldPresent(sfCounterpartySponsor);
-    }
-
-    /**
-     * @brief Get sfSponsee (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
-    getSponsee() const
-    {
-        if (hasSponsee())
-        {
-            return this->tx_->at(sfSponsee);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfSponsee is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasSponsee() const
-    {
-        return this->tx_->isFieldPresent(sfSponsee);
-    }
-
-    /**
-     * @brief Get sfFeeAmount (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
-    getFeeAmount() const
-    {
-        if (hasFeeAmount())
-        {
-            return this->tx_->at(sfFeeAmount);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfFeeAmount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasFeeAmount() const
-    {
-        return this->tx_->isFieldPresent(sfFeeAmount);
-    }
-
-    /**
-     * @brief Get sfMaxFee (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
-    getMaxFee() const
-    {
-        if (hasMaxFee())
-        {
-            return this->tx_->at(sfMaxFee);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfMaxFee is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasMaxFee() const
-    {
-        return this->tx_->isFieldPresent(sfMaxFee);
-    }
-
-    /**
-     * @brief Get sfRemainingOwnerCount (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getRemainingOwnerCount() const
-    {
-        if (hasRemainingOwnerCount())
-        {
-            return this->tx_->at(sfRemainingOwnerCount);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfRemainingOwnerCount is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasRemainingOwnerCount() const
-    {
-        return this->tx_->isFieldPresent(sfRemainingOwnerCount);
-    }
-};
-
-/**
- * @brief Builder for SponsorshipSet transactions.
- *
- * Provides a fluent interface for constructing transactions with method chaining.
- * Uses STObject internally for flexible transaction construction.
- * Inherits common field setters from TransactionBuilderBase.
- */
-class SponsorshipSetBuilder : public TransactionBuilderBase<SponsorshipSetBuilder>
-{
-public:
-    /**
-     * @brief Construct a new SponsorshipSetBuilder with required fields.
-     * @param account The account initiating the transaction.
-     * @param sequence Optional sequence number for the transaction.
-     * @param fee Optional fee for the transaction.
-     */
-    SponsorshipSetBuilder(SF_ACCOUNT::type::value_type account,
-                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
-                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
-)
-        : TransactionBuilderBase<SponsorshipSetBuilder>(ttSPONSORSHIP_SET, account, sequence, fee)
-    {
-    }
-
-    /**
-     * @brief Construct a SponsorshipSetBuilder from an existing STTx object.
-     * @param tx The existing transaction to copy from.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    SponsorshipSetBuilder(std::shared_ptr<STTx const> tx)
-    {
-        if (tx->getTxnType() != ttSPONSORSHIP_SET)
-        {
-            throw std::runtime_error("Invalid transaction type for SponsorshipSetBuilder");
-        }
-        object_ = *tx;
-    }
-
-    /** @brief Transaction-specific field setters */
-
-    /**
-     * @brief Set sfCounterpartySponsor (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipSetBuilder&
-    setCounterpartySponsor(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfCounterpartySponsor] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponsee (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipSetBuilder&
-    setSponsee(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfSponsee] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfFeeAmount (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipSetBuilder&
-    setFeeAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
-    {
-        object_[sfFeeAmount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfMaxFee (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipSetBuilder&
-    setMaxFee(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
-    {
-        object_[sfMaxFee] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfRemainingOwnerCount (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipSetBuilder&
-    setRemainingOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
-    {
-        object_[sfRemainingOwnerCount] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Build and return the SponsorshipSet wrapper.
-     * @param publicKey The public key for signing.
-     * @param secretKey The secret key for signing.
-     * @return The constructed transaction wrapper.
-     */
-    SponsorshipSet
-    build(PublicKey const& publicKey, SecretKey const& secretKey)
-    {
-        sign(publicKey, secretKey);
-        return SponsorshipSet{std::make_shared<STTx>(std::move(object_))};
-    }
-};
-
-}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/SponsorshipTransfer.h

@@ -1,179 +0,0 @@
-// This file is auto-generated. Do not edit.
-#pragma once
-
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/STParsedJSON.h>
-#include <xrpl/protocol/jss.h>
-#include <xrpl/protocol_autogen/TransactionBase.h>
-#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
-#include <xrpl/json/json_value.h>
-
-#include <stdexcept>
-#include <optional>
-
-namespace xrpl::transactions {
-
-class SponsorshipTransferBuilder;
-
-/**
- * @brief Transaction: SponsorshipTransfer
- *
- * Type: ttSPONSORSHIP_TRANSFER (90)
- * Delegable: Delegation::NotDelegable
- * Amendment: featureSponsor
- * Privileges: NoPriv
- *
- * Immutable wrapper around STTx providing type-safe field access.
- * Use SponsorshipTransferBuilder to construct new transactions.
- */
-class SponsorshipTransfer : public TransactionBase
-{
-public:
-    static constexpr xrpl::TxType txType = ttSPONSORSHIP_TRANSFER;
-
-    /**
-     * @brief Construct a SponsorshipTransfer transaction wrapper from an existing STTx object.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    explicit SponsorshipTransfer(std::shared_ptr<STTx const> tx)
-        : TransactionBase(std::move(tx))
-    {
-        // Verify transaction type
-        if (tx_->getTxnType() != txType)
-        {
-            throw std::runtime_error("Invalid transaction type for SponsorshipTransfer");
-        }
-    }
-
-    // Transaction-specific field getters
-
-    /**
-     * @brief Get sfObjectID (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT256::type::value_type>
-    getObjectID() const
-    {
-        if (hasObjectID())
-        {
-            return this->tx_->at(sfObjectID);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfObjectID is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasObjectID() const
-    {
-        return this->tx_->isFieldPresent(sfObjectID);
-    }
-
-    /**
-     * @brief Get sfSponsee (SoeOptional)
-     * @return The field value, or std::nullopt if not present.
-     */
-    [[nodiscard]]
-    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
-    getSponsee() const
-    {
-        if (hasSponsee())
-        {
-            return this->tx_->at(sfSponsee);
-        }
-        return std::nullopt;
-    }
-
-    /**
-     * @brief Check if sfSponsee is present.
-     * @return True if the field is present, false otherwise.
-     */
-    [[nodiscard]]
-    bool
-    hasSponsee() const
-    {
-        return this->tx_->isFieldPresent(sfSponsee);
-    }
-};
-
-/**
- * @brief Builder for SponsorshipTransfer transactions.
- *
- * Provides a fluent interface for constructing transactions with method chaining.
- * Uses STObject internally for flexible transaction construction.
- * Inherits common field setters from TransactionBuilderBase.
- */
-class SponsorshipTransferBuilder : public TransactionBuilderBase<SponsorshipTransferBuilder>
-{
-public:
-    /**
-     * @brief Construct a new SponsorshipTransferBuilder with required fields.
-     * @param account The account initiating the transaction.
-     * @param sequence Optional sequence number for the transaction.
-     * @param fee Optional fee for the transaction.
-     */
-    SponsorshipTransferBuilder(SF_ACCOUNT::type::value_type account,
-                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
-                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
-)
-        : TransactionBuilderBase<SponsorshipTransferBuilder>(ttSPONSORSHIP_TRANSFER, account, sequence, fee)
-    {
-    }
-
-    /**
-     * @brief Construct a SponsorshipTransferBuilder from an existing STTx object.
-     * @param tx The existing transaction to copy from.
-     * @throws std::runtime_error if the transaction type doesn't match.
-     */
-    SponsorshipTransferBuilder(std::shared_ptr<STTx const> tx)
-    {
-        if (tx->getTxnType() != ttSPONSORSHIP_TRANSFER)
-        {
-            throw std::runtime_error("Invalid transaction type for SponsorshipTransferBuilder");
-        }
-        object_ = *tx;
-    }
-
-    /** @brief Transaction-specific field setters */
-
-    /**
-     * @brief Set sfObjectID (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipTransferBuilder&
-    setObjectID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
-    {
-        object_[sfObjectID] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Set sfSponsee (SoeOptional)
-     * @return Reference to this builder for method chaining.
-     */
-    SponsorshipTransferBuilder&
-    setSponsee(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
-    {
-        object_[sfSponsee] = value;
-        return *this;
-    }
-
-    /**
-     * @brief Build and return the SponsorshipTransfer wrapper.
-     * @param publicKey The public key for signing.
-     * @param secretKey The secret key for signing.
-     * @return The constructed transaction wrapper.
-     */
-    SponsorshipTransfer
-    build(PublicKey const& publicKey, SecretKey const& secretKey)
-    {
-        sign(publicKey, secretKey);
-        return SponsorshipTransfer{std::make_shared<STTx>(std::move(object_))};
-    }
-};
-
-}  // namespace xrpl::transactions

include/xrpl/resource/detail/Logic.h

@@ -351,10 +351,9 @@ public:
             Import& import(iter->second);
             if (iter->second.whenExpires <= elapsed)
             {
-                for (auto itemIter(import.items.begin()); itemIter != import.items.end();
-                     ++itemIter)
+                for (auto& item : import.items)
                 {
-                    itemIter->consumer.entry().remoteBalance -= itemIter->balance;
+                    item.consumer.entry().remoteBalance -= item.balance;
                 }
 
                 iter = importTable_.erase(iter);

include/xrpl/server/Manifest.h

@@ -161,13 +161,12 @@ deserializeManifest(
     return deserializeManifest(makeSlice(s), journal);
 }
 
-template <
-    class T,
-    class = std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>>>
+template <class T>
 std::optional<Manifest>
 deserializeManifest(
     std::vector<T> const& v,
     beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
+    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return deserializeManifest(makeSlice(v), journal);
 }

include/xrpl/server/detail/BaseHTTPPeer.h

@@ -223,10 +223,7 @@ BaseHTTPPeer<Handler, Impl>::close()
 {
     if (!strand_.running_in_this_thread())
     {
-        return post(
-            strand_,
-            std::bind(
-                (void (BaseHTTPPeer::*)(void))&BaseHTTPPeer::close, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->close(); });
     }
     boost::beast::get_lowest_layer(impl().stream_).close();
 }
@@ -322,22 +319,18 @@ BaseHTTPPeer<Handler, Impl>::onWrite(error_code const& ec, std::size_t bytesTran
             v,
             bind_executor(
                 strand_,
-                std::bind(
-                    &BaseHTTPPeer::onWrite,
-                    impl().shared_from_this(),
-                    std::placeholders::_1,
-                    std::placeholders::_2)));
+                [self = impl().shared_from_this()](
+                    error_code const& ec, std::size_t bytesTransferred) {
+                    self->onWrite(ec, bytesTransferred);
+                }));
     }
     if (!complete_)
         return;
     if (graceful_)
         return doClose();
-    util::spawn(
-        strand_,
-        std::bind(
-            &BaseHTTPPeer<Handler, Impl>::doRead,
-            impl().shared_from_this(),
-            std::placeholders::_1));
+    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
+        self->doRead(doYield);
+    });
 }
 
 template <class Handler, class Impl>
@@ -351,14 +344,9 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
     {
         auto const p = impl().shared_from_this();
         resume = std::function<void(void)>([this, p, writer, keepAlive]() {
-            util::spawn(
-                strand_,
-                std::bind(
-                    &BaseHTTPPeer<Handler, Impl>::doWriter,
-                    p,
-                    writer,
-                    keepAlive,
-                    std::placeholders::_1));
+            util::spawn(strand_, [p, writer, keepAlive](yield_context doYield) {
+                p->doWriter(writer, keepAlive, doYield);
+            });
         });
     }
 
@@ -379,12 +367,9 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
     if (!keepAlive)
         return doClose();
 
-    util::spawn(
-        strand_,
-        std::bind(
-            &BaseHTTPPeer<Handler, Impl>::doRead,
-            impl().shared_from_this(),
-            std::placeholders::_1));
+    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
+        self->doRead(doYield);
+    });
 }
 
 //------------------------------------------------------------------------------
@@ -405,8 +390,7 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
         if (!strand_.running_in_this_thread())
         {
             return post(
-                strand_,
-                std::bind(&BaseHTTPPeer::onWrite, impl().shared_from_this(), error_code{}, 0));
+                strand_, [self = impl().shared_from_this()] { self->onWrite(error_code{}, 0); });
         }
         return onWrite(error_code{}, 0);
     }
@@ -417,13 +401,9 @@ void
 BaseHTTPPeer<Handler, Impl>::write(std::shared_ptr<Writer> const& writer, bool keepAlive)
 {
     util::spawn(
-        strand_,
-        std::bind(
-            &BaseHTTPPeer<Handler, Impl>::doWriter,
-            impl().shared_from_this(),
-            writer,
-            keepAlive,
-            std::placeholders::_1));
+        strand_, [self = impl().shared_from_this(), writer, keepAlive](yield_context doYield) {
+            self->doWriter(writer, keepAlive, doYield);
+        });
 }
 
 // DEPRECATED
@@ -443,8 +423,7 @@ BaseHTTPPeer<Handler, Impl>::complete()
 {
     if (!strand_.running_in_this_thread())
     {
-        return post(
-            strand_, std::bind(&BaseHTTPPeer<Handler, Impl>::complete, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
     }
 
     message_ = {};
@@ -457,12 +436,9 @@ BaseHTTPPeer<Handler, Impl>::complete()
     }
 
     // keep-alive
-    util::spawn(
-        strand_,
-        std::bind(
-            &BaseHTTPPeer<Handler, Impl>::doRead,
-            impl().shared_from_this(),
-            std::placeholders::_1));
+    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
+        self->doRead(doYield);
+    });
 }
 
 // DEPRECATED
@@ -474,11 +450,7 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     if (!strand_.running_in_this_thread())
     {
         return post(
-            strand_,
-            std::bind(
-                (void (BaseHTTPPeer::*)(bool))&BaseHTTPPeer<Handler, Impl>::close,
-                impl().shared_from_this(),
-                graceful));
+            strand_, [self = impl().shared_from_this(), graceful] { self->close(graceful); });
     }
 
     complete_ = true;

include/xrpl/server/detail/BasePeer.h

@@ -10,7 +10,6 @@
 
 #include <atomic>
 #include <chrono>
-#include <functional>
 #include <string>
 #include <utility>
 
@@ -84,7 +83,7 @@ void
 BasePeer<Handler, Impl>::close()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BasePeer::close, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->close(); });
     error_code ec;
     xrpl::getLowestLayer(impl().ws_).socket().close(ec);
 }

include/xrpl/server/detail/BaseWSPeer.h

@@ -20,6 +20,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cstddef>
 #include <functional>
 #include <iterator>
 #include <list>
@@ -180,12 +181,13 @@ void
 BaseWSPeer<Handler, Impl>::run()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BaseWSPeer::run, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->run(); });
     impl().ws_.set_option(port().pmdOptions);
     // Must manage the control callback memory outside of the `control_callback`
     // function
-    controlCallback_ =
-        std::bind(&BaseWSPeer::onPingPong, this, std::placeholders::_1, std::placeholders::_2);
+    controlCallback_ = [this](
+                           boost::beast::websocket::frame_type kind,
+                           boost::beast::string_view payload) { onPingPong(kind, payload); };
     impl().ws_.control_callback(controlCallback_);
     startTimer();
     closeOnTimer_ = true;
@@ -193,11 +195,9 @@ BaseWSPeer<Handler, Impl>::run()
         res.set(boost::beast::http::field::server, BuildInfo::getFullVersionString());
     }));
     impl().ws_.async_accept(
-        request_,
-        bind_executor(
-            strand_,
-            std::bind(
-                &BaseWSPeer::onWsHandshake, impl().shared_from_this(), std::placeholders::_1)));
+        request_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
+            self->onWsHandshake(ec);
+        }));
 }
 
 template <class Handler, class Impl>
@@ -205,7 +205,10 @@ void
 BaseWSPeer<Handler, Impl>::send(std::shared_ptr<WSMsg> w)
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BaseWSPeer::send, impl().shared_from_this(), std::move(w)));
+    {
+        return post(
+            strand_, [self = impl().shared_from_this(), w = std::move(w)] { self->send(w); });
+    }
     if (doClose_)
         return;
     if (wq_.size() > port().wsQueueLimit)
@@ -258,7 +261,7 @@ void
 BaseWSPeer<Handler, Impl>::complete()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BaseWSPeer::complete, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
     doRead();
 }
 
@@ -277,7 +280,7 @@ void
 BaseWSPeer<Handler, Impl>::doWrite()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->doWrite(); });
     onWrite({});
 }
 
@@ -288,8 +291,7 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
     if (ec)
         return fail(ec, "write");
     auto& w = *wq_.front();
-    auto const result =
-        w.prepare(65536, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
+    auto const result = w.prepare(65536, [self = impl().shared_from_this()] { self->doWrite(); });
     if (boost::indeterminate(result.first))
         return;
     startTimer();
@@ -299,8 +301,9 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
             static_cast<bool>(result.first),
             result.second,
             bind_executor(
-                strand_,
-                std::bind(&BaseWSPeer::onWrite, impl().shared_from_this(), std::placeholders::_1)));
+                strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
+                    self->onWrite(ec);
+                }));
     }
     else
     {
@@ -308,9 +311,9 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
             static_cast<bool>(result.first),
             result.second,
             bind_executor(
-                strand_,
-                std::bind(
-                    &BaseWSPeer::onWriteFin, impl().shared_from_this(), std::placeholders::_1)));
+                strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
+                    self->onWriteFin(ec);
+                }));
     }
 }
 
@@ -324,10 +327,9 @@ BaseWSPeer<Handler, Impl>::onWriteFin(error_code const& ec)
     if (doClose_)
     {
         impl().ws_.async_close(
-            cr_,
-            bind_executor(
-                strand_,
-                std::bind(&BaseWSPeer::onClose, impl().shared_from_this(), std::placeholders::_1)));
+            cr_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
+                self->onClose(ec);
+            }));
     }
     else if (!wq_.empty())
     {
@@ -340,12 +342,13 @@ void
 BaseWSPeer<Handler, Impl>::doRead()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, std::bind(&BaseWSPeer::doRead, impl().shared_from_this()));
+        return post(strand_, [self = impl().shared_from_this()] { self->doRead(); });
     impl().ws_.async_read(
         rb_,
         bind_executor(
-            strand_,
-            std::bind(&BaseWSPeer::onRead, impl().shared_from_this(), std::placeholders::_1)));
+            strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
+                self->onRead(ec);
+            }));
 }
 
 template <class Handler, class Impl>
@@ -389,11 +392,7 @@ BaseWSPeer<Handler, Impl>::startTimer()
     }
 
     timer_.async_wait(bind_executor(
-        strand_,
-        std::bind(
-            &BaseWSPeer<Handler, Impl>::onTimer,
-            impl().shared_from_this(),
-            std::placeholders::_1)));
+        strand_, [self = impl().shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
 }
 
 // Convenience for discarding the error code
@@ -461,10 +460,9 @@ BaseWSPeer<Handler, Impl>::onTimer(error_code ec)
             beast::rngfill(payload_.begin(), payload_.size(), cryptoPrng());
             impl().ws_.async_ping(
                 payload_,
-                bind_executor(
-                    strand_,
-                    std::bind(
-                        &BaseWSPeer::onPing, impl().shared_from_this(), std::placeholders::_1)));
+                bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
+                    self->onPing(ec);
+                }));
             JLOG(this->j_.trace()) << "sent ping";
             return;
         }

include/xrpl/server/detail/Door.h

@@ -33,7 +33,6 @@
 #include <algorithm>
 #include <chrono>
 #include <cstdint>
-#include <functional>
 #include <memory>
 #include <optional>
 #include <sstream>
@@ -182,7 +181,7 @@ void
 Door<Handler>::Detector::run()
 {
     util::spawn(
-        strand_, std::bind(&Detector::doDetect, this->shared_from_this(), std::placeholders::_1));
+        strand_, [self = this->shared_from_this()](yield_context yield) { self->doDetect(yield); });
 }
 
 template <class Handler>
@@ -297,8 +296,7 @@ void
 Door<Handler>::run()
 {
     util::spawn(
-        strand_,
-        std::bind(&Door<Handler>::doAccept, this->shared_from_this(), std::placeholders::_1));
+        strand_, [self = this->shared_from_this()](yield_context yield) { self->doAccept(yield); });
 }
 
 template <class Handler>
@@ -307,8 +305,7 @@ Door<Handler>::close()
 {
     if (!strand_.running_in_this_thread())
     {
-        return boost::asio::post(
-            strand_, std::bind(&Door<Handler>::close, this->shared_from_this()));
+        return boost::asio::post(strand_, [self = this->shared_from_this()] { self->close(); });
     }
     backoffTimer_.cancel();
     error_code ec;

include/xrpl/server/detail/PlainHTTPPeer.h

@@ -9,7 +9,6 @@
 
 #include <boost/beast/core/tcp_stream.hpp>
 
-#include <functional>
 #include <memory>
 #include <utility>
 
@@ -89,7 +88,9 @@ PlainHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
     {
-        util::spawn(this->strand_, std::bind(&PlainHTTPPeer::doClose, this->shared_from_this()));
+        util::spawn(this->strand_, [self = this->shared_from_this()](boost::asio::yield_context) {
+            self->doClose();
+        });
         return;
     }
 
@@ -97,8 +98,9 @@ PlainHTTPPeer<Handler>::run()
         return;
 
     util::spawn(
-        this->strand_,
-        std::bind(&PlainHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
+        this->strand_, [self = this->shared_from_this()](boost::asio::yield_context doYield) {
+            self->doRead(doYield);
+        });
 }
 
 template <class Handler>

include/xrpl/server/detail/SSLHTTPPeer.h

@@ -13,7 +13,6 @@
 #include <boost/beast/core/tcp_stream.hpp>
 #include <boost/beast/ssl/ssl_stream.hpp>
 
-#include <functional>
 #include <memory>
 #include <utility>
 
@@ -99,14 +98,15 @@ SSLHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
     {
-        util::spawn(this->strand_, std::bind(&SSLHTTPPeer::doClose, this->shared_from_this()));
+        util::spawn(
+            this->strand_, [self = this->shared_from_this()](yield_context) { self->doClose(); });
         return;
     }
     if (!socket_.is_open())
         return;
-    util::spawn(
-        this->strand_,
-        std::bind(&SSLHTTPPeer::doHandshake, this->shared_from_this(), std::placeholders::_1));
+    util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
+        self->doHandshake(doYield);
+    });
 }
 
 template <class Handler>
@@ -142,9 +142,9 @@ SSLHTTPPeer<Handler>::doHandshake(yield_context doYield)
         this->port().protocol.count("https") > 0;
     if (http)
     {
-        util::spawn(
-            this->strand_,
-            std::bind(&SSLHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
+        util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
+            self->doRead(doYield);
+        });
         return;
     }
     // `this` will be destroyed
@@ -172,7 +172,7 @@ SSLHTTPPeer<Handler>::doClose()
     this->startTimer();
     stream_.async_shutdown(bind_executor(
         this->strand_,
-        std::bind(&SSLHTTPPeer::onShutdown, this->shared_from_this(), std::placeholders::_1)));
+        [self = this->shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
 }
 
 template <class Handler>

include/xrpl/shamap/FullBelowCache.h

@@ -103,7 +103,7 @@ public:
 
     /** generation determines whether cached entry is valid */
     std::uint32_t
-    getGeneration(void) const
+    getGeneration() const
     {
         return gen_;
     }

include/xrpl/shamap/SHAMap.h

@@ -3,7 +3,6 @@
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/IntrusivePointer.h>
 #include <xrpl/basics/SHAMapHash.h>
-#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/beast/utility/instrumentation.h>
@@ -88,6 +87,17 @@ enum class SHAMapState {
 
     See https://en.wikipedia.org/wiki/Merkle_tree
  */
+
+/** Holds a SHAMap node's identity, serialized data, and leaf status.
+    Used by getNodeFat to return node data for peer synchronization.
+*/
+struct SHAMapNodeData
+{
+    SHAMapNodeID nodeID;
+    bool isLeaf;
+    Blob data;  // Placed last, so `isLeaf` can fit into the alignment padding of `nodeID`.
+};
+
 class SHAMap
 {
 private:
@@ -265,10 +275,10 @@ public:
     std::vector<std::pair<SHAMapNodeID, uint256>>
     getMissingNodes(int maxNodes, SHAMapSyncFilter const* filter);
 
-    bool
+    [[nodiscard]] bool
     getNodeFat(
         SHAMapNodeID const& wanted,
-        std::vector<std::pair<SHAMapNodeID, Blob>>& data,
+        std::vector<SHAMapNodeData>& data,
         bool fatLeaves,
         std::uint32_t depth) const;
 
@@ -295,10 +305,43 @@ public:
     void
     serializeRoot(Serializer& s) const;
 
+    /** Add a root node to the SHAMap during synchronization.
+     *
+     * This function is used when receiving the root node of a SHAMap from a peer during ledger
+     * synchronization. The node must already have been deserialized.
+     *
+     * @param hash The expected hash of the root node.
+     * @param rootNode A deserialized root node to add.
+     * @param filter Optional sync filter to track received nodes.
+     * @return Status indicating whether the node was useful, duplicate, or invalid.
+     *
+     * @note This function expects the rootNode to be a valid, deserialized SHAMapTreeNode. The
+     *       caller is responsible for deserialization and basic validation before calling this
+     *       function.
+     */
     SHAMapAddNode
-    addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFilter const* filter);
+    addRootNode(SHAMapHash const& hash, SHAMapTreeNodePtr rootNode, SHAMapSyncFilter const* filter);
+
+    /** Add a known node at a specific position in the SHAMap during synchronization.
+     *
+     * This function is used when receiving nodes from peers during ledger synchronization. The node
+     * is inserted at the position specified by nodeID. The node must already have been
+     * deserialized.
+     *
+     * @param nodeID The position in the tree where this node belongs.
+     * @param treeNode A deserialized tree node to add.
+     * @param filter Optional sync filter to track received nodes.
+     * @return Status indicating whether the node was useful, duplicate, or invalid.
+     *
+     * @note This function expects the treeNode to be a valid, deserialized SHAMapTreeNode. The
+     *       caller is responsible for deserialization and basic validation before calling this
+     *       function. This also means that the nodeID must be consistent with the node's content.
+     */
     SHAMapAddNode
-    addKnownNode(SHAMapNodeID const& nodeID, Slice const& rawNode, SHAMapSyncFilter const* filter);
+    addKnownNode(
+        SHAMapNodeID const& nodeID,
+        SHAMapTreeNodePtr treeNode,
+        SHAMapSyncFilter const* filter);
 
     // status functions
     void

include/xrpl/tx/ApplyContext.h

@@ -127,15 +127,6 @@ public:
     TER
     checkInvariants(TER const result, XRPAmount const fee);
 
-    ApplyViewContext
-    getApplyViewContext()
-    {
-        XRPL_ASSERT(
-            view_.has_value(),
-            "xrpl::ApplyContext::getApplyViewContext : view_ emplaced in constructor");
-        return {.view = *view_, .tx = tx};
-    }
-
 private:
     static TER
     failInvariantCheck(TER const result);

include/xrpl/tx/Transactor.h

@@ -10,10 +10,8 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/Permissions.h>
 #include <xrpl/protocol/Rules.h>
-#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/Units.h>
@@ -128,21 +126,6 @@ struct PreflightResult;
 // Needed for preflight specialization
 class Change;
 
-enum class FeePayerType {
-    Account,
-    Delegate,
-    SponsorCoSigned,
-    SponsorPreFunded,
-};
-
-struct FeePayer
-{
-    AccountID id;
-    Keylet keylet;
-    SF_AMOUNT const& balanceField;
-    FeePayerType type{FeePayerType::Account};
-};
-
 class Transactor
 {
 protected:
@@ -315,10 +298,6 @@ public:
 
         return T::checkGranularSemantics(view, tx, heldGranularPermissions);
     }
-
-    static NotTEC
-    checkSponsor(ReadView const& view, STTx const& tx);
-
     /////////////////////////////////////////////////////
 
     // Interface used by AccountDelete
@@ -480,9 +459,6 @@ private:
     std::pair<TER, XRPAmount>
     reset(XRPAmount fee);
 
-    static FeePayer
-    getFeePayer(ReadView const& view, STTx const& tx);
-
     TER
     consumeSeqProxy(SLE::pointer const& sleAccount);
     TER

include/xrpl/tx/invariants/InvariantCheck.h

@@ -15,7 +15,6 @@
 #include <xrpl/tx/invariants/NFTInvariant.h>
 #include <xrpl/tx/invariants/PermissionedDEXInvariant.h>
 #include <xrpl/tx/invariants/PermissionedDomainInvariant.h>
-#include <xrpl/tx/invariants/SponsorshipInvariant.h>
 #include <xrpl/tx/invariants/VaultInvariant.h>
 
 #include <cstdint>
@@ -442,9 +441,7 @@ using InvariantChecks = std::tuple<
     ValidMPTPayment,
     ValidAmounts,
     ValidMPTTransfer,
-    ObjectHasPseudoAccount,
-    SponsorshipOwnerCountsMatch,
-    SponsorshipAccountCountMatchesField>;
+    ObjectHasPseudoAccount>;
 
 /**
  * @brief get a tuple of all invariant checks

include/xrpl/tx/invariants/SponsorshipInvariant.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
-
-#include <cstdint>
-#include <memory>
-
-namespace xrpl {
-
-/**
- * @brief Invariant: Sponsored owner counts are balanced.
- *
- * The following check is made for every transaction:
- *  - The sum of all per-account deltas of `sfSponsoredOwnerCount` equals
- *    the sum of all per-account deltas of `sfSponsoringOwnerCount`.
- *  - Account OwnerCount must be greater than or equal to SponsoredOwnerCount.
- */
-class SponsorshipOwnerCountsMatch
-{
-    std::int64_t deltaSponsoredOwnerCount_ = 0;
-    std::int64_t deltaSponsoringOwnerCount_ = 0;
-    std::int64_t deltaSponsoredObjectOwnerCount_ = 0;
-    std::uint64_t ownerCountBelowSponsored_ = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    [[nodiscard]] bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&) const;
-};
-
-/**
- * @brief Invariant: Sponsoring account relationships tracked consistently.
- *
- * The following check is made for every transaction:
- *  - The net delta of `sfSponsoringAccountCount` across all accounts equals
- *    the net delta of the count of ltACCOUNT_ROOT entries having
- *    `sfSponsor` present (presence transitions only: add/remove).
- */
-class SponsorshipAccountCountMatchesField
-{
-    std::int64_t deltaSponsoringAccountCount_ = 0;
-    std::int64_t deltaSponsorFieldPresence_ = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    [[nodiscard]] bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&) const;
-};
-
-}  // namespace xrpl

include/xrpl/tx/paths/AMMOffer.h

@@ -7,7 +7,6 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Concepts.h>
 #include <xrpl/protocol/Quality.h>
-#include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/TER.h>
 
 #include <cstdint>
@@ -111,10 +110,7 @@ public:
     send(Args&&... args)
     {
         return accountSend(
-            std::forward<Args>(args)...,
-            SLE::pointer(),
-            WaiveTransferFee::Yes,
-            AllowMPTOverflow::Yes);
+            std::forward<Args>(args)..., WaiveTransferFee::Yes, AllowMPTOverflow::Yes);
     }
 
     [[nodiscard]] bool

include/xrpl/tx/paths/Offer.h

@@ -234,8 +234,7 @@ template <typename... Args>
 TER
 TOffer<TIn, TOut>::send(Args&&... args)
 {
-    return accountSend(
-        std::forward<Args>(args)..., SLE::pointer(), WaiveTransferFee::No, AllowMPTOverflow::Yes);
+    return accountSend(std::forward<Args>(args)..., WaiveTransferFee::No, AllowMPTOverflow::Yes);
 }
 
 template <StepAmount TIn, StepAmount TOut>

include/xrpl/tx/paths/detail/EitherAmount.h

@@ -6,7 +6,7 @@
 #include <xrpl/protocol/MPTAmount.h>  // IWYU pragma: keep
 #include <xrpl/protocol/XRPAmount.h>
 
-#include <ostream>
+#include <ostream>  // IWYU pragma: keep
 #include <stdexcept>
 #include <variant>
 

include/xrpl/tx/transactors/sponsor/SponsorshipSet.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/Transactor.h>
-
-#include <cstdint>
-#include <memory>
-
-namespace xrpl {
-
-class SponsorshipSet : public Transactor
-{
-public:
-    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
-
-    explicit SponsorshipSet(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-
-    void
-    visitInvariantEntry(
-        bool isDelete,
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after) override;
-
-    [[nodiscard]] bool
-    finalizeInvariants(
-        STTx const& tx,
-        TER result,
-        XRPAmount fee,
-        ReadView const& view,
-        beast::Journal const& j) override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/sponsor/SponsorshipTransfer.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/Transactor.h>
-
-#include <cstdint>
-#include <memory>
-
-namespace xrpl {
-
-class SponsorshipTransfer : public Transactor
-{
-public:
-    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
-
-    explicit SponsorshipTransfer(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-
-    void
-    visitInvariantEntry(
-        bool isDelete,
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after) override;
-
-    [[nodiscard]] bool
-    finalizeInvariants(
-        STTx const& tx,
-        TER result,
-        XRPAmount fee,
-        ReadView const& view,
-        beast::Journal const& j) override;
-};
-
-}  // namespace xrpl

include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h

@@ -76,7 +76,7 @@ public:
         beast::Journal const& j) override;
 
     static std::expected<MPTID, TER>
-    create(ApplyViewContext ctx, beast::Journal journal, MPTCreateArgs const& args);
+    create(ApplyView& view, beast::Journal journal, MPTCreateArgs const& args);
 };
 
 }  // namespace xrpl

nix/packages.nix

@@ -32,6 +32,15 @@ in
     perl # needed for openssl
     pkg-config
     pre-commit
+    # protoc generates the Go gRPC bindings and embeds its own version string into every committed
+    # .pb.go file. To allow CI to verify those files with a plain `git diff`, we pin the version to
+    # `protobuf_34` rather than the rolling `protobuf` to keep regeneration reproducible across the
+    # Nix frequently changing unstable channel. The protoc-gen-go* plugins have no versioned
+    # attributes in nixpkgs; protoc-gen-go's version is in turn constrained by the go.mod require
+    # on google.golang.org/protobuf.
+    protobuf_34 # provides protoc
+    protoc-gen-go # protoc plugin for the Go message bindings
+    protoc-gen-go-grpc # protoc plugin for the Go gRPC service stubs
     python3
     runClangTidy
     vim

src/libxrpl/basics/Number.cpp

@@ -876,7 +876,7 @@ Number::operator/=(Number const& y)
     int const ds = (dp ? -1 : 1);
     // Create the denominator as 128-bit unsigned, since that's what we
     // need to work with.
-    uint128_t const dm = static_cast<uint128_t>(y.mantissa_);
+    auto const dm = static_cast<uint128_t>(y.mantissa_);
     auto const de = y.exponent_;
 
     auto const& range = kRange.get();