Merge branch 'develop' into Bronek/fortify_pseudo_account

.clang-format

@@ -94,4 +94,3 @@ SpacesInSquareBrackets: false
 Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
-QualifierAlignment: Right

.github/CODEOWNERS

@@ -1,8 +0,0 @@
-# Allow anyone to review any change by default.
-*
-
-# Require the rpc-reviewers team to review changes to the rpc code.
-include/libxrpl/protocol/ @xrplf/rpc-reviewers
-src/libxrpl/protocol/ @xrplf/rpc-reviewers
-src/xrpld/rpc/ @xrplf/rpc-reviewers
-src/xrpld/app/misc/ @xrplf/rpc-reviewers

.github/workflows/clang-format.yml

@@ -1,13 +1,9 @@
 name: clang-format
 
-on:
-  push:
-  pull_request:
-    types: [opened, reopened, synchronize, ready_for_review]
+on: [push, pull_request]
 
 jobs:
   check:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-24.04
     env:
       CLANG_VERSION: 18

.github/workflows/doxygen.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     steps:
       - name: checkout
         uses: actions/checkout@v4

.github/workflows/levelization.yml

@@ -1,13 +1,9 @@
 name: levelization
 
-on:
-  push:
-  pull_request:
-    types: [opened, reopened, synchronize, ready_for_review]
+on: [push, pull_request]
 
 jobs:
   check:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-latest
     env:
       CLANG_VERSION: 10

.github/workflows/libxrpl.yml

@@ -8,21 +8,19 @@ on:
     paths:
       - 'src/libxrpl/protocol/BuildInfo.cpp'
       - '.github/workflows/libxrpl.yml'
-    types: [opened, reopened, synchronize, ready_for_review]
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
   publish:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     name: Publish libXRPL
     outputs:
       outcome: ${{ steps.upload.outputs.outcome }}
       version: ${{ steps.version.outputs.version }}
       channel: ${{ steps.channel.outputs.channel }}
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     steps:
       - name: Wait for essential checks to succeed
         uses: lewagon/wait-on-check-action@v1.3.4

.github/workflows/macos.yml

@@ -1,7 +1,6 @@
 name: macos
 on:
   pull_request:
-    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows, instrumentation)
@@ -19,7 +18,6 @@ concurrency:
 jobs:
 
   test:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       matrix:
         platform:
@@ -89,9 +87,8 @@ jobs:
           generator: ${{ matrix.generator }}
           configuration: ${{ matrix.configuration }}
           cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
-      # TODO: Temporary disabled tests
-      # - name: test
-      #   run: |
-      #     n=$(nproc)
-      #     echo "Using $n test jobs"
-      #     ${build_dir}/rippled --unittest --unittest-jobs $n
+      - name: test
+        run: |
+          n=$(nproc)
+          echo "Using $n test jobs"
+          ${build_dir}/rippled --unittest --unittest-jobs $n

.github/workflows/nix.yml

@@ -1,7 +1,6 @@
 name: nix
 on:
   pull_request:
-    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows)
@@ -40,7 +39,6 @@ concurrency:
 
 jobs:
   dependencies:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       fail-fast: false
       matrix:
@@ -64,7 +62,7 @@ jobs:
               cc: /usr/bin/clang-14
               cxx: /usr/bin/clang++-14
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -126,61 +124,7 @@ jobs:
           - "-Dunity=ON"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
-    env:
-      build_dir: .build
-    steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
-      - name: download cache
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
-      - name: extract cache
-        run: |
-          mkdir -p ~/.conan
-          tar -xzf conan.tar -C ~/.conan
-      - name: check environment
-        run: |
-          env | sort
-          echo ${PATH} | tr ':' '\n'
-          conan --version
-          cmake --version
-      - name: checkout
-        uses: actions/checkout@v4
-      - name: dependencies
-        uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-        with:
-          configuration: ${{ matrix.configuration }}
-      - name: build
-        uses: ./.github/actions/build
-        with:
-          generator: Ninja
-          configuration: ${{ matrix.configuration }}
-          cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
-      - name: test
-        run: |
-          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
-
-  reference-fee-test:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - linux
-        compiler:
-          - gcc
-        configuration:
-          - Debug
-        cmake-args:
-          - "-DUNIT_TEST_REFERENCE_FEE=200"
-          - "-DUNIT_TEST_REFERENCE_FEE=1000"
-    needs: dependencies
-    runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -231,7 +175,7 @@ jobs:
           - Debug
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -305,7 +249,7 @@ jobs:
   conan:
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
       configuration: Release
@@ -360,7 +304,6 @@ jobs:
   # later
 
   instrumentation-build:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     env:
       CLANG_RELEASE: 16
     strategy:

.github/workflows/windows.yml

@@ -2,7 +2,6 @@ name: windows
 
 on:
   pull_request:
-    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows, instrumentation)
@@ -22,7 +21,6 @@ concurrency:
 jobs:
 
   test:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       fail-fast: false
       matrix:

API-CHANGELOG.md

@@ -83,17 +83,9 @@ The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conve
 
 The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
 
-## XRP Ledger server version 2.5.0
-
-As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
-
-### Additions and bugfixes in 2.5.0
-
-- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled.
-
 ## XRP Ledger server version 2.4.0
 
-[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
+As of 2025-01-28, version 2.4.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
 
 ### Additions and bugfixes in 2.4.0
 

cmake/RippledCore.cmake

@@ -136,9 +136,6 @@ if(xrpld)
   add_executable(rippled)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
-    target_compile_definitions(rippled PRIVATE
-                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
-    )
   endif()
   target_include_directories(rippled
     PRIVATE

cmake/RippledSettings.cmake

@@ -11,12 +11,6 @@ option(assert "Enables asserts, even in release builds" OFF)
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if(tests)
-  # This setting allows making a separate workflow to test fees other than default 10
-  if(NOT UNIT_TEST_REFERENCE_FEE)
-    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-  endif()
-endif()
 
 option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)

include/xrpl/basics/BasicConfig.h

@@ -367,7 +367,7 @@ get(Section const& section,
 }
 
 inline std::string
-get(Section const& section, std::string const& name, char const* defaultValue)
+get(Section const& section, std::string const& name, const char* defaultValue)
 {
     try
     {

include/xrpl/basics/CompressionAlgorithms.h

@@ -55,7 +55,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
+        reinterpret_cast<const char*>(in),
         reinterpret_cast<char*>(compressed),
         inSize,
         outCapacity);
@@ -89,7 +89,7 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
+            reinterpret_cast<const char*>(in),
             reinterpret_cast<char*>(decompressed),
             inSize,
             decompressedSize) != decompressedSize)

include/xrpl/basics/Expected.h

@@ -93,7 +93,7 @@ public:
     {
     }
 
-    constexpr E const&
+    constexpr const E&
     value() const&
     {
         return val_;
@@ -111,7 +111,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr E const&&
+    constexpr const E&&
     value() const&&
     {
         return std::move(val_);

include/xrpl/basics/IntrusiveRefCounts.h

@@ -294,7 +294,7 @@ IntrusiveRefCounts::releaseStrongRef() const
         }
 
         if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
+                prevIntVal, nextIntVal, std::memory_order_release))
         {
             // Can't be in partial destroy because only decrementing the strong
             // count to zero can start a partial destroy, and that can't happen
@@ -351,7 +351,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
             }
         }
         if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
+                prevIntVal, nextIntVal, std::memory_order_release))
         {
             XRPL_ASSERT(
                 (!(prevIntVal & partialDestroyStartedMask)),
@@ -374,7 +374,7 @@ IntrusiveRefCounts::releaseWeakRef() const
             // This case should only be hit if the partialDestroyStartedBit is
             // set non-atomically (and even then very rarely). The code is kept
             // in case we need to set the flag non-atomically for perf reasons.
-            refCounts.wait(prevIntVal, std::memory_order_acquire);
+            refCounts.wait(prevIntVal, std::memory_order_acq_rel);
             prevIntVal = refCounts.load(std::memory_order_acquire);
             prev = RefCountPair{prevIntVal};
         }
@@ -382,7 +382,7 @@ IntrusiveRefCounts::releaseWeakRef() const
         {
             // partial destroy MUST finish before running a full destroy (when
             // using weak pointers)
-            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
+            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acq_rel);
         }
         return ReleaseWeakRefAction::destroy;
     }
@@ -396,7 +396,7 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
     auto desiredValue = RefCountPair{2, 1}.combinedValue();
 
     while (!refCounts.compare_exchange_weak(
-        curValue, desiredValue, std::memory_order_acq_rel))
+        curValue, desiredValue, std::memory_order_release))
     {
         RefCountPair const prev{curValue};
         if (!prev.strong)

include/xrpl/basics/TaggedCache.h

@@ -115,7 +115,7 @@ public:
     sweep();
 
     bool
-    del(key_type const& key, bool valid);
+    del(const key_type& key, bool valid);
 
 public:
     /** Replace aliased objects with originals.
@@ -134,20 +134,20 @@ public:
     template <class R>
     bool
     canonicalize(
-        key_type const& key,
+        const key_type& key,
         SharedPointerType& data,
         R&& replaceCallback);
 
     bool
     canonicalize_replace_cache(
-        key_type const& key,
+        const key_type& key,
         SharedPointerType const& data);
 
     bool
-    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
+    canonicalize_replace_client(const key_type& key, SharedPointerType& data);
 
     SharedPointerType
-    fetch(key_type const& key);
+    fetch(const key_type& key);
 
     /** Insert the element into the container.
         If the key already exists, nothing happens.
@@ -168,7 +168,7 @@ public:
     //             simply return an iterator.
     //
     bool
-    retrieve(key_type const& key, T& data);
+    retrieve(const key_type& key, T& data);
 
     mutex_type&
     peekMutex();
@@ -322,10 +322,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    int const m_target_size;
+    const int m_target_size;
 
     // Desired maximum cache age
-    clock_type::duration const m_target_age;
+    const clock_type::duration m_target_age;
 
     // Number of items cached
     int m_cache_count;

include/xrpl/basics/TaggedCache.ipp

@@ -365,7 +365,7 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::del(key_type const& key, bool valid)
+    Mutex>::del(const key_type& key, bool valid)
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
@@ -414,7 +414,7 @@ TaggedCache<
     KeyEqual,
     Mutex>::
     canonicalize(
-        key_type const& key,
+        const key_type& key,
         SharedPointerType& data,
         R&& replaceCallback)
 {
@@ -509,7 +509,7 @@ TaggedCache<
     KeyEqual,
     Mutex>::
     canonicalize_replace_cache(
-        key_type const& key,
+        const key_type& key,
         SharedPointerType const& data)
 {
     return canonicalize(
@@ -535,7 +535,7 @@ TaggedCache<
     Hash,
     KeyEqual,
     Mutex>::
-    canonicalize_replace_client(key_type const& key, SharedPointerType& data)
+    canonicalize_replace_client(const key_type& key, SharedPointerType& data)
 {
     return canonicalize(key, data, []() { return false; });
 }
@@ -558,7 +558,7 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::fetch(key_type const& key)
+    Mutex>::fetch(const key_type& key)
 {
     std::lock_guard<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
@@ -656,7 +656,7 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::retrieve(key_type const& key, T& data)
+    Mutex>::retrieve(const key_type& key, T& data)
 {
     // retrieve the value of the stored data
     auto entry = fetch(key);

include/xrpl/basics/base_uint.h

@@ -374,7 +374,7 @@ public:
     }
 
     base_uint&
-    operator^=(base_uint const& b)
+    operator^=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -383,7 +383,7 @@ public:
     }
 
     base_uint&
-    operator&=(base_uint const& b)
+    operator&=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
@@ -392,7 +392,7 @@ public:
     }
 
     base_uint&
-    operator|=(base_uint const& b)
+    operator|=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] |= b.data_[i];
@@ -415,11 +415,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator++(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         ++(*this);
 
         return ret;
@@ -441,11 +441,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator--(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         --(*this);
 
         return ret;
@@ -466,7 +466,7 @@ public:
     }
 
     base_uint&
-    operator+=(base_uint const& b)
+    operator+=(const base_uint& b)
     {
         std::uint64_t carry = 0;
 
@@ -511,7 +511,7 @@ public:
     }
 
     [[nodiscard]] constexpr bool
-    parseHex(char const* str)
+    parseHex(const char* str)
     {
         return parseHex(std::string_view{str});
     }
@@ -632,13 +632,6 @@ to_string(base_uint<Bits, Tag> const& a)
     return strHex(a.cbegin(), a.cend());
 }
 
-template <std::size_t Bits, class Tag>
-inline std::string
-to_short_string(base_uint<Bits, Tag> const& a)
-{
-    return to_string(a).substr(0, 8) + "...";
-}
-
 template <std::size_t Bits, class Tag>
 inline std::ostream&
 operator<<(std::ostream& out, base_uint<Bits, Tag> const& u)

include/xrpl/basics/comparators.h

@@ -43,7 +43,7 @@ struct less
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::equal_to<T>()(left, right);
     }

include/xrpl/basics/partitioned_unordered_map.h

@@ -52,7 +52,7 @@ template <
     typename Value,
     typename Hash,
     typename Pred = std::equal_to<Key>,
-    typename Alloc = std::allocator<std::pair<Key const, Value>>>
+    typename Alloc = std::allocator<std::pair<const Key, Value>>>
 class partitioned_unordered_map
 {
     std::size_t partitions_;

include/xrpl/basics/tagged_integer.h

@@ -76,13 +76,13 @@ public:
     }
 
     bool
-    operator<(tagged_integer const& rhs) const noexcept
+    operator<(const tagged_integer& rhs) const noexcept
     {
         return m_value < rhs.m_value;
     }
 
     bool
-    operator==(tagged_integer const& rhs) const noexcept
+    operator==(const tagged_integer& rhs) const noexcept
     {
         return m_value == rhs.m_value;
     }
@@ -144,14 +144,14 @@ public:
     }
 
     tagged_integer&
-    operator<<=(tagged_integer const& rhs) noexcept
+    operator<<=(const tagged_integer& rhs) noexcept
     {
         m_value <<= rhs.m_value;
         return *this;
     }
 
     tagged_integer&
-    operator>>=(tagged_integer const& rhs) noexcept
+    operator>>=(const tagged_integer& rhs) noexcept
     {
         m_value >>= rhs.m_value;
         return *this;

include/xrpl/beast/utility/instrumentation.h

@@ -39,16 +39,11 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #endif
 
 #define XRPL_ASSERT ALWAYS_OR_UNREACHABLE
-#define XRPL_ASSERT_PARTS(cond, function, description, ...) \
-    XRPL_ASSERT(cond, function " : " description)
 
 // How to use the instrumentation macros:
 //
 // * XRPL_ASSERT if cond must be true but the line might not be reached during
 //   fuzzing. Same like `assert` in normal use.
-// * XRPL_ASSERT_PARTS is for convenience, and works like XRPL_ASSERT, but
-//   splits the message param into "function" and "description", then joins
-//   them with " : " before passing to XRPL_ASSERT.
 // * ALWAYS if cond must be true _and_ the line must be reached during fuzzing.
 //   Same like `assert` in normal use.
 // * REACHABLE if the line must be reached during fuzzing

include/xrpl/beast/utility/temp_dir.h

@@ -37,9 +37,9 @@ class temp_dir
 
 public:
 #if !GENERATING_DOCS
-    temp_dir(temp_dir const&) = delete;
+    temp_dir(const temp_dir&) = delete;
     temp_dir&
-    operator=(temp_dir const&) = delete;
+    operator=(const temp_dir&) = delete;
 #endif
 
     /// Construct a temporary directory.

include/xrpl/json/json_reader.h

@@ -39,7 +39,7 @@ class Reader
 {
 public:
     using Char = char;
-    using Location = Char const*;
+    using Location = const Char*;
 
     /** \brief Constructs a Reader allowing all features
      * for parsing.
@@ -64,7 +64,7 @@ public:
      * error occurred.
      */
     bool
-    parse(char const* beginDoc, char const* endDoc, Value& root);
+    parse(const char* beginDoc, const char* endDoc, Value& root);
 
     /// \brief Parse from input stream.
     /// \see Json::operator>>(std::istream&, Json::Value&).
@@ -133,7 +133,7 @@ private:
     using Errors = std::deque<ErrorInfo>;
 
     bool
-    expectToken(TokenType type, Token& token, char const* message);
+    expectToken(TokenType type, Token& token, const char* message);
     bool
     readToken(Token& token);
     void

include/xrpl/json/json_value.h

@@ -20,13 +20,11 @@
 #ifndef RIPPLE_JSON_JSON_VALUE_H_INCLUDED
 #define RIPPLE_JSON_JSON_VALUE_H_INCLUDED
 
-#include <xrpl/basics/Number.h>
 #include <xrpl/json/json_forwards.h>
 
 #include <cstring>
 #include <map>
 #include <string>
-#include <utility>
 #include <vector>
 
 /** \brief JSON (JavaScript Object Notation).
@@ -63,24 +61,24 @@ enum ValueType {
 class StaticString
 {
 public:
-    constexpr explicit StaticString(char const* czstring) : str_(czstring)
+    constexpr explicit StaticString(const char* czstring) : str_(czstring)
     {
     }
 
     constexpr
-    operator char const*() const
+    operator const char*() const
     {
         return str_;
     }
 
-    constexpr char const*
+    constexpr const char*
     c_str() const
     {
         return str_;
     }
 
 private:
-    char const* str_;
+    const char* str_;
 };
 
 inline bool
@@ -158,10 +156,10 @@ public:
     using Int = Json::Int;
     using ArrayIndex = UInt;
 
-    static Value const null;
-    static Int const minInt;
-    static Int const maxInt;
-    static UInt const maxUInt;
+    static const Value null;
+    static const Int minInt;
+    static const Int maxInt;
+    static const UInt maxUInt;
 
 private:
     class CZString
@@ -173,24 +171,24 @@ private:
             duplicateOnCopy
         };
         CZString(int index);
-        CZString(char const* cstr, DuplicationPolicy allocate);
-        CZString(CZString const& other);
+        CZString(const char* cstr, DuplicationPolicy allocate);
+        CZString(const CZString& other);
         ~CZString();
         CZString&
-        operator=(CZString const& other) = delete;
+        operator=(const CZString& other) = delete;
         bool
-        operator<(CZString const& other) const;
+        operator<(const CZString& other) const;
         bool
-        operator==(CZString const& other) const;
+        operator==(const CZString& other) const;
         int
         index() const;
-        char const*
+        const char*
         c_str() const;
         bool
         isStaticString() const;
 
     private:
-        char const* cstr_;
+        const char* cstr_;
         int index_;
     };
 
@@ -217,8 +215,7 @@ public:
     Value(Int value);
     Value(UInt value);
     Value(double value);
-    Value(char const* value);
-    Value(ripple::Number const& value);
+    Value(const char* value);
     /** \brief Constructs a value from a static string.
 
      * Like other value string constructor but do not duplicate the string for
@@ -230,10 +227,10 @@ public:
      * Json::Value aValue( StaticString("some text") );
      * \endcode
      */
-    Value(StaticString const& value);
+    Value(const StaticString& value);
     Value(std::string const& value);
     Value(bool value);
-    Value(Value const& other);
+    Value(const Value& other);
     ~Value();
 
     Value&
@@ -250,7 +247,7 @@ public:
     ValueType
     type() const;
 
-    char const*
+    const char*
     asCString() const;
     /** Returns the unquoted string value. */
     std::string
@@ -320,12 +317,12 @@ public:
     /// Access an array element (zero based index )
     /// (You may need to say 'value[0u]' to get your compiler to distinguish
     ///  this from the operator[] which takes a string.)
-    Value const&
+    const Value&
     operator[](UInt index) const;
     /// If the array contains at least index+1 elements, returns the element
     /// value, otherwise returns defaultValue.
     Value
-    get(UInt index, Value const& defaultValue) const;
+    get(UInt index, const Value& defaultValue) const;
     /// Return true if index < size().
     bool
     isValidIndex(UInt index) const;
@@ -333,25 +330,25 @@ public:
     ///
     /// Equivalent to jsonvalue[jsonvalue.size()] = value;
     Value&
-    append(Value const& value);
+    append(const Value& value);
     Value&
     append(Value&& value);
 
     /// Access an object value by name, create a null member if it does not
     /// exist.
     Value&
-    operator[](char const* key);
+    operator[](const char* key);
     /// Access an object value by name, returns null if there is no member with
     /// that name.
-    Value const&
-    operator[](char const* key) const;
+    const Value&
+    operator[](const char* key) const;
     /// Access an object value by name, create a null member if it does not
     /// exist.
     Value&
     operator[](std::string const& key);
     /// Access an object value by name, returns null if there is no member with
     /// that name.
-    Value const&
+    const Value&
     operator[](std::string const& key) const;
     /** \brief Access an object value by name, create a null member if it does
      not exist.
@@ -367,16 +364,14 @@ public:
      * \endcode
      */
     Value&
-    operator[](StaticString const& key);
-    Value const&
-    operator[](StaticString const& key) const;
+    operator[](const StaticString& key);
 
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(char const* key, Value const& defaultValue) const;
+    get(const char* key, const Value& defaultValue) const;
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(std::string const& key, Value const& defaultValue) const;
+    get(std::string const& key, const Value& defaultValue) const;
 
     /// \brief Remove and return the named member.
     ///
@@ -385,14 +380,14 @@ public:
     /// \pre type() is objectValue or nullValue
     /// \post type() is unchanged
     Value
-    removeMember(char const* key);
+    removeMember(const char* key);
     /// Same as removeMember(const char*)
     Value
     removeMember(std::string const& key);
 
     /// Return true if the object has a member named key.
     bool
-    isMember(char const* key) const;
+    isMember(const char* key) const;
     /// Return true if the object has a member named key.
     bool
     isMember(std::string const& key) const;
@@ -419,13 +414,13 @@ public:
     end();
 
     friend bool
-    operator==(Value const&, Value const&);
+    operator==(const Value&, const Value&);
     friend bool
-    operator<(Value const&, Value const&);
+    operator<(const Value&, const Value&);
 
 private:
     Value&
-    resolveReference(char const* key, bool isStatic);
+    resolveReference(const char* key, bool isStatic);
 
 private:
     union ValueHolder
@@ -441,38 +436,32 @@ private:
     int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
 };
 
-inline Value
-to_json(ripple::Number const& number)
-{
-    return to_string(number);
-}
-
 bool
-operator==(Value const&, Value const&);
+operator==(const Value&, const Value&);
 
 inline bool
-operator!=(Value const& x, Value const& y)
+operator!=(const Value& x, const Value& y)
 {
     return !(x == y);
 }
 
 bool
-operator<(Value const&, Value const&);
+operator<(const Value&, const Value&);
 
 inline bool
-operator<=(Value const& x, Value const& y)
+operator<=(const Value& x, const Value& y)
 {
     return !(y < x);
 }
 
 inline bool
-operator>(Value const& x, Value const& y)
+operator>(const Value& x, const Value& y)
 {
     return y < x;
 }
 
 inline bool
-operator>=(Value const& x, Value const& y)
+operator>=(const Value& x, const Value& y)
 {
     return !(x < y);
 }
@@ -493,11 +482,11 @@ public:
     virtual ~ValueAllocator() = default;
 
     virtual char*
-    makeMemberName(char const* memberName) = 0;
+    makeMemberName(const char* memberName) = 0;
     virtual void
     releaseMemberName(char* memberName) = 0;
     virtual char*
-    duplicateStringValue(char const* value, unsigned int length = unknown) = 0;
+    duplicateStringValue(const char* value, unsigned int length = unknown) = 0;
     virtual void
     releaseStringValue(char* value) = 0;
 };
@@ -514,16 +503,16 @@ public:
 
     ValueIteratorBase();
 
-    explicit ValueIteratorBase(Value::ObjectValues::iterator const& current);
+    explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
 
     bool
-    operator==(SelfType const& other) const
+    operator==(const SelfType& other) const
     {
         return isEqual(other);
     }
 
     bool
-    operator!=(SelfType const& other) const
+    operator!=(const SelfType& other) const
     {
         return !isEqual(other);
     }
@@ -539,7 +528,7 @@ public:
 
     /// Return the member name of the referenced Value. "" if it is not an
     /// objectValue.
-    char const*
+    const char*
     memberName() const;
 
 protected:
@@ -553,13 +542,13 @@ protected:
     decrement();
 
     difference_type
-    computeDistance(SelfType const& other) const;
+    computeDistance(const SelfType& other) const;
 
     bool
-    isEqual(SelfType const& other) const;
+    isEqual(const SelfType& other) const;
 
     void
-    copy(SelfType const& other);
+    copy(const SelfType& other);
 
 private:
     Value::ObjectValues::iterator current_;
@@ -577,8 +566,8 @@ class ValueConstIterator : public ValueIteratorBase
 public:
     using size_t = unsigned int;
     using difference_type = int;
-    using reference = Value const&;
-    using pointer = Value const*;
+    using reference = const Value&;
+    using pointer = const Value*;
     using SelfType = ValueConstIterator;
 
     ValueConstIterator() = default;
@@ -586,11 +575,11 @@ public:
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueConstIterator(Value::ObjectValues::iterator const& current);
+    explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
 
 public:
     SelfType&
-    operator=(ValueIteratorBase const& other);
+    operator=(const ValueIteratorBase& other);
 
     SelfType
     operator++(int)
@@ -643,17 +632,17 @@ public:
     using SelfType = ValueIterator;
 
     ValueIterator() = default;
-    ValueIterator(ValueConstIterator const& other);
-    ValueIterator(ValueIterator const& other);
+    ValueIterator(const ValueConstIterator& other);
+    ValueIterator(const ValueIterator& other);
 
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueIterator(Value::ObjectValues::iterator const& current);
+    explicit ValueIterator(const Value::ObjectValues::iterator& current);
 
 public:
     SelfType&
-    operator=(SelfType const& other);
+    operator=(const SelfType& other);
 
     SelfType
     operator++(int)

include/xrpl/json/json_writer.h

@@ -39,7 +39,7 @@ public:
     {
     }
     virtual std::string
-    write(Value const& root) = 0;
+    write(const Value& root) = 0;
 };
 
 /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
@@ -60,11 +60,11 @@ public:
 
 public:  // overridden from Writer
     std::string
-    write(Value const& root) override;
+    write(const Value& root) override;
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
 
     std::string document_;
 };
@@ -101,15 +101,15 @@ public:  // overridden from Writer
      * JSON document that represents the root value.
      */
     std::string
-    write(Value const& root) override;
+    write(const Value& root) override;
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
     void
-    writeArrayValue(Value const& value);
+    writeArrayValue(const Value& value);
     bool
-    isMultineArray(Value const& value);
+    isMultineArray(const Value& value);
     void
     pushValue(std::string const& value);
     void
@@ -168,15 +168,15 @@ public:
      * return a value.
      */
     void
-    write(std::ostream& out, Value const& root);
+    write(std::ostream& out, const Value& root);
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
     void
-    writeArrayValue(Value const& value);
+    writeArrayValue(const Value& value);
     bool
-    isMultineArray(Value const& value);
+    isMultineArray(const Value& value);
     void
     pushValue(std::string const& value);
     void
@@ -207,12 +207,12 @@ valueToString(double value);
 std::string
 valueToString(bool value);
 std::string
-valueToQuotedString(char const* value);
+valueToQuotedString(const char* value);
 
 /// \brief Output using the StyledStreamWriter.
 /// \see Json::operator>>()
 std::ostream&
-operator<<(std::ostream&, Value const& root);
+operator<<(std::ostream&, const Value& root);
 
 //------------------------------------------------------------------------------
 

include/xrpl/json/to_string.h

@@ -37,7 +37,7 @@ pretty(Value const&);
 
 /** Output using the StyledStreamWriter. @see Json::operator>>(). */
 std::ostream&
-operator<<(std::ostream&, Value const& root);
+operator<<(std::ostream&, const Value& root);
 
 }  // namespace Json
 

include/xrpl/protocol/Asset.h

@@ -20,7 +20,6 @@
 #ifndef RIPPLE_PROTOCOL_ASSET_H_INCLUDED
 #define RIPPLE_PROTOCOL_ASSET_H_INCLUDED
 
-#include <xrpl/basics/Number.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/MPTIssue.h>
@@ -28,7 +27,6 @@
 namespace ripple {
 
 class Asset;
-class STAmount;
 
 template <typename TIss>
 concept ValidIssueType =
@@ -94,9 +92,6 @@ public:
     void
     setJson(Json::Value& jv) const;
 
-    STAmount
-    operator()(Number const&) const;
-
     bool
     native() const
     {
@@ -119,14 +114,6 @@ public:
     equalTokens(Asset const& lhs, Asset const& rhs);
 };
 
-inline Json::Value
-to_json(Asset const& asset)
-{
-    Json::Value jv;
-    asset.setJson(jv);
-    return jv;
-}
-
 template <ValidIssueType TIss>
 constexpr bool
 Asset::holds() const
@@ -232,6 +219,9 @@ validJSONAsset(Json::Value const& jv);
 Asset
 assetFromJson(Json::Value const& jv);
 
+Json::Value
+to_json(Asset const& asset);
+
 }  // namespace ripple
 
 #endif  // RIPPLE_PROTOCOL_ASSET_H_INCLUDED

include/xrpl/protocol/ErrorCodes.h

@@ -120,7 +120,7 @@ enum error_code_i {
     rpcSRC_ACT_MALFORMED = 65,
     rpcSRC_ACT_MISSING = 66,
     rpcSRC_ACT_NOT_FOUND = 67,
-    rpcDELEGATE_ACT_NOT_FOUND = 68,
+    // unused                  68,
     rpcSRC_CUR_MALFORMED = 69,
     rpcSRC_ISR_MALFORMED = 70,
     rpcSTREAM_MALFORMED = 71,

include/xrpl/protocol/FeeUnits.h

@@ -16,8 +16,8 @@
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#ifndef PROTOCOL_UNITS_H_INCLUDED
-#define PROTOCOL_UNITS_H_INCLUDED
+#ifndef BASICS_FEES_H_INCLUDED
+#define BASICS_FEES_H_INCLUDED
 
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/utility/Zero.h>
@@ -38,23 +38,23 @@
 
 namespace ripple {
 
-namespace unit {
+namespace feeunit {
 
 /** "drops" are the smallest divisible amount of XRP. This is what most
     of the code uses. */
 struct dropTag;
+/** "fee units" calculations are a not-really-unitless value that is used
+    to express the cost of a given transaction vs. a reference transaction.
+    They are primarily used by the Transactor classes. */
+struct feeunitTag;
 /** "fee levels" are used by the transaction queue to compare the relative
     cost of transactions that require different levels of effort to process.
     See also: src/ripple/app/misc/FeeEscalation.md#fee-level */
 struct feelevelTag;
-/** unitless values are plain scalars wrapped in a ValueUnit. They are
+/** unitless values are plain scalars wrapped in a TaggedFee. They are
     used for calculations in this header. */
 struct unitlessTag;
 
-/** Units to represent basis points (bips) and 1/10 basis points */
-class BipsTag;
-class TenthBipsTag;
-
 template <class T>
 using enable_if_unit_t = typename std::enable_if_t<
     std::is_class_v<T> && std::is_object_v<typename T::unit_type> &&
@@ -62,33 +62,32 @@ using enable_if_unit_t = typename std::enable_if_t<
 
 /** `is_usable_unit_v` is checked to ensure that only values with
     known valid type tags can be used (sometimes transparently) in
-    non-unit contexts. At the time of implementation, this includes
+    non-fee contexts. At the time of implementation, this includes
     all known tags, but more may be added in the future, and they
     should not be added automatically unless determined to be
     appropriate.
 */
 template <class T, class = enable_if_unit_t<T>>
 constexpr bool is_usable_unit_v =
+    std::is_same_v<typename T::unit_type, feeunitTag> ||
     std::is_same_v<typename T::unit_type, feelevelTag> ||
     std::is_same_v<typename T::unit_type, unitlessTag> ||
-    std::is_same_v<typename T::unit_type, dropTag> ||
-    std::is_same_v<typename T::unit_type, BipsTag> ||
-    std::is_same_v<typename T::unit_type, TenthBipsTag>;
+    std::is_same_v<typename T::unit_type, dropTag>;
 
 template <class UnitTag, class T>
-class ValueUnit : private boost::totally_ordered<ValueUnit<UnitTag, T>>,
-                  private boost::additive<ValueUnit<UnitTag, T>>,
-                  private boost::equality_comparable<ValueUnit<UnitTag, T>, T>,
-                  private boost::dividable<ValueUnit<UnitTag, T>, T>,
-                  private boost::modable<ValueUnit<UnitTag, T>, T>,
-                  private boost::unit_steppable<ValueUnit<UnitTag, T>>
+class TaggedFee : private boost::totally_ordered<TaggedFee<UnitTag, T>>,
+                  private boost::additive<TaggedFee<UnitTag, T>>,
+                  private boost::equality_comparable<TaggedFee<UnitTag, T>, T>,
+                  private boost::dividable<TaggedFee<UnitTag, T>, T>,
+                  private boost::modable<TaggedFee<UnitTag, T>, T>,
+                  private boost::unit_steppable<TaggedFee<UnitTag, T>>
 {
 public:
     using unit_type = UnitTag;
     using value_type = T;
 
 private:
-    value_type value_;
+    value_type fee_;
 
 protected:
     template <class Other>
@@ -96,44 +95,44 @@ protected:
         std::is_arithmetic_v<Other> && std::is_arithmetic_v<value_type> &&
         std::is_convertible_v<Other, value_type>;
 
-    template <class OtherValue, class = enable_if_unit_t<OtherValue>>
-    static constexpr bool is_compatiblevalue_v =
-        is_compatible_v<typename OtherValue::value_type> &&
-        std::is_same_v<UnitTag, typename OtherValue::unit_type>;
+    template <class OtherFee, class = enable_if_unit_t<OtherFee>>
+    static constexpr bool is_compatiblefee_v =
+        is_compatible_v<typename OtherFee::value_type> &&
+        std::is_same_v<UnitTag, typename OtherFee::unit_type>;
 
     template <class Other>
     using enable_if_compatible_t =
         typename std::enable_if_t<is_compatible_v<Other>>;
 
-    template <class OtherValue>
-    using enable_if_compatiblevalue_t =
-        typename std::enable_if_t<is_compatiblevalue_v<OtherValue>>;
+    template <class OtherFee>
+    using enable_if_compatiblefee_t =
+        typename std::enable_if_t<is_compatiblefee_v<OtherFee>>;
 
 public:
-    ValueUnit() = default;
-    constexpr ValueUnit(ValueUnit const& other) = default;
-    constexpr ValueUnit&
-    operator=(ValueUnit const& other) = default;
+    TaggedFee() = default;
+    constexpr TaggedFee(TaggedFee const& other) = default;
+    constexpr TaggedFee&
+    operator=(TaggedFee const& other) = default;
 
-    constexpr explicit ValueUnit(beast::Zero) : value_(0)
+    constexpr explicit TaggedFee(beast::Zero) : fee_(0)
     {
     }
 
-    constexpr ValueUnit&
+    constexpr TaggedFee&
     operator=(beast::Zero)
     {
-        value_ = 0;
+        fee_ = 0;
         return *this;
     }
 
-    constexpr explicit ValueUnit(value_type value) : value_(value)
+    constexpr explicit TaggedFee(value_type fee) : fee_(fee)
     {
     }
 
-    constexpr ValueUnit&
-    operator=(value_type value)
+    TaggedFee&
+    operator=(value_type fee)
     {
-        value_ = value;
+        fee_ = fee;
         return *this;
     }
 
@@ -145,181 +144,153 @@ public:
         class = std::enable_if_t<
             is_compatible_v<Other> &&
             is_safetocasttovalue_v<value_type, Other>>>
-    constexpr ValueUnit(ValueUnit<unit_type, Other> const& value)
-        : ValueUnit(safe_cast<value_type>(value.value()))
+    constexpr TaggedFee(TaggedFee<unit_type, Other> const& fee)
+        : TaggedFee(safe_cast<value_type>(fee.fee()))
     {
     }
 
-    constexpr ValueUnit
-    operator+(value_type const& rhs) const
-    {
-        return ValueUnit{value_ + rhs};
-    }
-
-    friend constexpr ValueUnit
-    operator+(value_type lhs, ValueUnit const& rhs)
-    {
-        // addition is commutative
-        return rhs + lhs;
-    }
-
-    constexpr ValueUnit
-    operator-(value_type const& rhs) const
-    {
-        return ValueUnit{value_ - rhs};
-    }
-
-    friend constexpr ValueUnit
-    operator-(value_type lhs, ValueUnit const& rhs)
-    {
-        // subtraction is NOT commutative, but (lhs + (-rhs)) is addition, which
-        // is
-        return -rhs + lhs;
-    }
-
-    constexpr ValueUnit
+    constexpr TaggedFee
     operator*(value_type const& rhs) const
     {
-        return ValueUnit{value_ * rhs};
+        return TaggedFee{fee_ * rhs};
     }
 
-    friend constexpr ValueUnit
-    operator*(value_type lhs, ValueUnit const& rhs)
+    friend constexpr TaggedFee
+    operator*(value_type lhs, TaggedFee const& rhs)
     {
         // multiplication is commutative
         return rhs * lhs;
     }
 
     constexpr value_type
-    operator/(ValueUnit const& rhs) const
+    operator/(TaggedFee const& rhs) const
     {
-        return value_ / rhs.value_;
+        return fee_ / rhs.fee_;
     }
 
-    ValueUnit&
-    operator+=(ValueUnit const& other)
+    TaggedFee&
+    operator+=(TaggedFee const& other)
     {
-        value_ += other.value();
+        fee_ += other.fee();
         return *this;
     }
 
-    ValueUnit&
-    operator-=(ValueUnit const& other)
+    TaggedFee&
+    operator-=(TaggedFee const& other)
     {
-        value_ -= other.value();
+        fee_ -= other.fee();
         return *this;
     }
 
-    ValueUnit&
+    TaggedFee&
     operator++()
     {
-        ++value_;
+        ++fee_;
         return *this;
     }
 
-    ValueUnit&
+    TaggedFee&
     operator--()
     {
-        --value_;
+        --fee_;
         return *this;
     }
 
-    ValueUnit&
+    TaggedFee&
     operator*=(value_type const& rhs)
     {
-        value_ *= rhs;
+        fee_ *= rhs;
         return *this;
     }
 
-    ValueUnit&
+    TaggedFee&
     operator/=(value_type const& rhs)
     {
-        value_ /= rhs;
+        fee_ /= rhs;
         return *this;
     }
 
     template <class transparent = value_type>
-    std::enable_if_t<std::is_integral_v<transparent>, ValueUnit&>
+    std::enable_if_t<std::is_integral_v<transparent>, TaggedFee&>
     operator%=(value_type const& rhs)
     {
-        value_ %= rhs;
+        fee_ %= rhs;
         return *this;
     }
 
-    ValueUnit
+    TaggedFee
     operator-() const
     {
         static_assert(
-            std::is_signed_v<T>, "- operator illegal on unsigned value types");
-        return ValueUnit{-value_};
+            std::is_signed_v<T>, "- operator illegal on unsigned fee types");
+        return TaggedFee{-fee_};
     }
 
-    constexpr bool
-    operator==(ValueUnit const& other) const
+    bool
+    operator==(TaggedFee const& other) const
     {
-        return value_ == other.value_;
+        return fee_ == other.fee_;
     }
 
     template <class Other, class = enable_if_compatible_t<Other>>
-    constexpr bool
-    operator==(ValueUnit<unit_type, Other> const& other) const
+    bool
+    operator==(TaggedFee<unit_type, Other> const& other) const
     {
-        return value_ == other.value();
+        return fee_ == other.fee();
     }
 
-    constexpr bool
+    bool
     operator==(value_type other) const
     {
-        return value_ == other;
+        return fee_ == other;
     }
 
     template <class Other, class = enable_if_compatible_t<Other>>
-    constexpr bool
-    operator!=(ValueUnit<unit_type, Other> const& other) const
+    bool
+    operator!=(TaggedFee<unit_type, Other> const& other) const
     {
         return !operator==(other);
     }
 
-    constexpr bool
-    operator<(ValueUnit const& other) const
+    bool
+    operator<(TaggedFee const& other) const
     {
-        return value_ < other.value_;
+        return fee_ < other.fee_;
     }
 
     /** Returns true if the amount is not zero */
     explicit constexpr
     operator bool() const noexcept
     {
-        return value_ != 0;
+        return fee_ != 0;
     }
 
     /** Return the sign of the amount */
     constexpr int
     signum() const noexcept
     {
-        return (value_ < 0) ? -1 : (value_ ? 1 : 0);
+        return (fee_ < 0) ? -1 : (fee_ ? 1 : 0);
     }
 
     /** Returns the number of drops */
-    // TODO: Move this to a new class, maybe with the old "TaggedFee" name
     constexpr value_type
     fee() const
     {
-        return value_;
+        return fee_;
     }
 
     template <class Other>
     constexpr double
-    decimalFromReference(ValueUnit<unit_type, Other> reference) const
+    decimalFromReference(TaggedFee<unit_type, Other> reference) const
     {
-        return static_cast<double>(value_) / reference.value();
+        return static_cast<double>(fee_) / reference.fee();
     }
 
     // `is_usable_unit_v` is checked to ensure that only values with
     // known valid type tags can be converted to JSON. At the time
     // of implementation, that includes all known tags, but more may
     // be added in the future.
-    std::enable_if_t<is_usable_unit_v<ValueUnit>, Json::Value>
+    std::enable_if_t<is_usable_unit_v<TaggedFee>, Json::Value>
     jsonClipped() const
     {
         if constexpr (std::is_integral_v<value_type>)
@@ -332,15 +303,15 @@ public:
             constexpr auto min = std::numeric_limits<jsontype>::min();
             constexpr auto max = std::numeric_limits<jsontype>::max();
 
-            if (value_ < min)
+            if (fee_ < min)
                 return min;
-            if (value_ > max)
+            if (fee_ > max)
                 return max;
-            return static_cast<jsontype>(value_);
+            return static_cast<jsontype>(fee_);
         }
         else
         {
-            return value_;
+            return fee_;
         }
     }
 
@@ -351,30 +322,30 @@ public:
     constexpr value_type
     value() const
     {
-        return value_;
+        return fee_;
     }
 
     friend std::istream&
-    operator>>(std::istream& s, ValueUnit& val)
+    operator>>(std::istream& s, TaggedFee& val)
     {
-        s >> val.value_;
+        s >> val.fee_;
         return s;
     }
 };
 
-// Output Values as just their numeric value.
+// Output Fees as just their numeric value.
 template <class Char, class Traits, class UnitTag, class T>
 std::basic_ostream<Char, Traits>&
-operator<<(std::basic_ostream<Char, Traits>& os, ValueUnit<UnitTag, T> const& q)
+operator<<(std::basic_ostream<Char, Traits>& os, const TaggedFee<UnitTag, T>& q)
 {
     return os << q.value();
 }
 
 template <class UnitTag, class T>
 std::string
-to_string(ValueUnit<UnitTag, T> const& amount)
+to_string(TaggedFee<UnitTag, T> const& amount)
 {
-    return std::to_string(amount.value());
+    return std::to_string(amount.fee());
 }
 
 template <class Source, class = enable_if_unit_t<Source>>
@@ -437,10 +408,10 @@ using enable_muldiv_commute_t =
     typename std::enable_if_t<can_muldiv_commute_v<Source1, Source2, Dest>>;
 
 template <class T>
-ValueUnit<unitlessTag, T>
+TaggedFee<unitlessTag, T>
 scalar(T value)
 {
-    return ValueUnit<unitlessTag, T>{value};
+    return TaggedFee<unitlessTag, T>{value};
 }
 
 template <
@@ -451,17 +422,18 @@ template <
 std::optional<Dest>
 mulDivU(Source1 value, Dest mul, Source2 div)
 {
-    // values can never be negative in any context.
+    // Fees can never be negative in any context.
     if (value.value() < 0 || mul.value() < 0 || div.value() < 0)
     {
         // split the asserts so if one hits, the user can tell which
         // without a debugger.
         XRPL_ASSERT(
-            value.value() >= 0, "ripple::unit::mulDivU : minimum value input");
+            value.value() >= 0,
+            "ripple::feeunit::mulDivU : minimum value input");
         XRPL_ASSERT(
-            mul.value() >= 0, "ripple::unit::mulDivU : minimum mul input");
+            mul.value() >= 0, "ripple::feeunit::mulDivU : minimum mul input");
         XRPL_ASSERT(
-            div.value() >= 0, "ripple::unit::mulDivU : minimum div input");
+            div.value() >= 0, "ripple::feeunit::mulDivU : minimum div input");
         return std::nullopt;
     }
 
@@ -494,57 +466,46 @@ mulDivU(Source1 value, Dest mul, Source2 div)
     return Dest{static_cast<desttype>(quotient)};
 }
 
-}  // namespace unit
+}  // namespace feeunit
 
-// Fee Levels
 template <class T>
-using FeeLevel = unit::ValueUnit<unit::feelevelTag, T>;
+using FeeLevel = feeunit::TaggedFee<feeunit::feelevelTag, T>;
 using FeeLevel64 = FeeLevel<std::uint64_t>;
 using FeeLevelDouble = FeeLevel<double>;
 
-// Basis points (Bips)
-template <class T>
-using Bips = unit::ValueUnit<unit::BipsTag, T>;
-using Bips16 = Bips<std::uint16_t>;
-using Bips32 = Bips<std::uint32_t>;
-template <class T>
-using TenthBips = unit::ValueUnit<unit::TenthBipsTag, T>;
-using TenthBips16 = TenthBips<std::uint16_t>;
-using TenthBips32 = TenthBips<std::uint32_t>;
-
 template <
     class Source1,
     class Source2,
     class Dest,
-    class = unit::enable_muldiv_t<Source1, Source2, Dest>>
+    class = feeunit::enable_muldiv_t<Source1, Source2, Dest>>
 std::optional<Dest>
 mulDiv(Source1 value, Dest mul, Source2 div)
 {
-    return unit::mulDivU(value, mul, div);
+    return feeunit::mulDivU(value, mul, div);
 }
 
 template <
     class Source1,
     class Source2,
     class Dest,
-    class = unit::enable_muldiv_commute_t<Source1, Source2, Dest>>
+    class = feeunit::enable_muldiv_commute_t<Source1, Source2, Dest>>
 std::optional<Dest>
 mulDiv(Dest value, Source1 mul, Source2 div)
 {
     // Multiplication is commutative
-    return unit::mulDivU(mul, value, div);
+    return feeunit::mulDivU(mul, value, div);
 }
 
-template <class Dest, class = unit::enable_muldiv_dest_t<Dest>>
+template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
 std::optional<Dest>
 mulDiv(std::uint64_t value, Dest mul, std::uint64_t div)
 {
     // Give the scalars a non-tag so the
     // unit-handling version gets called.
-    return unit::mulDivU(unit::scalar(value), mul, unit::scalar(div));
+    return feeunit::mulDivU(feeunit::scalar(value), mul, feeunit::scalar(div));
 }
 
-template <class Dest, class = unit::enable_muldiv_dest_t<Dest>>
+template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
 std::optional<Dest>
 mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
 {
@@ -555,13 +516,13 @@ mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
 template <
     class Source1,
     class Source2,
-    class = unit::enable_muldiv_sources_t<Source1, Source2>>
+    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
 std::optional<std::uint64_t>
 mulDiv(Source1 value, std::uint64_t mul, Source2 div)
 {
     // Give the scalars a dimensionless unit so the
     // unit-handling version gets called.
-    auto unitresult = unit::mulDivU(value, unit::scalar(mul), div);
+    auto unitresult = feeunit::mulDivU(value, feeunit::scalar(mul), div);
 
     if (!unitresult)
         return std::nullopt;
@@ -572,7 +533,7 @@ mulDiv(Source1 value, std::uint64_t mul, Source2 div)
 template <
     class Source1,
     class Source2,
-    class = unit::enable_muldiv_sources_t<Source1, Source2>>
+    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
 std::optional<std::uint64_t>
 mulDiv(std::uint64_t value, Source1 mul, Source2 div)
 {
@@ -592,16 +553,6 @@ safe_cast(Src s) noexcept
     return Dest{safe_cast<typename Dest::value_type>(s.value())};
 }
 
-template <class Dest, class Src>
-constexpr std::enable_if_t<
-    std::is_integral_v<typename Dest::value_type> && std::is_integral_v<Src>,
-    Dest>
-safe_cast(Src s) noexcept
-{
-    // Dest may not have an explicit value constructor
-    return Dest{safe_cast<typename Dest::value_type>(s)};
-}
-
 template <class Dest, class Src>
 constexpr std::enable_if_t<
     std::is_same_v<typename Dest::unit_type, typename Src::unit_type> &&
@@ -614,16 +565,6 @@ unsafe_cast(Src s) noexcept
     return Dest{unsafe_cast<typename Dest::value_type>(s.value())};
 }
 
-template <class Dest, class Src>
-constexpr std::enable_if_t<
-    std::is_integral_v<typename Dest::value_type> && std::is_integral_v<Src>,
-    Dest>
-unsafe_cast(Src s) noexcept
-{
-    // Dest may not have an explicit value constructor
-    return Dest{unsafe_cast<typename Dest::value_type>(s)};
-}
-
 }  // namespace ripple
 
-#endif  // PROTOCOL_UNITS_H_INCLUDED
+#endif  // BASICS_FEES_H_INCLUDED

include/xrpl/protocol/IOUAmount.h

@@ -28,6 +28,7 @@
 
 #include <cstdint>
 #include <string>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/protocol/Indexes.h

@@ -279,10 +279,6 @@ amm(Asset const& issue1, Asset const& issue2) noexcept;
 Keylet
 amm(uint256 const& amm) noexcept;
 
-/** A keylet for Delegate object */
-Keylet
-delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept;
-
 Keylet
 bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType);
 
@@ -334,33 +330,6 @@ mptoken(uint256 const& mptokenKey)
 Keylet
 mptoken(uint256 const& issuanceKey, AccountID const& holder) noexcept;
 
-Keylet
-vault(AccountID const& owner, std::uint32_t seq) noexcept;
-
-inline Keylet
-vault(uint256 const& vaultKey)
-{
-    return {ltVAULT, vaultKey};
-}
-
-Keylet
-loanbroker(AccountID const& owner, std::uint32_t seq) noexcept;
-
-inline Keylet
-loanbroker(uint256 const& vaultKey)
-{
-    return {ltLOAN_BROKER, vaultKey};
-}
-
-Keylet
-loan(uint256 const& loanBrokerID, std::uint32_t loanSeq) noexcept;
-
-inline Keylet
-loan(uint256 const& vaultKey)
-{
-    return {ltLOAN, vaultKey};
-}
-
 Keylet
 permissionedDomain(AccountID const& account, std::uint32_t seq) noexcept;
 

include/xrpl/protocol/LedgerFormats.h

@@ -132,7 +132,7 @@ enum LedgerSpecificFlags {
     lsfNoFreeze = 0x00200000,       // True, cannot freeze ripple states
     lsfGlobalFreeze = 0x00400000,   // True, all assets frozen
     lsfDefaultRipple =
-        0x00800000,               // True, incoming trust lines allow rippling by default
+        0x00800000,               // True, trust lines allow rippling by default
     lsfDepositAuth = 0x01000000,  // True, all deposits require authorization
 /*  // reserved for Hooks amendment
     lsfTshCollect = 0x02000000,     // True, allow TSH collect-calls to acc hooks
@@ -191,14 +191,6 @@ enum LedgerSpecificFlags {
 
     // ltCREDENTIAL
     lsfAccepted = 0x00010000,
-
-    // ltVAULT
-    lsfVaultPrivate = 0x00010000,
-
-    // ltLOAN
-    lsfLoanDefault = 0x00010000,
-    lsfLoanImpaired = 0x00020000,
-    lsfLoanOverpayment = 0x00040000, // True, loan allows overpayments
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/MPTAmount.h

@@ -24,12 +24,15 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/utility/Zero.h>
+#include <xrpl/json/json_value.h>
 
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
 
 #include <cstdint>
+#include <optional>
 #include <string>
+#include <type_traits>
 
 namespace ripple {
 

include/xrpl/protocol/MPTIssue.h

@@ -42,11 +42,8 @@ public:
     AccountID const&
     getIssuer() const;
 
-    constexpr MPTID const&
-    getMptID() const
-    {
-        return mptID_;
-    }
+    MPTID const&
+    getMptID() const;
 
     std::string
     getText() const;

include/xrpl/protocol/MultiApiJson.h

@@ -80,7 +80,7 @@ struct MultiApiJson
     }
 
     void
-    set(char const* key, auto const& v)
+    set(const char* key, auto const& v)
         requires std::constructible_from<Json::Value, decltype(v)>
     {
         for (auto& a : this->val)
@@ -91,7 +91,7 @@ struct MultiApiJson
     enum IsMemberResult : int { none = 0, some, all };
 
     [[nodiscard]] IsMemberResult
-    isMember(char const* key) const
+    isMember(const char* key) const
     {
         int count = 0;
         for (auto& a : this->val)

include/xrpl/protocol/Permissions.h

@@ -1,97 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_PROTOCOL_PERMISSION_H_INCLUDED
-#define RIPPLE_PROTOCOL_PERMISSION_H_INCLUDED
-
-#include <xrpl/protocol/TxFormats.h>
-
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace ripple {
-/**
- * We have both transaction type permissions and granular type permissions.
- * Since we will reuse the TransactionFormats to parse the Transaction
- * Permissions, only the GranularPermissionType is defined here. To prevent
- * conflicts with TxType, the GranularPermissionType is always set to a value
- * greater than the maximum value of uint16.
- */
-enum GranularPermissionType : std::uint32_t {
-#pragma push_macro("PERMISSION")
-#undef PERMISSION
-
-#define PERMISSION(type, txType, value) type = value,
-
-#include <xrpl/protocol/detail/permissions.macro>
-
-#undef PERMISSION
-#pragma pop_macro("PERMISSION")
-};
-
-enum Delegation { delegatable, notDelegatable };
-
-class Permission
-{
-private:
-    Permission();
-
-    std::unordered_map<std::uint16_t, Delegation> delegatableTx_;
-
-    std::unordered_map<std::string, GranularPermissionType>
-        granularPermissionMap_;
-
-    std::unordered_map<GranularPermissionType, std::string> granularNameMap_;
-
-    std::unordered_map<GranularPermissionType, TxType> granularTxTypeMap_;
-
-public:
-    static Permission const&
-    getInstance();
-
-    Permission(Permission const&) = delete;
-    Permission&
-    operator=(Permission const&) = delete;
-
-    std::optional<std::uint32_t>
-    getGranularValue(std::string const& name) const;
-
-    std::optional<std::string>
-    getGranularName(GranularPermissionType const& value) const;
-
-    std::optional<TxType>
-    getGranularTxType(GranularPermissionType const& gpType) const;
-
-    bool
-    isDelegatable(std::uint32_t const& permissionValue) const;
-
-    // for tx level permission, permission value is equal to tx type plus one
-    uint32_t
-    txToPermissionType(TxType const& type) const;
-
-    // tx type value is permission value minus one
-    TxType
-    permissionToTxType(uint32_t const& value) const;
-};
-
-}  // namespace ripple
-
-#endif

include/xrpl/protocol/Protocol.h

@@ -23,8 +23,6 @@
 #include <xrpl/basics/ByteUtilities.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/partitioned_unordered_map.h>
-#include <xrpl/basics/safe_cast.h>
-#include <xrpl/protocol/Units.h>
 
 #include <cstdint>
 
@@ -84,90 +82,6 @@ std::size_t constexpr maxDeletableTokenOfferEntries = 500;
  */
 std::uint16_t constexpr maxTransferFee = 50000;
 
-/** There are 10,000 basis points (bips) in 100%.
- *
- * Basis points represent 0.01%.
- *
- * Given a value X, to find the amount for B bps,
- * use X * B / bipsPerUnity
- *
- * Example: If a loan broker has 999 XRP of debt, and must maintain 1,000 bps of
- * that debt as cover (10%), then the minimum cover amount is 999,000,000 drops
- * * 1000 / bipsPerUnity = 99,900,00 drops or 99.9 XRP.
- *
- * Given a percentage P, to find the number of bps that percentage represents,
- * use P * bipsPerUnity.
- *
- * Example: 50% is 0.50 * bipsPerUnity = 5,000 bps.
- */
-Bips32 constexpr bipsPerUnity(100 * 100);
-TenthBips32 constexpr tenthBipsPerUnity(bipsPerUnity.value() * 10);
-
-constexpr Bips32
-percentageToBips(std::uint32_t percentage)
-{
-    return Bips32(percentage * bipsPerUnity.value() / 100);
-}
-constexpr TenthBips32
-percentageToTenthBips(std::uint32_t percentage)
-{
-    return TenthBips32(percentage * tenthBipsPerUnity.value() / 100);
-}
-template <typename T, class TBips>
-constexpr T
-bipsOfValue(T value, Bips<TBips> bips)
-{
-    return value * bips.value() / bipsPerUnity.value();
-}
-template <typename T, class TBips>
-constexpr T
-tenthBipsOfValue(T value, TenthBips<TBips> bips)
-{
-    return value * bips.value() / tenthBipsPerUnity.value();
-}
-
-/** The maximum management fee rate allowed by a loan broker in 1/10 bips.
-
-    Valid values are between 0 and 10% inclusive.
-*/
-TenthBips16 constexpr maxManagementFeeRate(
-    unsafe_cast<std::uint16_t>(percentageToTenthBips(10).value()));
-static_assert(maxManagementFeeRate == TenthBips16(std::uint16_t(10'000u)));
-
-/** The maximum coverage rate required of a loan broker in 1/10 bips.
-
-    Valid values are between 0 and 100% inclusive.
-*/
-TenthBips32 constexpr maxCoverRate = percentageToTenthBips(100);
-static_assert(maxCoverRate == TenthBips32(100'000u));
-
-/** The maximum overpayment fee on a loan in 1/10 bips.
-*
-    Valid values are between 0 and 100% inclusive.
-*/
-TenthBips32 constexpr maxOverpaymentFee = percentageToTenthBips(100);
-
-/** The maximum premium added to the interest rate for late payments on a loan
- * in 1/10 bips.
- *
- * Valid values are between 0 and 100% inclusive.
- */
-TenthBips32 constexpr maxLateInterestRate = percentageToTenthBips(100);
-
-/** The maximum close interest rate charged for repaying a loan early in 1/10
- * bips.
- *
- * Valid values are between 0 and 100% inclusive.
- */
-TenthBips32 constexpr maxCloseInterestRate = percentageToTenthBips(100);
-
-/** The maximum overpayment interest rate charged on loan overpayments in 1/10
- * bips.
- *
- * Valid values are between 0 and 100% inclusive.
- */
-TenthBips32 constexpr maxOverpaymentInterestRate = percentageToTenthBips(100);
-
 /** The maximum length of a URI inside an NFT */
 std::size_t constexpr maxTokenURILength = 256;
 
@@ -202,16 +116,6 @@ std::size_t constexpr maxMPTokenMetadataLength = 1024;
 /** The maximum amount of MPTokenIssuance */
 std::uint64_t constexpr maxMPTokenAmount = 0x7FFF'FFFF'FFFF'FFFFull;
 
-/** The maximum length of Data payload */
-std::size_t constexpr maxDataPayloadLength = 256;
-
-/** Vault withdrawal policies */
-std::uint8_t constexpr vaultStrategyFirstComeFirstServe = 1;
-
-/** Maximum recursion depth for vault shares being put as an asset inside
- * another vault; counted from 0 */
-std::uint8_t constexpr maxAssetCheckDepth = 5;
-
 /** A ledger index. */
 using LedgerIndex = std::uint32_t;
 
@@ -251,10 +155,6 @@ std::size_t constexpr maxPriceScale = 20;
  */
 std::size_t constexpr maxTrim = 25;
 
-/** The maximum number of delegate permissions an account can grant
- */
-std::size_t constexpr permissionMaxSize = 10;
-
 }  // namespace ripple
 
 #endif

include/xrpl/protocol/Quality.h

@@ -113,8 +113,8 @@ public:
     // have lower unsigned integer representations.
     using value_type = std::uint64_t;
 
-    static int const minTickSize = 3;
-    static int const maxTickSize = 16;
+    static const int minTickSize = 3;
+    static const int maxTickSize = 16;
 
 private:
     // This has the same representation as STAmount, see the comment on the

include/xrpl/protocol/SField.h

@@ -22,10 +22,10 @@
 
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/json/json_value.h>
-#include <xrpl/protocol/Units.h>
 
 #include <cstdint>
 #include <map>
+#include <utility>
 
 namespace ripple {
 
@@ -54,9 +54,6 @@ class STXChainBridge;
 class STVector256;
 class STCurrency;
 
-template <class Integer>
-concept HasValue = requires(Integer i) { i.value(); };
-
 #pragma push_macro("XMACRO")
 #undef XMACRO
 
@@ -139,9 +136,9 @@ field_code(int id, int index)
     the binary format of the transaction can be canonicalized.  All
     SFields are created at compile time.
 
-    Each SField, once constructed, lives until program termination, and
-   there is only one instance per fieldType/fieldValue pair which serves the
-   entire application.
+    Each SField, once constructed, lives until program termination, and there
+    is only one instance per fieldType/fieldValue pair which serves the entire
+    application.
 */
 class SField
 {
@@ -152,11 +149,8 @@ public:
         sMD_ChangeNew = 0x02,    // new value when it changes
         sMD_DeleteFinal = 0x04,  // final value when it is deleted
         sMD_Create = 0x08,       // value when it's created
-        sMD_Always = 0x10,   // value when node containing it is affected at all
-        sMD_BaseTen = 0x20,  // value is treated as base 10, overriding
-        // default behavior
-        sMD_PseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
-        // _only_, then it is a pseudo-account
+        sMD_Always = 0x10,  // value when node containing it is affected at all
+        sMD_BaseTen = 0x20,
         sMD_Default =
             sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create
     };
@@ -181,30 +175,29 @@ public:
     operator=(SField&&) = delete;
 
 public:
-    struct private_access_tag_t;  // public, but still an implementation
-    // detail
+    struct private_access_tag_t;  // public, but still an implementation detail
 
     // These constructors can only be called from SField.cpp
     SField(
         private_access_tag_t,
         SerializedTypeID tid,
         int fv,
-        char const* fn,
+        const char* fn,
         int meta = sMD_Default,
         IsSigning signing = IsSigning::yes);
     explicit SField(private_access_tag_t, int fc);
 
-    static SField const&
+    static const SField&
     getField(int fieldCode);
-    static SField const&
+    static const SField&
     getField(std::string const& fieldName);
-    static SField const&
+    static const SField&
     getField(int type, int value)
     {
         return getField(field_code(type, value));
     }
 
-    static SField const&
+    static const SField&
     getField(SerializedTypeID type, int value)
     {
         return getField(field_code(type, value));
@@ -291,19 +284,19 @@ public:
     }
 
     bool
-    operator==(SField const& f) const
+    operator==(const SField& f) const
     {
         return fieldCode == f.fieldCode;
     }
 
     bool
-    operator!=(SField const& f) const
+    operator!=(const SField& f) const
     {
         return fieldCode != f.fieldCode;
     }
 
     static int
-    compare(SField const& f1, SField const& f2);
+    compare(const SField& f1, const SField& f2);
 
     static std::map<int, SField const*> const&
     getKnownCodeToField()
@@ -314,7 +307,6 @@ public:
 private:
     static int num;
     static std::map<int, SField const*> knownCodeToField;
-    static std::map<std::string, SField const*> knownNameToField;
 };
 
 /** A field with a type known at compile time. */

include/xrpl/protocol/STAccount.h

@@ -58,7 +58,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STAmount.h

@@ -62,20 +62,20 @@ private:
 public:
     using value_type = STAmount;
 
-    static int const cMinOffset = -96;
-    static int const cMaxOffset = 80;
+    static const int cMinOffset = -96;
+    static const int cMaxOffset = 80;
 
     // Maximum native value supported by the code
-    static std::uint64_t const cMinValue = 1000000000000000ull;
-    static std::uint64_t const cMaxValue = 9999999999999999ull;
-    static std::uint64_t const cMaxNative = 9000000000000000000ull;
+    static const std::uint64_t cMinValue = 1000000000000000ull;
+    static const std::uint64_t cMaxValue = 9999999999999999ull;
+    static const std::uint64_t cMaxNative = 9000000000000000000ull;
 
     // Max native value on network.
-    static std::uint64_t const cMaxNativeN = 100000000000000000ull;
-    static std::uint64_t const cIssuedCurrency = 0x8000000000000000ull;
-    static std::uint64_t const cPositive = 0x4000000000000000ull;
-    static std::uint64_t const cMPToken = 0x2000000000000000ull;
-    static std::uint64_t const cValueMask = ~(cPositive | cMPToken);
+    static const std::uint64_t cMaxNativeN = 100000000000000000ull;
+    static const std::uint64_t cIssuedCurrency = 0x8000000000000000ull;
+    static const std::uint64_t cPositive = 0x4000000000000000ull;
+    static const std::uint64_t cMPToken = 0x2000000000000000ull;
+    static const std::uint64_t cValueMask = ~(cPositive | cMPToken);
 
     static std::uint64_t const uRateOne;
 
@@ -153,12 +153,6 @@ public:
     template <AssetType A>
     STAmount(A const& asset, int mantissa, int exponent = 0);
 
-    template <AssetType A>
-    STAmount(A const& asset, Number const& number)
-        : STAmount(asset, number.mantissa(), number.exponent())
-    {
-    }
-
     // Legacy support for new-style amounts
     STAmount(IOUAmount const& amount, Issue const& issue);
     STAmount(XRPAmount const& amount);
@@ -236,9 +230,6 @@ public:
     STAmount&
     operator=(XRPAmount const& amount);
 
-    STAmount&
-    operator=(Number const&);
-
     //--------------------------------------------------------------------------
     //
     // Modification
@@ -277,13 +268,13 @@ public:
     std::string
     getText() const override;
 
-    Json::Value getJson(JsonOptions = JsonOptions::none) const override;
+    Json::Value getJson(JsonOptions) const override;
 
     void
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;
@@ -426,7 +417,7 @@ STAmount
 amountFromQuality(std::uint64_t rate);
 
 STAmount
-amountFromString(Asset const& asset, std::string const& amount);
+amountFromString(Asset const& issue, std::string const& amount);
 
 STAmount
 amountFromJson(SField const& name, Json::Value const& v);
@@ -550,16 +541,6 @@ STAmount::operator=(XRPAmount const& amount)
     return *this;
 }
 
-inline STAmount&
-STAmount::operator=(Number const& number)
-{
-    mIsNegative = number.mantissa() < 0;
-    mValue = mIsNegative ? -number.mantissa() : number.mantissa();
-    mOffset = number.exponent();
-    canonicalize();
-    return *this;
-}
-
 inline void
 STAmount::negate()
 {
@@ -695,36 +676,6 @@ divRoundStrict(
 std::uint64_t
 getRate(STAmount const& offerOut, STAmount const& offerIn);
 
-STAmount
-roundToReference(
-    STAmount const value,
-    STAmount referenceValue,
-    Number::rounding_mode rounding = Number::getround());
-
-/** Round an arbitrary precision Number to the precision of a given Asset.
- *
- * @param asset The relevant asset
- * @param value The value to be rounded
- * @param referenceValue Only relevant to IOU assets. A reference value to
- *     establish the precision limit of `value`. Should be larger than
- * `value`.
- * @param rounding Optional Number rounding mode
- */
-template <AssetType A>
-Number
-roundToAsset(
-    A const& asset,
-    Number const& value,
-    Number const& referenceValue,
-    Number::rounding_mode rounding = Number::getround())
-{
-    NumberRoundModeGuard mg(rounding);
-    STAmount const ret{asset, value};
-    if (ret.asset().native() || !ret.asset().holds<Issue>())
-        return ret;
-    return roundToReference(ret, STAmount{asset, referenceValue});
-}
-
 //------------------------------------------------------------------------------
 
 inline bool
@@ -733,10 +684,10 @@ isXRP(STAmount const& amount)
     return amount.native();
 }
 
-// Since `canonicalize` does not have access to a ledger, this is needed to
-// put the low-level routine stAmountCanonicalize on an amendment switch.
-// Only transactions need to use this switchover. Outside of a transaction
-// it's safe to unconditionally use the new behavior.
+// Since `canonicalize` does not have access to a ledger, this is needed to put
+// the low-level routine stAmountCanonicalize on an amendment switch. Only
+// transactions need to use this switchover. Outside of a transaction it's safe
+// to unconditionally use the new behavior.
 
 bool
 getSTAmountCanonicalizeSwitchover();

include/xrpl/protocol/STArray.h

@@ -128,13 +128,13 @@ public:
     add(Serializer& s) const override;
 
     void
-    sort(bool (*compare)(STObject const& o1, STObject const& o2));
+    sort(bool (*compare)(const STObject& o1, const STObject& o2));
 
     bool
-    operator==(STArray const& s) const;
+    operator==(const STArray& s) const;
 
     bool
-    operator!=(STArray const& s) const;
+    operator!=(const STArray& s) const;
 
     iterator
     erase(iterator pos);
@@ -152,7 +152,7 @@ public:
     getSType() const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;
@@ -275,13 +275,13 @@ STArray::swap(STArray& a) noexcept
 }
 
 inline bool
-STArray::operator==(STArray const& s) const
+STArray::operator==(const STArray& s) const
 {
     return v_ == s.v_;
 }
 
 inline bool
-STArray::operator!=(STArray const& s) const
+STArray::operator!=(const STArray& s) const
 {
     return v_ != s.v_;
 }

include/xrpl/protocol/STBase.h

@@ -92,16 +92,6 @@ struct JsonOptions
     }
 };
 
-template <typename T>
-    requires requires(T const& t) {
-        { t.getJson(JsonOptions::none) } -> std::convertible_to<Json::Value>;
-    }
-Json::Value
-to_json(T const& t)
-{
-    return t.getJson(JsonOptions::none);
-}
-
 namespace detail {
 class STVar;
 }
@@ -139,16 +129,16 @@ class STBase
 public:
     virtual ~STBase() = default;
     STBase();
-    STBase(STBase const&) = default;
+    STBase(const STBase&) = default;
     STBase&
-    operator=(STBase const& t);
+    operator=(const STBase& t);
 
     explicit STBase(SField const& n);
 
     bool
-    operator==(STBase const& t) const;
+    operator==(const STBase& t) const;
     bool
-    operator!=(STBase const& t) const;
+    operator!=(const STBase& t) const;
 
     template <class D>
     D&
@@ -167,7 +157,7 @@ public:
     virtual std::string
     getText() const;
 
-    virtual Json::Value getJson(JsonOptions = JsonOptions::none) const;
+    virtual Json::Value getJson(JsonOptions /*options*/) const;
 
     virtual void
     add(Serializer& s) const;
@@ -207,7 +197,7 @@ private:
 //------------------------------------------------------------------------------
 
 std::ostream&
-operator<<(std::ostream& out, STBase const& t);
+operator<<(std::ostream& out, const STBase& t);
 
 template <class D>
 D&

include/xrpl/protocol/STBitString.h

@@ -45,8 +45,8 @@ public:
     STBitString() = default;
 
     STBitString(SField const& n);
-    STBitString(value_type const& v);
-    STBitString(SField const& n, value_type const& v);
+    STBitString(const value_type& v);
+    STBitString(SField const& n, const value_type& v);
     STBitString(SerialIter& sit, SField const& name);
 
     SerializedTypeID
@@ -56,7 +56,7 @@ public:
     getText() const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     void
     add(Serializer& s) const override;
@@ -93,12 +93,12 @@ inline STBitString<Bits>::STBitString(SField const& n) : STBase(n)
 }
 
 template <int Bits>
-inline STBitString<Bits>::STBitString(value_type const& v) : value_(v)
+inline STBitString<Bits>::STBitString(const value_type& v) : value_(v)
 {
 }
 
 template <int Bits>
-inline STBitString<Bits>::STBitString(SField const& n, value_type const& v)
+inline STBitString<Bits>::STBitString(SField const& n, const value_type& v)
     : STBase(n), value_(v)
 {
 }
@@ -160,9 +160,9 @@ STBitString<Bits>::getText() const
 
 template <int Bits>
 bool
-STBitString<Bits>::isEquivalent(STBase const& t) const
+STBitString<Bits>::isEquivalent(const STBase& t) const
 {
-    STBitString const* v = dynamic_cast<STBitString const*>(&t);
+    const STBitString* v = dynamic_cast<const STBitString*>(&t);
     return v && (value_ == v->value_);
 }
 

include/xrpl/protocol/STBlob.h

@@ -63,7 +63,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STCurrency.h

@@ -65,7 +65,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STInteger.h

@@ -21,7 +21,6 @@
 #define RIPPLE_PROTOCOL_STINTEGER_H_INCLUDED
 
 #include <xrpl/basics/CountedObject.h>
-#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STBase.h>
 
 namespace ripple {
@@ -37,7 +36,7 @@ private:
 
 public:
     explicit STInteger(Integer v);
-    STInteger(SField const& n, Integer v = {});
+    STInteger(SField const& n, Integer v = 0);
     STInteger(SerialIter& sit, SField const& name);
 
     SerializedTypeID
@@ -55,7 +54,7 @@ public:
     isDefault() const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     STInteger&
     operator=(value_type const& v);
@@ -123,14 +122,14 @@ template <typename Integer>
 inline bool
 STInteger<Integer>::isDefault() const
 {
-    return value_ == Integer{};
+    return value_ == 0;
 }
 
 template <typename Integer>
 inline bool
-STInteger<Integer>::isEquivalent(STBase const& t) const
+STInteger<Integer>::isEquivalent(const STBase& t) const
 {
-    STInteger const* v = dynamic_cast<STInteger const*>(&t);
+    const STInteger* v = dynamic_cast<const STInteger*>(&t);
     return v && (value_ == v->value_);
 }
 

include/xrpl/protocol/STIssue.h

@@ -37,7 +37,6 @@ public:
     using value_type = Asset;
 
     STIssue() = default;
-    STIssue(STIssue const& rhs) = default;
 
     explicit STIssue(SerialIter& sit, SField const& name);
 
@@ -46,15 +45,6 @@ public:
 
     explicit STIssue(SField const& name);
 
-    STIssue&
-    operator=(STIssue const& rhs) = default;
-    STIssue&
-    operator=(Asset const& rhs)
-    {
-        asset_ = rhs;
-        return *this;
-    }
-
     template <ValidIssueType TIss>
     TIss const&
     get() const;
@@ -81,7 +71,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STLedgerEntry.h

@@ -26,9 +26,7 @@
 namespace ripple {
 
 class Rules;
-namespace test {
 class Invariants_test;
-}
 
 class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 {
@@ -37,9 +35,7 @@ class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 
 public:
     using pointer = std::shared_ptr<STLedgerEntry>;
-    using ref = std::shared_ptr<STLedgerEntry> const&;
-    using const_pointer = std::shared_ptr<STLedgerEntry const>;
-    using const_ref = std::shared_ptr<STLedgerEntry const> const&;
+    using ref = const std::shared_ptr<STLedgerEntry>&;
 
     /** Create an empty object with the given key and type. */
     explicit STLedgerEntry(Keylet const& k);
@@ -58,7 +54,7 @@ public:
     getText() const override;
 
     Json::Value
-    getJson(JsonOptions options = JsonOptions::none) const override;
+    getJson(JsonOptions options) const override;
 
     /** Returns the 'key' (or 'index') of this item.
         The key identifies this entry's position in
@@ -88,8 +84,7 @@ private:
     void
     setSLEType();
 
-    friend test::Invariants_test;  // this test wants access to the private
-                                   // type_
+    friend Invariants_test;  // this test wants access to the private type_
 
     STBase*
     copy(std::size_t n, void* buf) const override;

include/xrpl/protocol/STNumber.h

@@ -63,13 +63,6 @@ public:
     void
     setValue(Number const& v);
 
-    STNumber&
-    operator=(Number const& rhs)
-    {
-        setValue(rhs);
-        return *this;
-    }
-
     bool
     isEquivalent(STBase const& t) const override;
     bool
@@ -90,19 +83,6 @@ private:
 std::ostream&
 operator<<(std::ostream& out, STNumber const& rhs);
 
-struct NumberParts
-{
-    std::uint64_t mantissa = 0;
-    int exponent = 0;
-    bool negative = false;
-};
-
-NumberParts
-partsFromString(std::string const& number);
-
-STNumber
-numberFromJson(SField const& field, Json::Value const& value);
-
 }  // namespace ripple
 
 #endif

include/xrpl/protocol/STObject.h

@@ -25,6 +25,7 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/STAmount.h>
@@ -33,7 +34,6 @@
 #include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/STPathSet.h>
 #include <xrpl/protocol/STVector256.h>
-#include <xrpl/protocol/Units.h>
 #include <xrpl/protocol/detail/STVar.h>
 
 #include <boost/iterator/transform_iterator.hpp>
@@ -99,8 +99,8 @@ public:
     STObject&
     operator=(STObject&& other);
 
-    STObject(SOTemplate const& type, SField const& name);
-    STObject(SOTemplate const& type, SerialIter& sit, SField const& name);
+    STObject(const SOTemplate& type, SField const& name);
+    STObject(const SOTemplate& type, SerialIter& sit, SField const& name);
     STObject(SerialIter& sit, SField const& name, int depth = 0);
     STObject(SerialIter&& sit, SField const& name);
     explicit STObject(SField const& name);
@@ -121,7 +121,7 @@ public:
     reserve(std::size_t n);
 
     void
-    applyTemplate(SOTemplate const& type);
+    applyTemplate(const SOTemplate& type);
 
     void
     applyTemplateFromSField(SField const&);
@@ -130,7 +130,7 @@ public:
     isFree() const;
 
     void
-    set(SOTemplate const&);
+    set(const SOTemplate&);
 
     bool
     set(SerialIter& u, int depth = 0);
@@ -139,7 +139,7 @@ public:
     getSType() const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;
@@ -154,7 +154,8 @@ public:
     getText() const override;
 
     // TODO(tom): options should be an enum.
-    Json::Value getJson(JsonOptions = JsonOptions::none) const override;
+    Json::Value
+    getJson(JsonOptions options) const override;
 
     void
     addWithoutSigningFields(Serializer& s) const;
@@ -182,13 +183,13 @@ public:
     uint256
     getSigningHash(HashPrefix prefix) const;
 
-    STBase const&
+    const STBase&
     peekAtIndex(int offset) const;
 
     STBase&
     getIndex(int offset);
 
-    STBase const*
+    const STBase*
     peekAtPIndex(int offset) const;
 
     STBase*
@@ -200,13 +201,13 @@ public:
     SField const&
     getFieldSType(int index) const;
 
-    STBase const&
+    const STBase&
     peekAtField(SField const& field) const;
 
     STBase&
     getField(SField const& field);
 
-    STBase const*
+    const STBase*
     peekAtPField(SField const& field) const;
 
     STBase*
@@ -240,14 +241,11 @@ public:
     getFieldAmount(SField const& field) const;
     STPathSet const&
     getFieldPathSet(SField const& field) const;
-    STVector256 const&
+    const STVector256&
     getFieldV256(SField const& field) const;
-    // If not found, returns an object constructed with the given field
-    STObject
-    getFieldObject(SField const& field) const;
-    STArray const&
+    const STArray&
     getFieldArray(SField const& field) const;
-    STCurrency const&
+    const STCurrency&
     getFieldCurrency(SField const& field) const;
     STNumber const&
     getFieldNumber(SField const& field) const;
@@ -411,12 +409,12 @@ public:
     delField(int index);
 
     bool
-    hasMatchingEntry(STBase const&);
+    hasMatchingEntry(const STBase&);
 
     bool
-    operator==(STObject const& o) const;
+    operator==(const STObject& o) const;
     bool
-    operator!=(STObject const& o) const;
+    operator!=(const STObject& o) const;
 
     class FieldErr;
 
@@ -486,19 +484,9 @@ private:
 template <class T>
 class STObject::Proxy
 {
-public:
+protected:
     using value_type = typename T::value_type;
 
-    value_type
-    value() const;
-
-    value_type
-    operator*() const;
-
-    T const*
-    operator->() const;
-
-protected:
     STObject* st_;
     SOEStyle style_;
     TypedField<T> const* f_;
@@ -507,6 +495,9 @@ protected:
 
     Proxy(STObject* st, TypedField<T> const* f);
 
+    value_type
+    value() const;
+
     T const*
     find() const;
 
@@ -518,29 +509,10 @@ protected:
 // Constraint += and -= ValueProxy operators
 // to value types that support arithmetic operations
 template <typename U>
-concept IsArithmeticNumber = std::is_arithmetic_v<U> ||
-    std::is_same_v<U, Number> || std::is_same_v<U, STAmount>;
-template <
-    typename U,
-    typename Value = typename U::value_type,
-    typename Unit = typename U::unit_type>
-concept IsArithmeticValueUnit =
-    std::is_same_v<U, unit::ValueUnit<Unit, Value>> &&
-    IsArithmeticNumber<Value> && std::is_class_v<Unit>;
-template <typename U, typename Value = typename U::value_type>
-concept IsArithmeticST = !IsArithmeticValueUnit<U> && IsArithmeticNumber<Value>;
-template <typename U>
-concept IsArithmetic =
-    IsArithmeticNumber<U> || IsArithmeticST<U> || IsArithmeticValueUnit<U>;
-
-template <class T, class U>
-concept Addable = requires(T t, U u) { t = t + u; };
-template <typename T, typename U>
-concept IsArithmeticCompatible =
-    IsArithmetic<typename T::value_type> && Addable<typename T::value_type, U>;
+concept IsArithmetic = std::is_arithmetic_v<U> || std::is_same_v<U, STAmount>;
 
 template <class T>
-class STObject::ValueProxy : public Proxy<T>
+class STObject::ValueProxy : private Proxy<T>
 {
 private:
     using value_type = typename T::value_type;
@@ -557,24 +529,15 @@ public:
     // Convenience operators for value types supporting
     // arithmetic operations
     template <IsArithmetic U>
-        requires IsArithmeticCompatible<T, U>
     ValueProxy&
     operator+=(U const& u);
 
     template <IsArithmetic U>
-        requires IsArithmeticCompatible<T, U>
     ValueProxy&
     operator-=(U const& u);
 
     operator value_type() const;
 
-    template <typename U>
-    friend bool
-    operator==(U const& lhs, STObject::ValueProxy<T> const& rhs)
-    {
-        return rhs.value() == lhs;
-    }
-
 private:
     friend class STObject;
 
@@ -582,7 +545,7 @@ private:
 };
 
 template <class T>
-class STObject::OptionalProxy : public Proxy<T>
+class STObject::OptionalProxy : private Proxy<T>
 {
 private:
     using value_type = typename T::value_type;
@@ -602,6 +565,15 @@ public:
     explicit
     operator bool() const noexcept;
 
+    /** Return the contained value
+
+        Throws:
+
+            STObject::FieldErr if !engaged()
+    */
+    value_type
+    operator*() const;
+
     operator optional_type() const;
 
     /** Explicit conversion to std::optional */
@@ -745,20 +717,6 @@ STObject::Proxy<T>::value() const -> value_type
     return value_type{};
 }
 
-template <class T>
-auto
-STObject::Proxy<T>::operator*() const -> value_type
-{
-    return this->value();
-}
-
-template <class T>
-T const*
-STObject::Proxy<T>::operator->() const
-{
-    return this->find();
-}
-
 template <class T>
 inline T const*
 STObject::Proxy<T>::find() const
@@ -798,7 +756,6 @@ STObject::ValueProxy<T>::operator=(U&& u)
 
 template <typename T>
 template <IsArithmetic U>
-    requires IsArithmeticCompatible<T, U>
 STObject::ValueProxy<T>&
 STObject::ValueProxy<T>::operator+=(U const& u)
 {
@@ -808,7 +765,6 @@ STObject::ValueProxy<T>::operator+=(U const& u)
 
 template <class T>
 template <IsArithmetic U>
-    requires IsArithmeticCompatible<T, U>
 STObject::ValueProxy<T>&
 STObject::ValueProxy<T>::operator-=(U const& u)
 {
@@ -836,6 +792,13 @@ STObject::OptionalProxy<T>::operator bool() const noexcept
     return engaged();
 }
 
+template <class T>
+auto
+STObject::OptionalProxy<T>::operator*() const -> value_type
+{
+    return this->value();
+}
+
 template <class T>
 STObject::OptionalProxy<T>::operator typename STObject::OptionalProxy<
     T>::optional_type() const
@@ -1007,7 +970,7 @@ STObject::getCount() const
     return v_.size();
 }
 
-inline STBase const&
+inline const STBase&
 STObject::peekAtIndex(int offset) const
 {
     return v_[offset].get();
@@ -1019,7 +982,7 @@ STObject::getIndex(int offset)
     return v_[offset].get();
 }
 
-inline STBase const*
+inline const STBase*
 STObject::peekAtPIndex(int offset) const
 {
     return &v_[offset].get();
@@ -1154,7 +1117,7 @@ STObject::setFieldH160(SField const& field, base_uint<160, Tag> const& v)
 }
 
 inline bool
-STObject::operator!=(STObject const& o) const
+STObject::operator!=(const STObject& o) const
 {
     return !(*this == o);
 }
@@ -1163,7 +1126,7 @@ template <typename T, typename V>
 V
 STObject::getFieldByValue(SField const& field) const
 {
-    STBase const* rf = peekAtPField(field);
+    const STBase* rf = peekAtPField(field);
 
     if (!rf)
         throwFieldNotFound(field);
@@ -1173,7 +1136,7 @@ STObject::getFieldByValue(SField const& field) const
     if (id == STI_NOTPRESENT)
         return V();  // optional field not present
 
-    T const* cf = dynamic_cast<T const*>(rf);
+    const T* cf = dynamic_cast<const T*>(rf);
 
     if (!cf)
         Throw<std::runtime_error>("Wrong field type");
@@ -1190,7 +1153,7 @@ template <typename T, typename V>
 V const&
 STObject::getFieldByConstRef(SField const& field, V const& empty) const
 {
-    STBase const* rf = peekAtPField(field);
+    const STBase* rf = peekAtPField(field);
 
     if (!rf)
         throwFieldNotFound(field);
@@ -1200,7 +1163,7 @@ STObject::getFieldByConstRef(SField const& field, V const& empty) const
     if (id == STI_NOTPRESENT)
         return empty;  // optional field not present
 
-    T const* cf = dynamic_cast<T const*>(rf);
+    const T* cf = dynamic_cast<const T*>(rf);
 
     if (!cf)
         Throw<std::runtime_error>("Wrong field type");

include/xrpl/protocol/STPathSet.h

@@ -106,10 +106,10 @@ public:
     getIssuerID() const;
 
     bool
-    operator==(STPathElement const& t) const;
+    operator==(const STPathElement& t) const;
 
     bool
-    operator!=(STPathElement const& t) const;
+    operator!=(const STPathElement& t) const;
 
 private:
     static std::size_t
@@ -164,7 +164,7 @@ public:
     STPathElement&
     operator[](int i);
 
-    STPathElement const&
+    const STPathElement&
     operator[](int i) const;
 
     void
@@ -196,7 +196,7 @@ public:
     assembleAdd(STPath const& base, STPathElement const& tail);
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;
@@ -375,7 +375,7 @@ STPathElement::getIssuerID() const
 }
 
 inline bool
-STPathElement::operator==(STPathElement const& t) const
+STPathElement::operator==(const STPathElement& t) const
 {
     return (mType & typeAccount) == (t.mType & typeAccount) &&
         hash_value_ == t.hash_value_ && mAccountID == t.mAccountID &&
@@ -383,7 +383,7 @@ STPathElement::operator==(STPathElement const& t) const
 }
 
 inline bool
-STPathElement::operator!=(STPathElement const& t) const
+STPathElement::operator!=(const STPathElement& t) const
 {
     return !operator==(t);
 }
@@ -455,7 +455,7 @@ STPath::operator[](int i)
     return mPath[i];
 }
 
-inline STPathElement const&
+inline const STPathElement&
 STPath::operator[](int i) const
 {
     return mPath[i];

include/xrpl/protocol/STTx.h

@@ -88,13 +88,7 @@ public:
 
     // Outer transaction functions / signature functions.
     Blob
-    getSignature(STObject const& sigObject) const;
-
-    Blob
-    getSignature() const
-    {
-        return getSignature(*this);
-    }
+    getSignature() const;
 
     uint256
     getSigningHash() const;
@@ -108,10 +102,6 @@ public:
     SeqProxy
     getSeqProxy() const;
 
-    /** Returns the first non-zero value of (Sequence, TicketSequence). */
-    std::uint32_t
-    getSeqValue() const;
-
     boost::container::flat_set<AccountID>
     getMentionedAccounts() const;
 
@@ -127,28 +117,10 @@ public:
     void
     sign(PublicKey const& publicKey, SecretKey const& secretKey);
 
+    /** Check the signature.
+        @return `true` if valid signature. If invalid, the error message string.
+    */
     enum class RequireFullyCanonicalSig : bool { no, yes };
-
-    /** Check the signature.
-        @param requireCanonicalSig If `true`, check that the signature is fully
-            canonical. If `false`, only check that the signature is valid.
-        @param rules The current ledger rules.
-        @param pSig Pointer to object that contains the signature fields, if not
-            using "this". Will most often be null
-        @return `true` if valid signature. If invalid, the error message string.
-    */
-    Expected<void, std::string>
-    checkSign(
-        RequireFullyCanonicalSig requireCanonicalSig,
-        Rules const& rules,
-        STObject const* pSig) const;
-
-    /** Check the signature.
-        @param requireCanonicalSig If `true`, check that the signature is fully
-            canonical. If `false`, only check that the signature is valid.
-        @param rules The current ledger rules.
-        @return `true` if valid signature. If invalid, the error message string.
-    */
     Expected<void, std::string>
     checkSign(RequireFullyCanonicalSig requireCanonicalSig, Rules const& rules)
         const;
@@ -170,15 +142,12 @@ public:
 
 private:
     Expected<void, std::string>
-    checkSingleSign(
-        RequireFullyCanonicalSig requireCanonicalSig,
-        STObject const* pSig) const;
+    checkSingleSign(RequireFullyCanonicalSig requireCanonicalSig) const;
 
     Expected<void, std::string>
     checkMultiSign(
         RequireFullyCanonicalSig requireCanonicalSig,
-        Rules const& rules,
-        STObject const* pSig) const;
+        Rules const& rules) const;
 
     STBase*
     copy(std::size_t n, void* buf) const override;

include/xrpl/protocol/STValidation.h

@@ -22,10 +22,10 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
-#include <xrpl/protocol/Units.h>
 
 #include <cstdint>
 #include <functional>

include/xrpl/protocol/STVector256.h

@@ -50,7 +50,7 @@ public:
     Json::Value getJson(JsonOptions) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;
@@ -62,7 +62,7 @@ public:
     operator=(std::vector<uint256>&& v);
 
     void
-    setValue(STVector256 const& v);
+    setValue(const STVector256& v);
 
     /** Retrieve a copy of the vector we contain */
     explicit
@@ -153,7 +153,7 @@ STVector256::operator=(std::vector<uint256>&& v)
 }
 
 inline void
-STVector256::setValue(STVector256 const& v)
+STVector256::setValue(const STVector256& v)
 {
     mValue = v.mValue;
 }

include/xrpl/protocol/STXChainBridge.h

@@ -107,7 +107,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(STBase const& t) const override;
+    isEquivalent(const STBase& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/Serializer.h

@@ -125,17 +125,8 @@ public:
     }
 
     template <typename Integer>
-        requires(!HasValue<Integer>)
     int addInteger(Integer);
 
-    template <typename Integer>
-        requires HasValue<Integer>
-    int
-    addInteger(Integer i)
-    {
-        return addInteger(i.value());
-    }
-
     template <std::size_t Bits, class Tag>
     int
     addBitString(base_uint<Bits, Tag> const& v)
@@ -148,9 +139,9 @@ public:
     int
     addRaw(Slice slice);
     int
-    addRaw(void const* ptr, int len);
+    addRaw(const void* ptr, int len);
     int
-    addRaw(Serializer const& s);
+    addRaw(const Serializer& s);
 
     int
     addVL(Blob const& vector);
@@ -160,7 +151,7 @@ public:
     int
     addVL(Iter begin, Iter end, int len);
     int
-    addVL(void const* ptr, int len);
+    addVL(const void* ptr, int len);
 
     // disassemble functions
     bool
@@ -170,7 +161,7 @@ public:
     bool
     getInteger(Integer& number, int offset)
     {
-        static auto const bytes = sizeof(Integer);
+        static const auto bytes = sizeof(Integer);
         if ((offset + bytes) > mData.size())
             return false;
         number = 0;
@@ -229,7 +220,7 @@ public:
     {
         return mData.size();
     }
-    void const*
+    const void*
     getDataPtr() const
     {
         return mData.data();
@@ -247,7 +238,7 @@ public:
     std::string
     getString() const
     {
-        return std::string(static_cast<char const*>(getDataPtr()), size());
+        return std::string(static_cast<const char*>(getDataPtr()), size());
     }
     void
     erase()
@@ -305,12 +296,12 @@ public:
         return v != mData;
     }
     bool
-    operator==(Serializer const& v) const
+    operator==(const Serializer& v) const
     {
         return v.mData == mData;
     }
     bool
-    operator!=(Serializer const& v) const
+    operator!=(const Serializer& v) const
     {
         return v.mData != mData;
     }

include/xrpl/protocol/TER.h

@@ -267,17 +267,6 @@ enum TECcodes : TERUnderlyingType {
     // Otherwise, treated as terRETRY.
     //
     // DO NOT CHANGE THESE NUMBERS: They appear in ledger meta data.
-    //
-    // Note:
-    //   tecNO_ENTRY is often used interchangeably with tecOBJECT_NOT_FOUND.
-    //   While there does not seem to be a clear rule which to use when, the
-    //   following guidance will help to keep errors consistent with the
-    //   majority of (but not all) transaction types:
-    // - tecNO_ENTRY : cannot find the primary ledger object on which the
-    //   transaction is being attempted
-    // - tecOBJECT_NOT_FOUND : cannot find the additional object(s) needed to
-    //   complete the transaction
-
     tecCLAIM = 100,
     tecPATH_PARTIAL = 101,
     tecUNFUNDED_ADD = 102,  // Unused legacy code
@@ -357,9 +346,6 @@ enum TECcodes : TERUnderlyingType {
     tecARRAY_TOO_LARGE = 191,
     tecLOCKED = 192,
     tecBAD_CREDENTIALS = 193,
-    tecWRONG_ASSET = 194,
-    tecLIMIT_EXCEEDED = 195,
-    tecPSEUDO_ACCOUNT = 196,
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/TxFlags.h

@@ -120,18 +120,9 @@ constexpr std::uint32_t tfTrustSetMask =
     ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
       tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
 
-// valid flags for granular permission
-constexpr std::uint32_t tfTrustSetGranularMask = tfSetfAuth | tfSetFreeze | tfClearFreeze;
-
-// bits representing supportedGranularMask are set to 0 and the bits
-// representing other flags are set to 1 in tfPermissionMask.
-constexpr std::uint32_t tfTrustSetPermissionMask = (~tfTrustSetMask) & (~tfTrustSetGranularMask);
-
 // EnableAmendment flags:
 constexpr std::uint32_t tfGotMajority                      = 0x00010000;
 constexpr std::uint32_t tfLostMajority                     = 0x00020000;
-constexpr std::uint32_t tfChangeMask =
-    ~( tfUniversal | tfGotMajority | tfLostMajority);
 
 // PaymentChannelClaim flags:
 constexpr std::uint32_t tfRenew                            = 0x00010000;
@@ -146,7 +137,7 @@ constexpr std::uint32_t const tfTransferable               = 0x00000008;
 constexpr std::uint32_t const tfMutable                    = 0x00000010;
 
 // MPTokenIssuanceCreate flags:
-// NOTE - there is intentionally no flag here for lsfMPTLocked, which this transaction cannot mutate.
+// NOTE - there is intentionally no flag here for lsfMPTLocked, which this transaction cannot mutate. 
 constexpr std::uint32_t const tfMPTCanLock                 = lsfMPTCanLock;
 constexpr std::uint32_t const tfMPTRequireAuth             = lsfMPTRequireAuth;
 constexpr std::uint32_t const tfMPTCanEscrow               = lsfMPTCanEscrow;
@@ -164,8 +155,6 @@ constexpr std::uint32_t const tfMPTokenAuthorizeMask  = ~(tfUniversal | tfMPTUna
 constexpr std::uint32_t const tfMPTLock                   = 0x00000001;
 constexpr std::uint32_t const tfMPTUnlock                 = 0x00000002;
 constexpr std::uint32_t const tfMPTokenIssuanceSetMask  = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
-constexpr std::uint32_t const tfMPTokenIssuanceSetGranularMask = tfMPTLock | tfMPTUnlock;
-constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = (~tfMPTokenIssuanceSetMask) & (~tfMPTokenIssuanceSetGranularMask);
 
 // MPTokenIssuanceDestroy flags:
 constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask  = ~tfUniversal;
@@ -235,24 +224,6 @@ constexpr std::uint32_t tfAMMClawbackMask = ~(tfUniversal | tfClawTwoAssets);
 // BridgeModify flags:
 constexpr std::uint32_t tfClearAccountCreateAmount     = 0x00010000;
 constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
-
-// VaultCreate flags:
-constexpr std::uint32_t const tfVaultPrivate               = 0x00010000;
-static_assert(tfVaultPrivate == lsfVaultPrivate);
-constexpr std::uint32_t const tfVaultShareNonTransferable  = 0x00020000;
-constexpr std::uint32_t const tfVaultCreateMask = ~(tfUniversal | tfVaultPrivate | tfVaultShareNonTransferable);
-
-// LoanSet flags:
-// True, indicates the loan supports overpayments
-constexpr std::uint32_t const tfLoanOverpayment = 0x00010000;
-constexpr std::uint32_t const tfLoanSetMask = ~(tfUniversal | tfLoanOverpayment);
-
-// LoanManage flags:
-constexpr std::uint32_t const tfLoanDefault = 0x00010000;
-constexpr std::uint32_t const tfLoanImpair = 0x00020000;
-constexpr std::uint32_t const tfLoanUnimpair = 0x00040000;
-constexpr std::uint32_t const tfLoanManageMask = ~(tfUniversal | tfLoanDefault | tfLoanImpair | tfLoanUnimpair);
-
 // clang-format on
 
 }  // namespace ripple

include/xrpl/protocol/TxFormats.h

@@ -59,8 +59,7 @@ enum TxType : std::uint16_t
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION
 
-#define TRANSACTION(tag, value, ...) \
-    tag = value,
+#define TRANSACTION(tag, value, name, fields) tag = value,
 
 #include <xrpl/protocol/detail/transactions.macro>
 

include/xrpl/protocol/XRPAmount.h

@@ -24,7 +24,7 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/json/json_value.h>
-#include <xrpl/protocol/Units.h>
+#include <xrpl/protocol/FeeUnits.h>
 
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
@@ -42,7 +42,7 @@ class XRPAmount : private boost::totally_ordered<XRPAmount>,
                   private boost::additive<XRPAmount, std::int64_t>
 {
 public:
-    using unit_type = unit::dropTag;
+    using unit_type = feeunit::dropTag;
     using value_type = std::int64_t;
 
 private:
@@ -267,7 +267,7 @@ XRPAmount::decimalXRP() const
 // Output XRPAmount as just the drops value.
 template <class Char, class Traits>
 std::basic_ostream<Char, Traits>&
-operator<<(std::basic_ostream<Char, Traits>& os, XRPAmount const& q)
+operator<<(std::basic_ostream<Char, Traits>& os, const XRPAmount& q)
 {
     return os << q.drops();
 }

include/xrpl/protocol/detail/features.macro

@@ -27,16 +27,13 @@
 #error "undefined macro: XRPL_RETIRE"
 #endif
 
-// clang-format off
-
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
+// If you add an amendment here, then do not forget to increment `numFeatures`
+// in include/xrpl/protocol/Feature.h.
 
-XRPL_FEATURE(LendingProtocol,            Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(SingleAssetVault,           Supported::no, VoteBehavior::DefaultNo)
-XRPL_FEATURE(PermissionDelegation,       Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (PayChanCancelAfter,         Supported::yes, VoteBehavior::DefaultNo)
 // Check flags in Credential transactions
+XRPL_FIX    (PseudoAccount,              Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (FrozenLPTokenTransfer,      Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
@@ -147,5 +144,3 @@ XRPL_RETIRE(fix1201)
 XRPL_RETIRE(fix1512)
 XRPL_RETIRE(fix1523)
 XRPL_RETIRE(fix1528)
-
-// clang-format on

include/xrpl/protocol/detail/ledger_entries.macro

@@ -165,9 +165,7 @@ LEDGER_ENTRY(ltACCOUNT_ROOT, 0x0061, AccountRoot, account, ({
     {sfMintedNFTokens,       soeDEFAULT},
     {sfBurnedNFTokens,       soeDEFAULT},
     {sfFirstNFTokenSequence, soeOPTIONAL},
-    {sfAMMID,                soeOPTIONAL}, // pseudo-account designator
-    {sfVaultID,              soeOPTIONAL}, // pseudo-account designator
-    {sfLoanBrokerID,         soeOPTIONAL}, // pseudo-account designator
+    {sfAMMID,                soeOPTIONAL},
 }))
 
 /** A ledger object which contains a list of object identifiers.
@@ -392,6 +390,21 @@ LEDGER_ENTRY(ltAMM, 0x0079, AMM, amm, ({
     {sfPreviousTxnLgrSeq,    soeOPTIONAL},
 }))
 
+/** A ledger object which tracks Oracle
+    \sa keylet::oracle
+ */
+LEDGER_ENTRY(ltORACLE, 0x0080, Oracle, oracle, ({
+    {sfOwner,                soeREQUIRED},
+    {sfProvider,             soeREQUIRED},
+    {sfPriceDataSeries,      soeREQUIRED},
+    {sfAssetClass,           soeREQUIRED},
+    {sfLastUpdateTime,       soeREQUIRED},
+    {sfURI,                  soeOPTIONAL},
+    {sfOwnerNode,            soeREQUIRED},
+    {sfPreviousTxnID,        soeREQUIRED},
+    {sfPreviousTxnLgrSeq,    soeREQUIRED},
+}))
+
 /** A ledger object which tracks MPTokenIssuance
     \sa keylet::mptIssuance
  */
@@ -406,7 +419,6 @@ LEDGER_ENTRY(ltMPTOKEN_ISSUANCE, 0x007e, MPTokenIssuance, mpt_issuance, ({
     {sfMPTokenMetadata,          soeOPTIONAL},
     {sfPreviousTxnID,            soeREQUIRED},
     {sfPreviousTxnLgrSeq,        soeREQUIRED},
-    {sfDomainID,                 soeOPTIONAL},
 }))
 
 /** A ledger object which tracks MPToken
@@ -421,21 +433,6 @@ LEDGER_ENTRY(ltMPTOKEN, 0x007f, MPToken, mptoken, ({
     {sfPreviousTxnLgrSeq,        soeREQUIRED},
 }))
 
-/** A ledger object which tracks Oracle
-    \sa keylet::oracle
- */
-LEDGER_ENTRY(ltORACLE, 0x0080, Oracle, oracle, ({
-    {sfOwner,                soeREQUIRED},
-    {sfProvider,             soeREQUIRED},
-    {sfPriceDataSeries,      soeREQUIRED},
-    {sfAssetClass,           soeREQUIRED},
-    {sfLastUpdateTime,       soeREQUIRED},
-    {sfURI,                  soeOPTIONAL},
-    {sfOwnerNode,            soeREQUIRED},
-    {sfPreviousTxnID,        soeREQUIRED},
-    {sfPreviousTxnLgrSeq,    soeREQUIRED},
-}))
-
 /** A ledger object which tracks Credential
     \sa keylet::credential
  */
@@ -463,101 +460,6 @@ LEDGER_ENTRY(ltPERMISSIONED_DOMAIN, 0x0082, PermissionedDomain, permissioned_dom
     {sfPreviousTxnLgrSeq,   soeREQUIRED},
 }))
 
-/** A ledger object representing permissions an account has delegated to another account.
-    \sa keylet::delegate
- */
-LEDGER_ENTRY(ltDELEGATE, 0x0083, Delegate, delegate, ({
-    {sfAccount,              soeREQUIRED},
-    {sfAuthorize,            soeREQUIRED},
-    {sfPermissions,          soeREQUIRED},
-    {sfOwnerNode,            soeREQUIRED},
-    {sfPreviousTxnID,        soeREQUIRED},
-    {sfPreviousTxnLgrSeq,    soeREQUIRED},
-}))
-
-/** A ledger object representing a single asset vault.
-
-    \sa keylet::mptoken
- */
-LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
-    {sfPreviousTxnID,        soeREQUIRED},
-    {sfPreviousTxnLgrSeq,    soeREQUIRED},
-    {sfSequence,             soeREQUIRED},
-    {sfOwnerNode,            soeREQUIRED},
-    {sfOwner,                soeREQUIRED},
-    {sfAccount,              soeREQUIRED},
-    {sfData,                 soeOPTIONAL},
-    {sfAsset,                soeREQUIRED},
-    {sfAssetsTotal,          soeREQUIRED},
-    {sfAssetsAvailable,      soeREQUIRED},
-    {sfAssetsMaximum,        soeDEFAULT},
-    {sfLossUnrealized,       soeREQUIRED},
-    {sfShareMPTID,           soeREQUIRED},
-    {sfWithdrawalPolicy,     soeREQUIRED},
-    // no SharesTotal ever (use MPTIssuance.sfOutstandingAmount)
-    // no PermissionedDomainID ever (use MPTIssuance.sfDomainID)
-}))
-
-/** Reserve 0x0084-0x0087 for future Vault-related objects. */
-
-/** A ledger object representing a loan broker
-
-    \sa keylet::loanbroker
- */
-LEDGER_ENTRY(ltLOAN_BROKER, 0x0088, LoanBroker, loan_broker, ({
-    {sfPreviousTxnID,        soeREQUIRED},
-    {sfPreviousTxnLgrSeq,    soeREQUIRED},
-    {sfSequence,             soeREQUIRED},
-    {sfOwnerNode,            soeREQUIRED},
-    {sfVaultNode,            soeREQUIRED},
-    {sfVaultID,              soeREQUIRED},
-    {sfAccount,              soeREQUIRED},
-    {sfOwner,                soeREQUIRED},
-    {sfLoanSequence,         soeREQUIRED},
-    {sfData,                 soeDEFAULT},
-    {sfManagementFeeRate,    soeDEFAULT},
-    {sfOwnerCount,           soeDEFAULT},
-    {sfDebtTotal,            soeDEFAULT},
-    {sfDebtMaximum,          soeDEFAULT},
-    {sfCoverAvailable,       soeDEFAULT},
-    {sfCoverRateMinimum,     soeDEFAULT},
-    {sfCoverRateLiquidation, soeDEFAULT},
-}))
-
-/** A ledger object representing a loan between a Borrower and a Loan Broker
-
-    \sa keylet::loan
- */
-LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({
-    {sfPreviousTxnID,        soeREQUIRED},
-    {sfPreviousTxnLgrSeq,    soeREQUIRED},
-    {sfOwnerNode,            soeREQUIRED},
-    {sfLoanBrokerNode,       soeREQUIRED},
-    {sfLoanBrokerID,         soeREQUIRED},
-    {sfLoanSequence,         soeREQUIRED},
-    {sfBorrower,             soeREQUIRED},
-    {sfLoanOriginationFee,   soeREQUIRED},
-    {sfLoanServiceFee,       soeREQUIRED},
-    {sfLatePaymentFee,       soeREQUIRED},
-    {sfClosePaymentFee,      soeREQUIRED},
-    {sfOverpaymentFee,       soeREQUIRED},
-    {sfInterestRate,         soeREQUIRED},
-    {sfLateInterestRate,     soeREQUIRED},
-    {sfCloseInterestRate,    soeREQUIRED},
-    {sfOverpaymentInterestRate, soeREQUIRED},
-    {sfStartDate,            soeREQUIRED},
-    {sfPaymentInterval,      soeREQUIRED},
-    {sfGracePeriod,          soeREQUIRED},
-    {sfPreviousPaymentDate,  soeREQUIRED},
-    {sfNextPaymentDueDate,   soeREQUIRED},
-    {sfPaymentRemaining,     soeREQUIRED},
-    {sfAssetsAvailable,      soeREQUIRED},
-    {sfPrincipalOutstanding, soeREQUIRED},
-    // Save the original request amount for rounding / scaling of
-    // other computations, particularly for IOUs
-    {sfPrincipalRequested,   soeREQUIRED},
-}))
-
 #undef EXPAND
 #undef LEDGER_ENTRY_DUPLICATE
 

include/xrpl/protocol/detail/permissions.macro

@@ -1,68 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#if !defined(PERMISSION)
-#error "undefined macro: PERMISSION"
-#endif
-
-/**
- * PERMISSION(name, type, txType, value)
- *
- * This macro defines a permission:
- * name: the name of the permission.
- * type: the GranularPermissionType enum.
- * txType: the corresponding TxType for this permission.
- * value: the uint32 numeric value for the enum type.
- */
-
-/** This permission grants the delegated account the ability to authorize a trustline. */
-PERMISSION(TrustlineAuthorize, ttTRUST_SET, 65537)
-
-/** This permission grants the delegated account the ability to freeze a trustline. */
-PERMISSION(TrustlineFreeze, ttTRUST_SET, 65538)
-
-/** This permission grants the delegated account the ability to unfreeze a trustline. */
-PERMISSION(TrustlineUnfreeze, ttTRUST_SET, 65539)
-
-/** This permission grants the delegated account the ability to set Domain. */
-PERMISSION(AccountDomainSet, ttACCOUNT_SET, 65540)
-
-/** This permission grants the delegated account the ability to set EmailHashSet. */
-PERMISSION(AccountEmailHashSet, ttACCOUNT_SET, 65541)
-
-/** This permission grants the delegated account the ability to set MessageKey. */
-PERMISSION(AccountMessageKeySet, ttACCOUNT_SET, 65542)
-
-/** This permission grants the delegated account the ability to set TransferRate. */
-PERMISSION(AccountTransferRateSet, ttACCOUNT_SET, 65543)
-
-/** This permission grants the delegated account the ability to set TickSize. */
-PERMISSION(AccountTickSizeSet, ttACCOUNT_SET, 65544)
-
-/** This permission grants the delegated account the ability to mint payment, which means sending a payment for a currency where the sending account is the issuer. */
-PERMISSION(PaymentMint, ttPAYMENT, 65545)
-
-/** This permission grants the delegated account the ability to burn payment, which means sending a payment for a currency where the destination account is the issuer */
-PERMISSION(PaymentBurn, ttPAYMENT, 65546)
-
-/** This permission grants the delegated account the ability to lock MPToken. */
-PERMISSION(MPTokenIssuanceLock, ttMPTOKEN_ISSUANCE_SET, 65547)
-
-/** This permission grants the delegated account the ability to unlock MPToken. */
-PERMISSION(MPTokenIssuanceUnlock, ttMPTOKEN_ISSUANCE_SET, 65548)

include/xrpl/protocol/detail/sfields.macro

@@ -24,8 +24,6 @@
 #error "undefined macro: TYPED_SFIELD"
 #endif
 
-// clang-format off
-
 // untyped
 UNTYPED_SFIELD(sfLedgerEntry,            LEDGERENTRY, 257)
 UNTYPED_SFIELD(sfTransaction,            TRANSACTION, 257)
@@ -44,7 +42,6 @@ TYPED_SFIELD(sfTickSize,                 UINT8,     16)
 TYPED_SFIELD(sfUNLModifyDisabling,       UINT8,     17)
 TYPED_SFIELD(sfHookResult,               UINT8,     18)
 TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
-TYPED_SFIELD(sfWithdrawalPolicy,         UINT8,     20)
 
 // 16-bit integers (common)
 TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::sMD_Never)
@@ -61,7 +58,6 @@ TYPED_SFIELD(sfHookEmitCount,            UINT16,    18)
 TYPED_SFIELD(sfHookExecutionIndex,       UINT16,    19)
 TYPED_SFIELD(sfHookApiVersion,           UINT16,    20)
 TYPED_SFIELD(sfLedgerFixType,            UINT16,    21)
-TYPED_SFIELD(sfManagementFeeRate,        UINT16,    22) // 1/10 basis points (bips)
 
 // 32-bit integers (common)
 TYPED_SFIELD(sfNetworkID,                UINT32,     1)
@@ -116,22 +112,6 @@ TYPED_SFIELD(sfEmitGeneration,           UINT32,    46)
 TYPED_SFIELD(sfVoteWeight,               UINT32,    48)
 TYPED_SFIELD(sfFirstNFTokenSequence,     UINT32,    50)
 TYPED_SFIELD(sfOracleDocumentID,         UINT32,    51)
-TYPED_SFIELD(sfPermissionValue,          UINT32,    52)
-TYPED_SFIELD(sfStartDate,                UINT32,    53)
-TYPED_SFIELD(sfPaymentInterval,          UINT32,    54)
-TYPED_SFIELD(sfGracePeriod,              UINT32,    55)
-TYPED_SFIELD(sfPreviousPaymentDate,      UINT32,    56)
-TYPED_SFIELD(sfNextPaymentDueDate,       UINT32,    57)
-TYPED_SFIELD(sfPaymentRemaining,         UINT32,    58)
-TYPED_SFIELD(sfPaymentTotal,             UINT32,    59)
-TYPED_SFIELD(sfLoanSequence,             UINT32,    60)
-TYPED_SFIELD(sfCoverRateMinimum,         UINT32,    61) // 1/10 basis points (bips)
-TYPED_SFIELD(sfCoverRateLiquidation,     UINT32,    62) // 1/10 basis points (bips)
-TYPED_SFIELD(sfOverpaymentFee,           UINT32,    63) // 1/10 basis points (bips)
-TYPED_SFIELD(sfInterestRate,             UINT32,    64) // 1/10 basis points (bips)
-TYPED_SFIELD(sfLateInterestRate,         UINT32,    65) // 1/10 basis points (bips)
-TYPED_SFIELD(sfCloseInterestRate,        UINT32,    66) // 1/10 basis points (bips)
-TYPED_SFIELD(sfOverpaymentInterestRate,  UINT32,    67) // 1/10 basis points (bips)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -162,8 +142,6 @@ TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::sMD_BaseTen|SFie
 TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::sMD_BaseTen|SField::sMD_Default)
 TYPED_SFIELD(sfIssuerNode,               UINT64,    27)
 TYPED_SFIELD(sfSubjectNode,              UINT64,    28)
-TYPED_SFIELD(sfVaultNode,                UINT64,    29)
-TYPED_SFIELD(sfLoanBrokerNode,           UINT64,    30)
 
 // 128-bit
 TYPED_SFIELD(sfEmailHash,                UINT128,    1)
@@ -176,7 +154,6 @@ TYPED_SFIELD(sfTakerGetsIssuer,          UINT160,    4)
 
 // 192-bit (common)
 TYPED_SFIELD(sfMPTokenIssuanceID,        UINT192,    1)
-TYPED_SFIELD(sfShareMPTID,               UINT192,    2)
 
 // 256-bit (common)
 TYPED_SFIELD(sfLedgerHash,               UINT256,    1)
@@ -192,8 +169,7 @@ TYPED_SFIELD(sfNFTokenID,                UINT256,   10)
 TYPED_SFIELD(sfEmitParentTxnID,          UINT256,   11)
 TYPED_SFIELD(sfEmitNonce,                UINT256,   12)
 TYPED_SFIELD(sfEmitHookHash,             UINT256,   13)
-TYPED_SFIELD(sfAMMID,                    UINT256,   14,
-    SField::sMD_PseudoAccount |SField::sMD_Default)
+TYPED_SFIELD(sfAMMID,                    UINT256,   14)
 
 // 256-bit (uncommon)
 TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
@@ -215,27 +191,9 @@ TYPED_SFIELD(sfHookHash,                 UINT256,   31)
 TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
-TYPED_SFIELD(sfVaultID,                  UINT256,   35,
-    SField::sMD_PseudoAccount | SField::sMD_Default)
-TYPED_SFIELD(sfLoanBrokerID,             UINT256,   36,
-    SField::sMD_PseudoAccount | SField::sMD_Default)
-TYPED_SFIELD(sfLoanID,                   UINT256,   37)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2)
-TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3)
-TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4)
-TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5)
-TYPED_SFIELD(sfDebtTotal,                NUMBER,     6)
-TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7)
-TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8)
-TYPED_SFIELD(sfLoanOriginationFee,       NUMBER,     9)
-TYPED_SFIELD(sfLoanServiceFee,           NUMBER,     10)
-TYPED_SFIELD(sfLatePaymentFee,           NUMBER,     11)
-TYPED_SFIELD(sfClosePaymentFee,          NUMBER,     12)
-TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13)
-TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
 
 // currency amount (common)
 TYPED_SFIELD(sfAmount,                   AMOUNT,     1)
@@ -320,7 +278,6 @@ TYPED_SFIELD(sfRegularKey,               ACCOUNT,    8)
 TYPED_SFIELD(sfNFTokenMinter,            ACCOUNT,    9)
 TYPED_SFIELD(sfEmitCallback,             ACCOUNT,   10)
 TYPED_SFIELD(sfHolder,                   ACCOUNT,   11)
-TYPED_SFIELD(sfDelegate,                 ACCOUNT,   12)
 
 // account (uncommon)
 TYPED_SFIELD(sfHookAccount,              ACCOUNT,   16)
@@ -331,8 +288,6 @@ TYPED_SFIELD(sfAttestationRewardAccount, ACCOUNT,   21)
 TYPED_SFIELD(sfLockingChainDoor,         ACCOUNT,   22)
 TYPED_SFIELD(sfIssuingChainDoor,         ACCOUNT,   23)
 TYPED_SFIELD(sfSubject,                  ACCOUNT,   24)
-TYPED_SFIELD(sfBorrower,                 ACCOUNT,   25)
-TYPED_SFIELD(sfCounterparty,             ACCOUNT,   26)
 
 // vector of 256-bit
 TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::sMD_Never)
@@ -372,7 +327,6 @@ UNTYPED_SFIELD(sfSignerEntry,            OBJECT,    11)
 UNTYPED_SFIELD(sfNFToken,                OBJECT,    12)
 UNTYPED_SFIELD(sfEmitDetails,            OBJECT,    13)
 UNTYPED_SFIELD(sfHook,                   OBJECT,    14)
-UNTYPED_SFIELD(sfPermission,             OBJECT,    15)
 
 // inner object (uncommon)
 UNTYPED_SFIELD(sfSigner,                 OBJECT,    16)
@@ -393,7 +347,6 @@ UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
-UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    34, SField::sMD_Default, SField::notSigning)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array
@@ -424,6 +377,3 @@ UNTYPED_SFIELD(sfAuthAccounts,           ARRAY,     25)
 UNTYPED_SFIELD(sfAuthorizeCredentials,   ARRAY,     26)
 UNTYPED_SFIELD(sfUnauthorizeCredentials, ARRAY,     27)
 UNTYPED_SFIELD(sfAcceptedCredentials,    ARRAY,     28)
-UNTYPED_SFIELD(sfPermissions,            ARRAY,     29)
-
-// clang-format on

include/xrpl/protocol/detail/token_errors.h

@@ -50,7 +50,7 @@ class TokenCodecErrcCategory : public std::error_category
 {
 public:
     // Return a short descriptive name for the category
-    virtual char const*
+    virtual const char*
     name() const noexcept override final
     {
         return "TokenCodecError";
@@ -86,7 +86,7 @@ public:
 };
 }  // namespace detail
 
-inline ripple::detail::TokenCodecErrcCategory const&
+inline const ripple::detail::TokenCodecErrcCategory&
 TokenCodecErrcCategory()
 {
     static ripple::detail::TokenCodecErrcCategory c;

include/xrpl/protocol/detail/transactions.macro

@@ -22,47 +22,14 @@
 #endif
 
 /**
- * TRANSACTION(tag, value, name, delegatable, privileges, fields)
- *
- * To ease maintenance, you may replace any unneeded values with "..."
- * e.g. #define TRANSACTION(tag, value, name, ...)
+ * TRANSACTION(tag, value, name, fields)
  *
  * You must define a transactor class in the `ripple` namespace named `name`,
- * and include its header alongside the TRANSACTOR definition using this
- * format:
- * #if TRANSACTION_INCLUDE
- * #   include <xrpld/app/tx/detail/HEADER.h>
- * #endif
- *
- * The `privileges` parameter of the TRANSACTION macro is a bitfield
- * defining which operations the transaction can perform.
- *
- * The values are only used in InvariantCheck.cpp
- * Valid values are
-    noPriv - The transaction can not do any of the enumerated operations
-    createAcct - The transaction can create a new ACCOUNT_ROOT object.
-    createPseudoAcct - The transaction can create a pseudo account,
-        which implies createAcct
-    mustDeleteAcct - The transaction must delete an ACCOUNT_ROOT object
-    mayDeleteAcct - The transaction may delete an ACCOUNT_ROOT object,
-        but does not have to
-    overrideFreeze - The transaction can override some freeze rules
-    changeNFTCounts - The transaction can mint or burn an NFT
-    createMPTIssuance - The transaction can create a new MPT issuance
-    destroyMPTIssuance - The transaction can destroy an MPT issuance
-    mustAuthorizeMPT - The transaction MUST create or delete an MPT
-        object (except by issuer)
-    mayAuthorizeMPT - The transaction MAY create or delete an MPT
-        object (except by issuer)
+ * and include its header in `src/xrpld/app/tx/detail/applySteps.cpp`.
  */
 
 /** This transaction type executes a payment. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Payment.h>
-#endif
-TRANSACTION(ttPAYMENT, 0, Payment,
-    Delegation::delegatable,
-    createAcct, ({
+TRANSACTION(ttPAYMENT, 0, Payment, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfSendMax, soeOPTIONAL, soeMPTSupported},
@@ -74,12 +41,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 }))
 
 /** This transaction type creates an escrow object. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Escrow.h>
-#endif
-TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfCondition, soeOPTIONAL},
@@ -89,9 +51,7 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
 }))
 
 /** This transaction type completes an existing escrow. */
-TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
     {sfFulfillment, soeOPTIONAL},
@@ -101,12 +61,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
 
 
 /** This transaction type adjusts various account settings. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/SetAccount.h>
-#endif
-TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttACCOUNT_SET, 3, AccountSet, ({
     {sfEmailHash, soeOPTIONAL},
     {sfWalletLocator, soeOPTIONAL},
     {sfWalletSize, soeOPTIONAL},
@@ -120,35 +75,20 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 }))
 
 /** This transaction type cancels an existing escrow. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Escrow.h>
-#endif
-TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel, ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
 }))
 
 /** This transaction type sets or clears an account's "regular key". */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/SetRegularKey.h>
-#endif
-TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey, ({
     {sfRegularKey, soeOPTIONAL},
 }))
 
 // 6 deprecated
 
 /** This transaction type creates an offer to trade one asset for another. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CreateOffer.h>
-#endif
-TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, ({
     {sfTakerPays, soeREQUIRED},
     {sfTakerGets, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -156,24 +96,14 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
 }))
 
 /** This transaction type cancels existing offers to trade one asset for another. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CancelOffer.h>
-#endif
-TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel, ({
     {sfOfferSequence, soeREQUIRED},
 }))
 
 // 9 deprecated
 
 /** This transaction type creates a new set of tickets. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CreateTicket.h>
-#endif
-TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, ({
     {sfTicketCount, soeREQUIRED},
 }))
 
@@ -182,23 +112,13 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
 /** This transaction type modifies the signer list associated with an account. */
 // The SignerEntries are optional because a SignerList is deleted by
 // setting the SignerQuorum to zero and omitting SignerEntries.
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/SetSignerList.h>
-#endif
-TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet, ({
     {sfSignerQuorum, soeREQUIRED},
     {sfSignerEntries, soeOPTIONAL},
 }))
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/PayChan.h>
-#endif
-TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfSettleDelay, soeREQUIRED},
@@ -208,18 +128,14 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 }))
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
-TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund, ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
 }))
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
-TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
     {sfBalance, soeOPTIONAL},
@@ -229,12 +145,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
 }))
 
 /** This transaction type creates a new check. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CreateCheck.h>
-#endif
-TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, ({
     {sfDestination, soeREQUIRED},
     {sfSendMax, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -243,34 +154,19 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
 }))
 
 /** This transaction type cashes an existing check. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CashCheck.h>
-#endif
-TRANSACTION(ttCHECK_CASH, 17, CheckCash,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCHECK_CASH, 17, CheckCash, ({
     {sfCheckID, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
     {sfDeliverMin, soeOPTIONAL},
 }))
 
 /** This transaction type cancels an existing check. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/CancelCheck.h>
-#endif
-TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel, ({
     {sfCheckID, soeREQUIRED},
 }))
 
 /** This transaction type grants or revokes authorization to transfer funds. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/DepositPreauth.h>
-#endif
-TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, ({
     {sfAuthorize, soeOPTIONAL},
     {sfUnauthorize, soeOPTIONAL},
     {sfAuthorizeCredentials, soeOPTIONAL},
@@ -278,24 +174,14 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
 }))
 
 /** This transaction type modifies a trustline between two accounts. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/SetTrust.h>
-#endif
-TRANSACTION(ttTRUST_SET, 20, TrustSet,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttTRUST_SET, 20, TrustSet, ({
     {sfLimitAmount, soeOPTIONAL},
     {sfQualityIn, soeOPTIONAL},
     {sfQualityOut, soeOPTIONAL},
 }))
 
 /** This transaction type deletes an existing account. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/DeleteAccount.h>
-#endif
-TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
-    Delegation::notDelegatable,
-    mustDeleteAcct, ({
+TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, ({
     {sfDestination, soeREQUIRED},
     {sfDestinationTag, soeOPTIONAL},
     {sfCredentialIDs, soeOPTIONAL},
@@ -304,12 +190,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
 // 22 reserved
 
 /** This transaction mints a new NFT. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenMint.h>
-#endif
-TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
-    Delegation::delegatable,
-    changeNFTCounts, ({
+TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, ({
     {sfNFTokenTaxon, soeREQUIRED},
     {sfTransferFee, soeOPTIONAL},
     {sfIssuer, soeOPTIONAL},
@@ -320,23 +201,13 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
 }))
 
 /** This transaction burns (i.e. destroys) an existing NFT. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenBurn.h>
-#endif
-TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
-    Delegation::delegatable,
-    changeNFTCounts, ({
+TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn, ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction creates a new offer to buy or sell an NFT. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenCreateOffer.h>
-#endif
-TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, ({
     {sfNFTokenID, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfDestination, soeOPTIONAL},
@@ -345,45 +216,25 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
 }))
 
 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenCancelOffer.h>
-#endif
-TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer, ({
     {sfNFTokenOffers, soeREQUIRED},
 }))
 
 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenAcceptOffer.h>
-#endif
-TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer, ({
     {sfNFTokenBuyOffer, soeOPTIONAL},
     {sfNFTokenSellOffer, soeOPTIONAL},
     {sfNFTokenBrokerFee, soeOPTIONAL},
 }))
 
 /** This transaction claws back issued tokens. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Clawback.h>
-#endif
-TRANSACTION(ttCLAWBACK, 30, Clawback,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCLAWBACK, 30, Clawback, ({
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction claws back tokens from an AMM pool. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMClawback.h>
-#endif
-TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
-    Delegation::delegatable,
-    mayDeleteAcct | overrideFreeze, ({
+TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, ({
     {sfHolder, soeREQUIRED},
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -391,24 +242,14 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
 }))
 
 /** This transaction type creates an AMM instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMCreate.h>
-#endif
-TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
-    Delegation::delegatable,
-    createPseudoAcct, ({
+TRANSACTION(ttAMM_CREATE, 35, AMMCreate, ({
     {sfAmount, soeREQUIRED},
     {sfAmount2, soeREQUIRED},
     {sfTradingFee, soeREQUIRED},
 }))
 
 /** This transaction type deposits into an AMM instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMDeposit.h>
-#endif
-TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -419,12 +260,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
 }))
 
 /** This transaction type withdraws from an AMM instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMWithdraw.h>
-#endif
-TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
-    Delegation::delegatable,
-    mayDeleteAcct, ({
+TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -434,24 +270,14 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
 }))
 
 /** This transaction type votes for the trading fee */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMVote.h>
-#endif
-TRANSACTION(ttAMM_VOTE, 38, AMMVote,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttAMM_VOTE, 38, AMMVote, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfTradingFee, soeREQUIRED},
 }))
 
 /** This transaction type bids for the auction slot */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMBid.h>
-#endif
-TRANSACTION(ttAMM_BID, 39, AMMBid,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttAMM_BID, 39, AMMBid, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfBidMin, soeOPTIONAL},
@@ -460,32 +286,20 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
 }))
 
 /** This transaction type deletes AMM in the empty state */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/AMMDelete.h>
-#endif
-TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
-    Delegation::delegatable,
-    mustDeleteAcct, ({
+TRANSACTION(ttAMM_DELETE, 40, AMMDelete, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
 }))
 
 /** This transactions creates a crosschain sequence number */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/XChainBridge.h>
-#endif
-TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
     {sfOtherChainSource, soeREQUIRED},
 }))
 
 /** This transactions initiates a crosschain transaction */
-TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -493,9 +307,7 @@ TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
 }))
 
 /** This transaction completes a crosschain transaction */
-TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
     {sfDestination, soeREQUIRED},
@@ -504,9 +316,7 @@ TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
 }))
 
 /** This transaction initiates a crosschain account create transaction */
-TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, ({
     {sfXChainBridge, soeREQUIRED},
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -514,9 +324,7 @@ TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
 }))
 
 /** This transaction adds an attestation to a claim */
-TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
-    Delegation::delegatable,
-    createAcct, ({
+TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, ({
     {sfXChainBridge, soeREQUIRED},
 
     {sfAttestationSignerAccount, soeREQUIRED},
@@ -532,10 +340,7 @@ TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
 }))
 
 /** This transaction adds an attestation to an account */
-TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
-    XChainAddAccountCreateAttestation,
-    Delegation::delegatable,
-    createAcct, ({
+TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateAttestation, ({
     {sfXChainBridge, soeREQUIRED},
 
     {sfAttestationSignerAccount, soeREQUIRED},
@@ -552,47 +357,31 @@ TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
 }))
 
 /** This transaction modifies a sidechain */
-TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeOPTIONAL},
     {sfMinAccountCreateAmount, soeOPTIONAL},
 }))
 
 /** This transactions creates a sidechain */
-TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
     {sfMinAccountCreateAmount, soeOPTIONAL},
 }))
 
 /** This transaction type creates or updates a DID */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/DID.h>
-#endif
-TRANSACTION(ttDID_SET, 49, DIDSet,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttDID_SET, 49, DIDSet, ({
     {sfDIDDocument, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
     {sfData, soeOPTIONAL},
 }))
 
 /** This transaction type deletes a DID */
-TRANSACTION(ttDID_DELETE, 50, DIDDelete,
-    Delegation::delegatable,
-    noPriv, ({}))
+TRANSACTION(ttDID_DELETE, 50, DIDDelete, ({}))
 
 /** This transaction type creates an Oracle instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/SetOracle.h>
-#endif
-TRANSACTION(ttORACLE_SET, 51, OracleSet,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttORACLE_SET, 51, OracleSet, ({
     {sfOracleDocumentID, soeREQUIRED},
     {sfProvider, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
@@ -602,33 +391,18 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
 }))
 
 /** This transaction type deletes an Oracle instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/DeleteOracle.h>
-#endif
-TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttORACLE_DELETE, 52, OracleDelete, ({
     {sfOracleDocumentID, soeREQUIRED},
 }))
 
 /** This transaction type fixes a problem in the ledger state */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LedgerStateFix.h>
-#endif
-TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, ({
     {sfLedgerFixType, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction type creates a MPTokensIssuance instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/MPTokenIssuanceCreate.h>
-#endif
-TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
-    Delegation::delegatable,
-    createMPTIssuance, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, ({
     {sfAssetScale, soeOPTIONAL},
     {sfTransferFee, soeOPTIONAL},
     {sfMaximumAmount, soeOPTIONAL},
@@ -636,44 +410,24 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
 }))
 
 /** This transaction type destroys a MPTokensIssuance instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/MPTokenIssuanceDestroy.h>
-#endif
-TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
-    Delegation::delegatable,
-    destroyMPTIssuance, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
 }))
 
 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/MPTokenIssuanceSet.h>
-#endif
-TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction type authorizes a MPToken instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/MPTokenAuthorize.h>
-#endif
-TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
-    Delegation::delegatable,
-    mustAuthorizeMPT, ({
+TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction type create an Credential instance */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Credentials.h>
-#endif
-TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, ({
     {sfSubject, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -681,268 +435,41 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
 }))
 
 /** This transaction type accept an Credential object */
-TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept, ({
     {sfIssuer, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
 }))
 
 /** This transaction type delete an Credential object */
-TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete, ({
     {sfSubject, soeOPTIONAL},
     {sfIssuer, soeOPTIONAL},
     {sfCredentialType, soeREQUIRED},
 }))
 
 /** This transaction type modify a NFToken */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/NFTokenModify.h>
-#endif
-TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify, ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
 }))
 
 /** This transaction type creates or modifies a Permissioned Domain */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/PermissionedDomainSet.h>
-#endif
-TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet, ({
     {sfDomainID, soeOPTIONAL},
     {sfAcceptedCredentials, soeREQUIRED},
 }))
 
 /** This transaction type deletes a Permissioned Domain */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/PermissionedDomainDelete.h>
-#endif
-TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
-    Delegation::delegatable,
-    noPriv, ({
+TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete, ({
     {sfDomainID, soeREQUIRED},
 }))
 
-/** This transaction type delegates authorized account specified permissions */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/DelegateSet.h>
-#endif
-TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
-    Delegation::notDelegatable,
-    noPriv, ({
-    {sfAuthorize, soeREQUIRED},
-    {sfPermissions, soeREQUIRED},
-}))
-
-/** This transaction creates a single asset vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultCreate.h>
-#endif
-TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
-    Delegation::delegatable,
-    createPseudoAcct | createMPTIssuance, ({
-    {sfAsset, soeREQUIRED, soeMPTSupported},
-    {sfAssetsMaximum, soeOPTIONAL},
-    {sfMPTokenMetadata, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
-    {sfWithdrawalPolicy, soeOPTIONAL},
-    {sfData, soeOPTIONAL},
-}))
-
-/** This transaction updates a single asset vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultSet.h>
-#endif
-TRANSACTION(ttVAULT_SET, 66, VaultSet,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfVaultID, soeREQUIRED},
-    {sfAssetsMaximum, soeOPTIONAL},
-    {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
-    {sfData, soeOPTIONAL},
-}))
-
-/** This transaction deletes a single asset vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultDelete.h>
-#endif
-TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
-    Delegation::delegatable,
-    mustDeleteAcct | destroyMPTIssuance, ({
-    {sfVaultID, soeREQUIRED},
-}))
-
-/** This transaction trades assets for shares with a vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultDeposit.h>
-#endif
-TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
-    Delegation::delegatable,
-    mayAuthorizeMPT, ({
-    {sfVaultID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-}))
-
-/** This transaction trades shares for assets with a vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultWithdraw.h>
-#endif
-TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfVaultID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-    {sfDestination, soeOPTIONAL},
-}))
-
-/** This transaction claws back tokens from a vault. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/VaultClawback.h>
-#endif
-TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfVaultID, soeREQUIRED},
-    {sfHolder, soeREQUIRED},
-    {sfAmount, soeOPTIONAL, soeMPTSupported},
-}))
-
-/** Reserve 71-73 for future Vault-related transactions */
-
-/** This transaction creates and updates a Loan Broker */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanBrokerSet.h>
-#endif
-TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
-    Delegation::delegatable,
-    createPseudoAcct | mayAuthorizeMPT, ({
-    {sfVaultID, soeREQUIRED},
-    {sfLoanBrokerID, soeOPTIONAL},
-    {sfData, soeOPTIONAL},
-    {sfManagementFeeRate, soeOPTIONAL},
-    {sfDebtMaximum, soeOPTIONAL},
-    {sfCoverRateMinimum, soeOPTIONAL},
-    {sfCoverRateLiquidation, soeOPTIONAL},
-}))
-
-/** This transaction deletes a Loan Broker */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanBrokerDelete.h>
-#endif
-TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
-    Delegation::delegatable,
-    mustDeleteAcct | mayAuthorizeMPT, ({
-    {sfLoanBrokerID, soeREQUIRED},
-}))
-
-/** This transaction deposits First Loss Capital into a Loan Broker */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanBrokerCoverDeposit.h>
-#endif
-TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanBrokerID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-}))
-
-/** This transaction withdraws First Loss Capital from a Loan Broker */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanBrokerCoverWithdraw.h>
-#endif
-TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanBrokerID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-}))
-
-/** This transaction creates a Loan */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanSet.h>
-#endif
-TRANSACTION(ttLOAN_SET, 78, LoanSet,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanBrokerID, soeREQUIRED},
-    {sfData, soeOPTIONAL},
-    {sfCounterparty, soeOPTIONAL},
-    {sfCounterpartySignature, soeREQUIRED},
-    {sfLoanOriginationFee, soeOPTIONAL},
-    {sfLoanServiceFee, soeOPTIONAL},
-    {sfLatePaymentFee, soeOPTIONAL},
-    {sfClosePaymentFee, soeOPTIONAL},
-    {sfOverpaymentFee, soeOPTIONAL},
-    {sfInterestRate, soeOPTIONAL},
-    {sfLateInterestRate, soeOPTIONAL},
-    {sfCloseInterestRate, soeOPTIONAL},
-    {sfOverpaymentInterestRate, soeOPTIONAL},
-    {sfPrincipalRequested, soeREQUIRED},
-    {sfStartDate, soeREQUIRED},
-    {sfPaymentTotal, soeOPTIONAL},
-    {sfPaymentInterval, soeOPTIONAL},
-    {sfGracePeriod, soeOPTIONAL},
-}))
-
-/** This transaction deletes an existing Loan */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanDelete.h>
-#endif
-TRANSACTION(ttLOAN_DELETE, 79, LoanDelete,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanID, soeREQUIRED},
-}))
-
-/** This transaction is used to change the delinquency status of an existing Loan */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanManage.h>
-#endif
-TRANSACTION(ttLOAN_MANAGE, 80, LoanManage,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanID, soeREQUIRED},
-}))
-
-/** The Borrower uses this transaction to draws funds from the Loan. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanDraw.h>
-#endif
-TRANSACTION(ttLOAN_DRAW, 81, LoanDraw,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-}))
-
-/** The Borrower uses this transaction to make a Payment on the Loan. */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/LoanPay.h>
-#endif
-TRANSACTION(ttLOAN_PAY, 82, LoanPay,
-    Delegation::delegatable,
-    noPriv, ({
-    {sfLoanID, soeREQUIRED},
-    {sfAmount, soeREQUIRED, soeMPTSupported},
-}))
-
 /** This system-generated transaction type is used to update the status of the various amendments.
 
     For details, see: https://xrpl.org/amendments.html
  */
-#if TRANSACTION_INCLUDE
-#   include <xrpld/app/tx/detail/Change.h>
-#endif
-TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttAMENDMENT, 100, EnableAmendment, ({
     {sfLedgerSequence, soeREQUIRED},
     {sfAmendment, soeREQUIRED},
 }))
@@ -950,9 +477,7 @@ TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
 /** This system-generated transaction type is used to update the network's fee settings.
     For details, see: https://xrpl.org/fee-voting.html
  */
-TRANSACTION(ttFEE, 101, SetFee,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttFEE, 101, SetFee, ({
     {sfLedgerSequence, soeOPTIONAL},
     // Old version uses raw numbers
     {sfBaseFee, soeOPTIONAL},
@@ -969,9 +494,7 @@ TRANSACTION(ttFEE, 101, SetFee,
 
     For details, see: https://xrpl.org/negative-unl.html
  */
-TRANSACTION(ttUNL_MODIFY, 102, UNLModify,
-    Delegation::notDelegatable,
-    noPriv, ({
+TRANSACTION(ttUNL_MODIFY, 102, UNLModify, ({
     {sfUNLModifyDisabling, soeREQUIRED},
     {sfLedgerSequence, soeREQUIRED},
     {sfUNLModifyValidator, soeREQUIRED},

include/xrpl/protocol/json_get_or_throw.h

@@ -20,7 +20,7 @@ struct JsonMissingKeyError : std::exception
     JsonMissingKeyError(Json::StaticString const& k) : key{k.c_str()}
     {
     }
-    char const*
+    const char*
     what() const noexcept override
     {
         if (msg.empty())
@@ -40,7 +40,7 @@ struct JsonTypeMismatchError : std::exception
         : key{k.c_str()}, expectedType{std::move(et)}
     {
     }
-    char const*
+    const char*
     what() const noexcept override
     {
         if (msg.empty())

include/xrpl/protocol/jss.h

@@ -95,10 +95,10 @@ JSS(SigningPubKey);                      // field.
 JSS(Subject);                            // in: Credential transactions
 JSS(TakerGets);                          // field.
 JSS(TakerPays);                          // field.
+JSS(TxnSignature);                       // field.
 JSS(TradingFee);                         // in/out: AMM trading fee
 JSS(TransactionType);                    // in: TransactionSign.
 JSS(TransferRate);                       // in: TransferRate.
-JSS(TxnSignature);                       // field.
 JSS(URI);                                // field.
 JSS(VoteSlots);                          // out: AMM Vote
 JSS(aborted);                            // out: InboundLedger
@@ -145,7 +145,6 @@ JSS(attestations);
 JSS(attestation_reward_account);
 JSS(auction_slot);            // out: amm_info
 JSS(authorized);              // out: AccountLines
-JSS(authorize);               // out: delegate
 JSS(authorized_credentials);   // in: ledger_entry DepositPreauth
 JSS(auth_accounts);           // out: amm_info
 JSS(auth_change);             // out: AccountInfo
@@ -449,7 +448,6 @@ JSS(node_reads_hit);          // out: GetCounts
 JSS(node_reads_total);        // out: GetCounts
 JSS(node_reads_duration_us);  // out: GetCounts
 JSS(node_size);               // out: server_info
-JSS(nodes);                   // out: VaultInfo
 JSS(nodestore);               // out: GetCounts
 JSS(node_writes);             // out: GetCounts
 JSS(node_written_bytes);      // out: GetCounts
@@ -560,7 +558,6 @@ JSS(server_status);           // out: NetworkOPs
 JSS(server_version);          // out: NetworkOPs
 JSS(settle_delay);            // out: AccountChannels
 JSS(severity);                // in: LogLevel
-JSS(shares);                  // out: VaultInfo
 JSS(signature);               // out: NetworkOPs, ChannelAuthorize
 JSS(signature_verified);      // out: ChannelVerify
 JSS(signing_key);             // out: NetworkOPs
@@ -686,7 +683,6 @@ JSS(validations);               // out: AmendmentTableImpl
 JSS(validator_list_threshold);  // out: ValidatorList
 JSS(validator_sites);           // out: ValidatorSites
 JSS(value);                     // out: STAmount
-JSS(vault_id);                  // in: VaultInfo
 JSS(version);                   // out: RPCVersion
 JSS(vetoed);                    // out: AmendmentTableImpl
 JSS(volume_a);                  // out: BookChanges
@@ -703,7 +699,7 @@ JSS(write_load);              // out: GetCounts
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION
 
-#define TRANSACTION(tag, value, name, ...) JSS(name);
+#define TRANSACTION(tag, value, name, fields) JSS(name);
 
 #include <xrpl/protocol/detail/transactions.macro>
 

src/libxrpl/basics/Archive.cpp

@@ -94,7 +94,7 @@ extractTarLz4(
 
         if (archive_entry_size(entry) > 0)
         {
-            void const* buf;
+            const void* buf;
             size_t sz;
             la_int64_t offset;
             while (true)

src/libxrpl/basics/FileUtilities.cpp

@@ -63,7 +63,7 @@ getFileContents(
         return {};
     }
 
-    std::string const result{
+    const std::string result{
         std::istreambuf_iterator<char>{fileStream},
         std::istreambuf_iterator<char>{}};
 

src/libxrpl/basics/Number.cpp

@@ -20,8 +20,6 @@
 #include <xrpl/basics/Number.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <boost/predef.h>
-
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
@@ -33,13 +31,12 @@
 #include <type_traits>
 #include <utility>
 
-#ifdef _MSC_VER
-#pragma message("Using boost::multiprecision::uint128_t")
+#ifdef BOOST_COMP_MSVC
 #include <boost/multiprecision/cpp_int.hpp>
 using uint128_t = boost::multiprecision::uint128_t;
-#else   // !defined(_MSC_VER)
+#else   // !defined(_MSVC_LANG)
 using uint128_t = __uint128_t;
-#endif  // !defined(_MSC_VER)
+#endif  // !defined(_MSVC_LANG)
 
 namespace ripple {
 
@@ -471,7 +468,7 @@ Number::operator/=(Number const& y)
     }
     // Shift by 10^17 gives greatest precision while not overflowing uint128_t
     // or the cast back to int64_t
-    uint128_t const f = 100'000'000'000'000'000;
+    const uint128_t f = 100'000'000'000'000'000;
     mantissa_ = static_cast<std::int64_t>(uint128_t(nm) * f / uint128_t(dm));
     exponent_ = ne - de - 17;
     mantissa_ *= np * dp;

src/libxrpl/basics/StringUtilities.cpp

@@ -89,13 +89,13 @@ parseUrl(parsedURL& pUrl, std::string const& strUrl)
     boost::algorithm::to_lower(pUrl.scheme);
     pUrl.username = smMatch[2];
     pUrl.password = smMatch[3];
-    std::string const domain = smMatch[4];
+    const std::string domain = smMatch[4];
     // We need to use Endpoint to parse the domain to
     // strip surrounding brackets from IPv6 addresses,
     // e.g. [::1] => ::1.
-    auto const result = beast::IP::Endpoint::from_string_checked(domain);
+    const auto result = beast::IP::Endpoint::from_string_checked(domain);
     pUrl.domain = result ? result->address().to_string() : domain;
-    std::string const port = smMatch[5];
+    const std::string port = smMatch[5];
     if (!port.empty())
     {
         pUrl.port = beast::lexicalCast<std::uint16_t>(port);

src/libxrpl/basics/UptimeClock.cpp

@@ -67,7 +67,7 @@ UptimeClock::time_point
 UptimeClock::now()
 {
     // start the update thread on first use
-    static auto const init = start_clock();
+    static const auto init = start_clock();
 
     // Return the number of seconds since rippled start
     return time_point{duration{now_}};

src/libxrpl/basics/mulDiv.cpp

@@ -31,7 +31,9 @@ namespace ripple {
 std::optional<std::uint64_t>
 mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div)
 {
-    boost::multiprecision::uint128_t result;
+    using namespace boost::multiprecision;
+
+    uint128_t result;
     result = multiply(result, value, mul);
 
     result /= div;

src/libxrpl/json/Writer.cpp

@@ -34,7 +34,7 @@ namespace Json {
 
 namespace {
 
-std::map<char, char const*> jsonSpecialCharacterEscape = {
+std::map<char, const char*> jsonSpecialCharacterEscape = {
     {'"', "\\\""},
     {'\\', "\\\\"},
     {'/', "\\/"},
@@ -47,13 +47,13 @@ std::map<char, char const*> jsonSpecialCharacterEscape = {
 static size_t const jsonEscapeLength = 2;
 
 // All other JSON punctuation.
-char const closeBrace = '}';
-char const closeBracket = ']';
-char const colon = ':';
-char const comma = ',';
-char const openBrace = '{';
-char const openBracket = '[';
-char const quote = '"';
+const char closeBrace = '}';
+const char closeBracket = ']';
+const char colon = ':';
+const char comma = ',';
+const char openBrace = '{';
+const char openBracket = '[';
+const char quote = '"';
 
 static auto const integralFloatsBecomeInts = false;
 

src/libxrpl/json/json_reader.cpp

@@ -78,8 +78,8 @@ bool
 Reader::parse(std::string const& document, Value& root)
 {
     document_ = document;
-    char const* begin = document_.c_str();
-    char const* end = begin + document_.length();
+    const char* begin = document_.c_str();
+    const char* end = begin + document_.length();
     return parse(begin, end, root);
 }
 
@@ -99,7 +99,7 @@ Reader::parse(std::istream& sin, Value& root)
 }
 
 bool
-Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
+Reader::parse(const char* beginDoc, const char* endDoc, Value& root)
 {
     begin_ = beginDoc;
     end_ = endDoc;
@@ -193,7 +193,7 @@ Reader::skipCommentTokens(Token& token)
 }
 
 bool
-Reader::expectToken(TokenType type, Token& token, char const* message)
+Reader::expectToken(TokenType type, Token& token, const char* message)
 {
     readToken(token);
 
@@ -629,7 +629,7 @@ bool
 Reader::decodeDouble(Token& token)
 {
     double value = 0;
-    int const bufferSize = 32;
+    const int bufferSize = 32;
     int count;
     int length = int(token.end_ - token.start_);
     // Sanity check to avoid buffer overflow exploits.
@@ -939,7 +939,7 @@ Reader::getFormatedErrorMessages() const
          itError != errors_.end();
          ++itError)
     {
-        ErrorInfo const& error = *itError;
+        const ErrorInfo& error = *itError;
         formattedMessage +=
             "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
         formattedMessage += "  " + error.message_ + "\n";

src/libxrpl/json/json_value.cpp

@@ -31,10 +31,10 @@
 
 namespace Json {
 
-Value const Value::null;
-Int const Value::minInt = Int(~(UInt(-1) / 2));
-Int const Value::maxInt = Int(UInt(-1) / 2);
-UInt const Value::maxUInt = UInt(-1);
+const Value Value::null;
+const Int Value::minInt = Int(~(UInt(-1) / 2));
+const Int Value::maxInt = Int(UInt(-1) / 2);
+const UInt Value::maxUInt = UInt(-1);
 
 class DefaultValueAllocator : public ValueAllocator
 {
@@ -42,7 +42,7 @@ public:
     virtual ~DefaultValueAllocator() = default;
 
     char*
-    makeMemberName(char const* memberName) override
+    makeMemberName(const char* memberName) override
     {
         return duplicateStringValue(memberName);
     }
@@ -54,7 +54,7 @@ public:
     }
 
     char*
-    duplicateStringValue(char const* value, unsigned int length = unknown)
+    duplicateStringValue(const char* value, unsigned int length = unknown)
         override
     {
         //@todo investigate this old optimization
@@ -110,14 +110,14 @@ Value::CZString::CZString(int index) : cstr_(0), index_(index)
 {
 }
 
-Value::CZString::CZString(char const* cstr, DuplicationPolicy allocate)
+Value::CZString::CZString(const char* cstr, DuplicationPolicy allocate)
     : cstr_(
           allocate == duplicate ? valueAllocator()->makeMemberName(cstr) : cstr)
     , index_(allocate)
 {
 }
 
-Value::CZString::CZString(CZString const& other)
+Value::CZString::CZString(const CZString& other)
     : cstr_(
           other.index_ != noDuplication && other.cstr_ != 0
               ? valueAllocator()->makeMemberName(other.cstr_)
@@ -136,7 +136,7 @@ Value::CZString::~CZString()
 }
 
 bool
-Value::CZString::operator<(CZString const& other) const
+Value::CZString::operator<(const CZString& other) const
 {
     if (cstr_ && other.cstr_)
         return strcmp(cstr_, other.cstr_) < 0;
@@ -145,7 +145,7 @@ Value::CZString::operator<(CZString const& other) const
 }
 
 bool
-Value::CZString::operator==(CZString const& other) const
+Value::CZString::operator==(const CZString& other) const
 {
     if (cstr_ && other.cstr_)
         return strcmp(cstr_, other.cstr_) == 0;
@@ -159,7 +159,7 @@ Value::CZString::index() const
     return index_;
 }
 
-char const*
+const char*
 Value::CZString::c_str() const
 {
     return cstr_;
@@ -232,25 +232,18 @@ Value::Value(double value) : type_(realValue)
     value_.real_ = value;
 }
 
-Value::Value(char const* value) : type_(stringValue), allocated_(true)
+Value::Value(const char* value) : type_(stringValue), allocated_(true)
 {
     value_.string_ = valueAllocator()->duplicateStringValue(value);
 }
 
-Value::Value(ripple::Number const& value) : type_(stringValue), allocated_(true)
-{
-    auto const tmp = to_string(value);
-    value_.string_ =
-        valueAllocator()->duplicateStringValue(tmp.c_str(), tmp.length());
-}
-
 Value::Value(std::string const& value) : type_(stringValue), allocated_(true)
 {
     value_.string_ = valueAllocator()->duplicateStringValue(
         value.c_str(), (unsigned int)value.length());
 }
 
-Value::Value(StaticString const& value) : type_(stringValue), allocated_(false)
+Value::Value(const StaticString& value) : type_(stringValue), allocated_(false)
 {
     value_.string_ = const_cast<char*>(value.c_str());
 }
@@ -260,7 +253,7 @@ Value::Value(bool value) : type_(booleanValue)
     value_.bool_ = value;
 }
 
-Value::Value(Value const& other) : type_(other.type_)
+Value::Value(const Value& other) : type_(other.type_)
 {
     switch (type_)
     {
@@ -377,7 +370,7 @@ integerCmp(Int i, UInt ui)
 }
 
 bool
-operator<(Value const& x, Value const& y)
+operator<(const Value& x, const Value& y)
 {
     if (auto signum = x.type_ - y.type_)
     {
@@ -426,7 +419,7 @@ operator<(Value const& x, Value const& y)
 }
 
 bool
-operator==(Value const& x, Value const& y)
+operator==(const Value& x, const Value& y)
 {
     if (x.type_ != y.type_)
     {
@@ -471,7 +464,7 @@ operator==(Value const& x, Value const& y)
     return 0;  // unreachable
 }
 
-char const*
+const char*
 Value::asCString() const
 {
     XRPL_ASSERT(type_ == stringValue, "Json::Value::asCString : valid type");
@@ -802,7 +795,7 @@ Value::operator[](UInt index)
     return (*it).second;
 }
 
-Value const&
+const Value&
 Value::operator[](UInt index) const
 {
     XRPL_ASSERT(
@@ -822,13 +815,13 @@ Value::operator[](UInt index) const
 }
 
 Value&
-Value::operator[](char const* key)
+Value::operator[](const char* key)
 {
     return resolveReference(key, false);
 }
 
 Value&
-Value::resolveReference(char const* key, bool isStatic)
+Value::resolveReference(const char* key, bool isStatic)
 {
     XRPL_ASSERT(
         type_ == nullValue || type_ == objectValue,
@@ -851,9 +844,9 @@ Value::resolveReference(char const* key, bool isStatic)
 }
 
 Value
-Value::get(UInt index, Value const& defaultValue) const
+Value::get(UInt index, const Value& defaultValue) const
 {
-    Value const* value = &((*this)[index]);
+    const Value* value = &((*this)[index]);
     return value == &null ? defaultValue : *value;
 }
 
@@ -863,8 +856,8 @@ Value::isValidIndex(UInt index) const
     return index < size();
 }
 
-Value const&
-Value::operator[](char const* key) const
+const Value&
+Value::operator[](const char* key) const
 {
     XRPL_ASSERT(
         type_ == nullValue || type_ == objectValue,
@@ -888,26 +881,20 @@ Value::operator[](std::string const& key)
     return (*this)[key.c_str()];
 }
 
-Value const&
+const Value&
 Value::operator[](std::string const& key) const
 {
     return (*this)[key.c_str()];
 }
 
 Value&
-Value::operator[](StaticString const& key)
+Value::operator[](const StaticString& key)
 {
     return resolveReference(key, true);
 }
 
-Value const&
-Value::operator[](StaticString const& key) const
-{
-    return (*this)[key.c_str()];
-}
-
 Value&
-Value::append(Value const& value)
+Value::append(const Value& value)
 {
     return (*this)[size()] = value;
 }
@@ -919,20 +906,20 @@ Value::append(Value&& value)
 }
 
 Value
-Value::get(char const* key, Value const& defaultValue) const
+Value::get(const char* key, const Value& defaultValue) const
 {
-    Value const* value = &((*this)[key]);
+    const Value* value = &((*this)[key]);
     return value == &null ? defaultValue : *value;
 }
 
 Value
-Value::get(std::string const& key, Value const& defaultValue) const
+Value::get(std::string const& key, const Value& defaultValue) const
 {
     return get(key.c_str(), defaultValue);
 }
 
 Value
-Value::removeMember(char const* key)
+Value::removeMember(const char* key)
 {
     XRPL_ASSERT(
         type_ == nullValue || type_ == objectValue,
@@ -959,12 +946,12 @@ Value::removeMember(std::string const& key)
 }
 
 bool
-Value::isMember(char const* key) const
+Value::isMember(const char* key) const
 {
     if (type_ != objectValue)
         return false;
 
-    Value const* value = &((*this)[key]);
+    const Value* value = &((*this)[key]);
     return value != &null;
 }
 

src/libxrpl/json/json_valueiterator.cpp

@@ -37,7 +37,7 @@ ValueIteratorBase::ValueIteratorBase() : current_(), isNull_(true)
 }
 
 ValueIteratorBase::ValueIteratorBase(
-    Value::ObjectValues::iterator const& current)
+    const Value::ObjectValues::iterator& current)
     : current_(current), isNull_(false)
 {
 }
@@ -61,7 +61,7 @@ ValueIteratorBase::decrement()
 }
 
 ValueIteratorBase::difference_type
-ValueIteratorBase::computeDistance(SelfType const& other) const
+ValueIteratorBase::computeDistance(const SelfType& other) const
 {
     // Iterator for null value are initialized using the default
     // constructor, which initialize current_ to the default
@@ -89,7 +89,7 @@ ValueIteratorBase::computeDistance(SelfType const& other) const
 }
 
 bool
-ValueIteratorBase::isEqual(SelfType const& other) const
+ValueIteratorBase::isEqual(const SelfType& other) const
 {
     if (isNull_)
     {
@@ -100,7 +100,7 @@ ValueIteratorBase::isEqual(SelfType const& other) const
 }
 
 void
-ValueIteratorBase::copy(SelfType const& other)
+ValueIteratorBase::copy(const SelfType& other)
 {
     current_ = other.current_;
 }
@@ -108,7 +108,7 @@ ValueIteratorBase::copy(SelfType const& other)
 Value
 ValueIteratorBase::key() const
 {
-    Value::CZString const czstring = (*current_).first;
+    const Value::CZString czstring = (*current_).first;
 
     if (czstring.c_str())
     {
@@ -124,7 +124,7 @@ ValueIteratorBase::key() const
 UInt
 ValueIteratorBase::index() const
 {
-    Value::CZString const czstring = (*current_).first;
+    const Value::CZString czstring = (*current_).first;
 
     if (!czstring.c_str())
         return czstring.index();
@@ -132,10 +132,10 @@ ValueIteratorBase::index() const
     return Value::UInt(-1);
 }
 
-char const*
+const char*
 ValueIteratorBase::memberName() const
 {
-    char const* name = (*current_).first.c_str();
+    const char* name = (*current_).first.c_str();
     return name ? name : "";
 }
 
@@ -148,13 +148,13 @@ ValueIteratorBase::memberName() const
 // //////////////////////////////////////////////////////////////////
 
 ValueConstIterator::ValueConstIterator(
-    Value::ObjectValues::iterator const& current)
+    const Value::ObjectValues::iterator& current)
     : ValueIteratorBase(current)
 {
 }
 
 ValueConstIterator&
-ValueConstIterator::operator=(ValueIteratorBase const& other)
+ValueConstIterator::operator=(const ValueIteratorBase& other)
 {
     copy(other);
     return *this;
@@ -168,23 +168,23 @@ ValueConstIterator::operator=(ValueIteratorBase const& other)
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 
-ValueIterator::ValueIterator(Value::ObjectValues::iterator const& current)
+ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
     : ValueIteratorBase(current)
 {
 }
 
-ValueIterator::ValueIterator(ValueConstIterator const& other)
+ValueIterator::ValueIterator(const ValueConstIterator& other)
     : ValueIteratorBase(other)
 {
 }
 
-ValueIterator::ValueIterator(ValueIterator const& other)
+ValueIterator::ValueIterator(const ValueIterator& other)
     : ValueIteratorBase(other)
 {
 }
 
 ValueIterator&
-ValueIterator::operator=(SelfType const& other)
+ValueIterator::operator=(const SelfType& other)
 {
     copy(other);
     return *this;

src/libxrpl/json/json_writer.cpp

@@ -40,7 +40,7 @@ isControlCharacter(char ch)
 }
 
 static bool
-containsControlCharacter(char const* str)
+containsControlCharacter(const char* str)
 {
     while (*str)
     {
@@ -117,7 +117,7 @@ valueToString(bool value)
 }
 
 std::string
-valueToQuotedString(char const* value)
+valueToQuotedString(const char* value)
 {
     // Not sure how to handle unicode...
     if (strpbrk(value, "\"\\\b\f\n\r\t") == nullptr &&
@@ -132,7 +132,7 @@ valueToQuotedString(char const* value)
     result.reserve(maxsize);  // to avoid lots of mallocs
     result += "\"";
 
-    for (char const* c = value; *c != 0; ++c)
+    for (const char* c = value; *c != 0; ++c)
     {
         switch (*c)
         {
@@ -197,7 +197,7 @@ valueToQuotedString(char const* value)
 // //////////////////////////////////////////////////////////////////
 
 std::string
-FastWriter::write(Value const& root)
+FastWriter::write(const Value& root)
 {
     document_ = "";
     writeValue(root);
@@ -205,7 +205,7 @@ FastWriter::write(Value const& root)
 }
 
 void
-FastWriter::writeValue(Value const& value)
+FastWriter::writeValue(const Value& value)
 {
     switch (value.type())
     {
@@ -281,7 +281,7 @@ StyledWriter::StyledWriter() : rightMargin_(74), indentSize_(3)
 }
 
 std::string
-StyledWriter::write(Value const& root)
+StyledWriter::write(const Value& root)
 {
     document_ = "";
     addChildValues_ = false;
@@ -292,7 +292,7 @@ StyledWriter::write(Value const& root)
 }
 
 void
-StyledWriter::writeValue(Value const& value)
+StyledWriter::writeValue(const Value& value)
 {
     switch (value.type())
     {
@@ -338,7 +338,7 @@ StyledWriter::writeValue(Value const& value)
                 while (true)
                 {
                     std::string const& name = *it;
-                    Value const& childValue = value[name];
+                    const Value& childValue = value[name];
                     writeWithIndent(valueToQuotedString(name.c_str()));
                     document_ += " : ";
                     writeValue(childValue);
@@ -358,7 +358,7 @@ StyledWriter::writeValue(Value const& value)
 }
 
 void
-StyledWriter::writeArrayValue(Value const& value)
+StyledWriter::writeArrayValue(const Value& value)
 {
     unsigned size = value.size();
 
@@ -377,7 +377,7 @@ StyledWriter::writeArrayValue(Value const& value)
 
             while (true)
             {
-                Value const& childValue = value[index];
+                const Value& childValue = value[index];
 
                 if (hasChildValue)
                     writeWithIndent(childValues_[index]);
@@ -417,7 +417,7 @@ StyledWriter::writeArrayValue(Value const& value)
 }
 
 bool
-StyledWriter::isMultineArray(Value const& value)
+StyledWriter::isMultineArray(const Value& value)
 {
     int size = value.size();
     bool isMultiLine = size * 3 >= rightMargin_;
@@ -425,7 +425,7 @@ StyledWriter::isMultineArray(Value const& value)
 
     for (int index = 0; index < size && !isMultiLine; ++index)
     {
-        Value const& childValue = value[index];
+        const Value& childValue = value[index];
         isMultiLine = isMultiLine ||
             ((childValue.isArray() || childValue.isObject()) &&
              childValue.size() > 0);
@@ -507,7 +507,7 @@ StyledStreamWriter::StyledStreamWriter(std::string indentation)
 }
 
 void
-StyledStreamWriter::write(std::ostream& out, Value const& root)
+StyledStreamWriter::write(std::ostream& out, const Value& root)
 {
     document_ = &out;
     addChildValues_ = false;
@@ -518,7 +518,7 @@ StyledStreamWriter::write(std::ostream& out, Value const& root)
 }
 
 void
-StyledStreamWriter::writeValue(Value const& value)
+StyledStreamWriter::writeValue(const Value& value)
 {
     switch (value.type())
     {
@@ -564,7 +564,7 @@ StyledStreamWriter::writeValue(Value const& value)
                 while (true)
                 {
                     std::string const& name = *it;
-                    Value const& childValue = value[name];
+                    const Value& childValue = value[name];
                     writeWithIndent(valueToQuotedString(name.c_str()));
                     *document_ << " : ";
                     writeValue(childValue);
@@ -584,7 +584,7 @@ StyledStreamWriter::writeValue(Value const& value)
 }
 
 void
-StyledStreamWriter::writeArrayValue(Value const& value)
+StyledStreamWriter::writeArrayValue(const Value& value)
 {
     unsigned size = value.size();
 
@@ -603,7 +603,7 @@ StyledStreamWriter::writeArrayValue(Value const& value)
 
             while (true)
             {
-                Value const& childValue = value[index];
+                const Value& childValue = value[index];
 
                 if (hasChildValue)
                     writeWithIndent(childValues_[index]);
@@ -643,7 +643,7 @@ StyledStreamWriter::writeArrayValue(Value const& value)
 }
 
 bool
-StyledStreamWriter::isMultineArray(Value const& value)
+StyledStreamWriter::isMultineArray(const Value& value)
 {
     int size = value.size();
     bool isMultiLine = size * 3 >= rightMargin_;
@@ -651,7 +651,7 @@ StyledStreamWriter::isMultineArray(Value const& value)
 
     for (int index = 0; index < size && !isMultiLine; ++index)
     {
-        Value const& childValue = value[index];
+        const Value& childValue = value[index];
         isMultiLine = isMultiLine ||
             ((childValue.isArray() || childValue.isObject()) &&
              childValue.size() > 0);
@@ -726,7 +726,7 @@ StyledStreamWriter::unindent()
 }
 
 std::ostream&
-operator<<(std::ostream& sout, Value const& root)
+operator<<(std::ostream& sout, const Value& root)
 {
     Json::StyledStreamWriter writer;
     writer.write(sout, root);

src/libxrpl/protocol/Asset.cpp

@@ -23,7 +23,6 @@
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/MPTIssue.h>
-#include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/jss.h>
 
 #include <stdexcept>
@@ -52,12 +51,6 @@ Asset::setJson(Json::Value& jv) const
     std::visit([&](auto&& issue) { issue.setJson(jv); }, issue_);
 }
 
-STAmount
-Asset::operator()(Number const& number) const
-{
-    return STAmount{*this, number};
-}
-
 std::string
 to_string(Asset const& asset)
 {
@@ -85,4 +78,11 @@ assetFromJson(Json::Value const& v)
     return mptIssueFromJson(v);
 }
 
+Json::Value
+to_json(Asset const& asset)
+{
+    return std::visit(
+        [&](auto const& issue) { return to_json(issue); }, asset.value());
+}
+
 }  // namespace ripple

src/libxrpl/protocol/ErrorCodes.cpp

@@ -96,7 +96,6 @@ constexpr static ErrorInfo unorderedErrorInfos[]{
     {rpcNOT_SYNCED,             "notSynced",            "Not synced to the network.", 503},
     {rpcNO_EVENTS,              "noEvents",             "Current transport does not support events.", 405},
     {rpcNO_NETWORK,             "noNetwork",            "Not synced to the network.", 503},
-    {rpcWRONG_NETWORK,          "wrongNetwork",         "Wrong network.", 503},
     {rpcNO_PERMISSION,          "noPermission",         "You don't have permission for this command.", 401},
     {rpcNO_PF_REQUEST,          "noPathRequest",        "No pathfinding request in progress.", 404},
     {rpcOBJECT_NOT_FOUND,       "objectNotFound",       "The requested object was not found.", 404},
@@ -107,7 +106,6 @@ constexpr static ErrorInfo unorderedErrorInfos[]{
     {rpcSRC_ACT_MALFORMED,      "srcActMalformed",      "Source account is malformed.", 400},
     {rpcSRC_ACT_MISSING,        "srcActMissing",        "Source account not provided.", 400},
     {rpcSRC_ACT_NOT_FOUND,      "srcActNotFound",       "Source account not found.", 404},
-    {rpcDELEGATE_ACT_NOT_FOUND, "delegateActNotFound",  "Delegate account not found.", 404},
     {rpcSRC_CUR_MALFORMED,      "srcCurMalformed",      "Source currency is malformed.", 400},
     {rpcSRC_ISR_MALFORMED,      "srcIsrMalformed",      "Source issuer is malformed.", 400},
     {rpcSTREAM_MALFORMED,       "malformedStream",      "Stream malformed.", 400},

src/libxrpl/protocol/Feature.cpp

@@ -139,27 +139,27 @@ class FeatureCollections
     {
         if (i >= features.size())
             LogicError("Invalid FeatureBitset index");
-        auto const& sequence = features.get<Feature::byIndex>();
+        const auto& sequence = features.get<Feature::byIndex>();
         return sequence[i];
     }
     size_t
     getIndex(Feature const& feature) const
     {
-        auto const& sequence = features.get<Feature::byIndex>();
+        const auto& sequence = features.get<Feature::byIndex>();
         auto const it_to = sequence.iterator_to(feature);
         return it_to - sequence.begin();
     }
     Feature const*
     getByFeature(uint256 const& feature) const
     {
-        auto const& feature_index = features.get<Feature::byFeature>();
+        const auto& feature_index = features.get<Feature::byFeature>();
         auto const feature_it = feature_index.find(feature);
         return feature_it == feature_index.end() ? nullptr : &*feature_it;
     }
     Feature const*
     getByName(std::string const& name) const
     {
-        auto const& name_index = features.get<Feature::byName>();
+        const auto& name_index = features.get<Feature::byName>();
         auto const name_it = name_index.find(name);
         return name_it == name_index.end() ? nullptr : &*name_it;
     }
@@ -240,7 +240,7 @@ FeatureCollections::getRegisteredFeature(std::string const& name) const
 }
 
 void
-check(bool condition, char const* logicErrorMessage)
+check(bool condition, const char* logicErrorMessage)
 {
     if (!condition)
         LogicError(logicErrorMessage);
@@ -437,13 +437,9 @@ featureToName(uint256 const& f)
     uint256 const feature##name = registerFeature(#name, supported, vote);
 #define XRPL_FIX(name, supported, vote) \
     uint256 const fix##name = registerFeature("fix" #name, supported, vote);
-
-// clang-format off
-#define XRPL_RETIRE(name)                                       \
-    [[deprecated("The referenced amendment has been retired")]] \
-    [[maybe_unused]]                                            \
+#define XRPL_RETIRE(name)                                                     \
+    [[deprecated("The referenced amendment has been retired"), maybe_unused]] \
     uint256 const retired##name = retireFeature(#name);
-// clang-format on
 
 #include <xrpl/protocol/detail/features.macro>
 
@@ -459,7 +455,7 @@ featureToName(uint256 const& f)
 //
 // Use initialization of one final static variable to set
 // featureCollections::readOnly.
-[[maybe_unused]] static bool const readOnlySet =
+[[maybe_unused]] static const bool readOnlySet =
     featureCollections.registrationIsDone();
 
 }  // namespace ripple

src/libxrpl/protocol/Indexes.cpp

@@ -94,10 +94,6 @@ enum class LedgerNameSpace : std::uint16_t {
     MPTOKEN = 't',
     CREDENTIAL = 'D',
     PERMISSIONED_DOMAIN = 'm',
-    DELEGATE = 'E',
-    VAULT = 'V',
-    LOAN_BROKER = 'l',  // lower-case L
-    LOAN = 'L',
 
     // No longer used or supported. Left here to reserve the space
     // to avoid accidental reuse.
@@ -456,14 +452,6 @@ amm(uint256 const& id) noexcept
     return {ltAMM, id};
 }
 
-Keylet
-delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept
-{
-    return {
-        ltDELEGATE,
-        indexHash(LedgerNameSpace::DELEGATE, account, authorizedAccount)};
-}
-
 Keylet
 bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType)
 {
@@ -555,24 +543,6 @@ credential(
         indexHash(LedgerNameSpace::CREDENTIAL, subject, issuer, credType)};
 }
 
-Keylet
-vault(AccountID const& owner, std::uint32_t seq) noexcept
-{
-    return vault(indexHash(LedgerNameSpace::VAULT, owner, seq));
-}
-
-Keylet
-loanbroker(AccountID const& owner, std::uint32_t seq) noexcept
-{
-    return loanbroker(indexHash(LedgerNameSpace::LOAN_BROKER, owner, seq));
-}
-
-Keylet
-loan(uint256 const& loanBrokerID, std::uint32_t loanSeq) noexcept
-{
-    return loan(indexHash(LedgerNameSpace::LOAN, loanBrokerID, loanSeq));
-}
-
 Keylet
 permissionedDomain(AccountID const& account, std::uint32_t seq) noexcept
 {

src/libxrpl/protocol/InnerObjectFormats.cpp

@@ -154,18 +154,6 @@ InnerObjectFormats::InnerObjectFormats()
             {sfIssuer, soeREQUIRED},
             {sfCredentialType, soeREQUIRED},
         });
-
-    add(sfPermission.jsonName.c_str(),
-        sfPermission.getCode(),
-        {{sfPermissionValue, soeREQUIRED}});
-
-    add(sfCounterpartySignature.jsonName,
-        sfCounterpartySignature.getCode(),
-        {
-            {sfSigningPubKey, soeOPTIONAL},
-            {sfTxnSignature, soeOPTIONAL},
-            {sfSigners, soeOPTIONAL},
-        });
 }
 
 InnerObjectFormats const&

src/libxrpl/protocol/Keylet.cpp

@@ -37,7 +37,7 @@ Keylet::check(STLedgerEntry const& sle) const
     if (type == ltCHILD)
         return sle.getType() != ltDIR_NODE;
 
-    return sle.getType() == type && sle.key() == key;
+    return sle.getType() == type;
 }
 
 }  // namespace ripple

src/libxrpl/protocol/LedgerFormats.cpp

@@ -29,7 +29,7 @@ namespace ripple {
 LedgerFormats::LedgerFormats()
 {
     // Fields shared by all ledger formats:
-    static std::initializer_list<SOElement> const commonFields{
+    static const std::initializer_list<SOElement> commonFields{
         {sfLedgerIndex, soeOPTIONAL},
         {sfLedgerEntryType, soeREQUIRED},
         {sfFlags, soeREQUIRED},

src/libxrpl/protocol/MPTIssue.cpp

@@ -48,6 +48,12 @@ MPTIssue::getIssuer() const
     return *account;
 }
 
+MPTID const&
+MPTIssue::getMptID() const
+{
+    return mptID_;
+}
+
 std::string
 MPTIssue::getText() const
 {

src/libxrpl/protocol/Permissions.cpp

@@ -1,148 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/protocol/Permissions.h>
-#include <xrpl/protocol/jss.h>
-
-namespace ripple {
-
-Permission::Permission()
-{
-    delegatableTx_ = {
-#pragma push_macro("TRANSACTION")
-#undef TRANSACTION
-
-#define TRANSACTION(tag, value, name, delegatable, ...) {value, delegatable},
-
-#include <xrpl/protocol/detail/transactions.macro>
-
-#undef TRANSACTION
-#pragma pop_macro("TRANSACTION")
-    };
-
-    granularPermissionMap_ = {
-#pragma push_macro("PERMISSION")
-#undef PERMISSION
-
-#define PERMISSION(type, txType, value) {#type, type},
-
-#include <xrpl/protocol/detail/permissions.macro>
-
-#undef PERMISSION
-#pragma pop_macro("PERMISSION")
-    };
-
-    granularNameMap_ = {
-#pragma push_macro("PERMISSION")
-#undef PERMISSION
-
-#define PERMISSION(type, txType, value) {type, #type},
-
-#include <xrpl/protocol/detail/permissions.macro>
-
-#undef PERMISSION
-#pragma pop_macro("PERMISSION")
-    };
-
-    granularTxTypeMap_ = {
-#pragma push_macro("PERMISSION")
-#undef PERMISSION
-
-#define PERMISSION(type, txType, value) {type, txType},
-
-#include <xrpl/protocol/detail/permissions.macro>
-
-#undef PERMISSION
-#pragma pop_macro("PERMISSION")
-    };
-
-    for ([[maybe_unused]] auto const& permission : granularPermissionMap_)
-        XRPL_ASSERT(
-            permission.second > UINT16_MAX,
-            "ripple::Permission::granularPermissionMap_ : granular permission "
-            "value must not exceed the maximum uint16_t value.");
-}
-
-Permission const&
-Permission::getInstance()
-{
-    static Permission const instance;
-    return instance;
-}
-
-std::optional<std::uint32_t>
-Permission::getGranularValue(std::string const& name) const
-{
-    auto const it = granularPermissionMap_.find(name);
-    if (it != granularPermissionMap_.end())
-        return static_cast<uint32_t>(it->second);
-
-    return std::nullopt;
-}
-
-std::optional<std::string>
-Permission::getGranularName(GranularPermissionType const& value) const
-{
-    auto const it = granularNameMap_.find(value);
-    if (it != granularNameMap_.end())
-        return it->second;
-
-    return std::nullopt;
-}
-
-std::optional<TxType>
-Permission::getGranularTxType(GranularPermissionType const& gpType) const
-{
-    auto const it = granularTxTypeMap_.find(gpType);
-    if (it != granularTxTypeMap_.end())
-        return it->second;
-
-    return std::nullopt;
-}
-
-bool
-Permission::isDelegatable(std::uint32_t const& permissionValue) const
-{
-    auto const granularPermission =
-        getGranularName(static_cast<GranularPermissionType>(permissionValue));
-    if (granularPermission)
-        // granular permissions are always allowed to be delegated
-        return true;
-
-    auto const it = delegatableTx_.find(permissionValue - 1);
-    if (it != delegatableTx_.end() && it->second == Delegation::notDelegatable)
-        return false;
-
-    return true;
-}
-
-uint32_t
-Permission::txToPermissionType(TxType const& type) const
-{
-    return static_cast<uint32_t>(type) + 1;
-}
-
-TxType
-Permission::permissionToTxType(uint32_t const& value) const
-{
-    return static_cast<TxType>(value - 1);
-}
-
-}  // namespace ripple

src/libxrpl/protocol/Quality.cpp

@@ -183,7 +183,7 @@ Quality
 Quality::round(int digits) const
 {
     // Modulus for mantissa
-    static std::uint64_t const mod[17] = {
+    static const std::uint64_t mod[17] = {
         /* 0 */ 10000000000000000,
         /* 1 */ 1000000000000000,
         /* 2 */ 100000000000000,

src/libxrpl/protocol/SField.cpp

@@ -17,7 +17,6 @@
 */
 //==============================================================================
 
-#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/SField.h>
 
 #include <map>
@@ -29,7 +28,6 @@ namespace ripple {
 SField::IsSigning const SField::notSigning;
 int SField::num = 0;
 std::map<int, SField const*> SField::knownCodeToField;
-std::map<std::string, SField const*> SField::knownNameToField;
 
 // Give only this translation unit permission to construct SFields
 struct SField::private_access_tag_t
@@ -47,7 +45,7 @@ TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
 }
 
 // Construct all compile-time SFields, and register them in the knownCodeToField
-// and knownNameToField databases:
+// database:
 
 // Use macros for most SField construction to enforce naming conventions.
 #pragma push_macro("UNTYPED_SFIELD")
@@ -89,7 +87,7 @@ SField::SField(
     private_access_tag_t,
     SerializedTypeID tid,
     int fv,
-    char const* fn,
+    const char* fn,
     int meta,
     IsSigning signing)
     : fieldCode(field_code(tid, fv))
@@ -101,14 +99,7 @@ SField::SField(
     , signingField(signing)
     , jsonName(fieldName.c_str())
 {
-    XRPL_ASSERT(
-        !knownCodeToField.contains(fieldCode),
-        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldCode is unique");
-    XRPL_ASSERT(
-        !knownNameToField.contains(fieldName),
-        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldName is unique");
     knownCodeToField[fieldCode] = this;
-    knownNameToField[fieldName] = this;
 }
 
 SField::SField(private_access_tag_t, int fc)
@@ -120,9 +111,6 @@ SField::SField(private_access_tag_t, int fc)
     , signingField(IsSigning::yes)
     , jsonName(fieldName.c_str())
 {
-    XRPL_ASSERT(
-        !knownCodeToField.contains(fieldCode),
-        "ripple::SField::SField(fc) : fieldCode is unique");
     knownCodeToField[fieldCode] = this;
 }
 
@@ -157,11 +145,11 @@ SField::compare(SField const& f1, SField const& f2)
 SField const&
 SField::getField(std::string const& fieldName)
 {
-    auto it = knownNameToField.find(fieldName);
-
-    if (it != knownNameToField.end())
+    for (auto const& [_, f] : knownCodeToField)
     {
-        return *(it->second);
+        (void)_;
+        if (f->fieldName == fieldName)
+            return *f;
     }
     return sfInvalid;
 }

src/libxrpl/protocol/STAccount.cpp

@@ -106,7 +106,7 @@ STAccount::add(Serializer& s) const
 }
 
 bool
-STAccount::isEquivalent(STBase const& t) const
+STAccount::isEquivalent(const STBase& t) const
 {
     auto const* const tPtr = dynamic_cast<STAccount const*>(&t);
     return tPtr && (default_ == tPtr->default_) && (value_ == tPtr->value_);

src/libxrpl/protocol/STAmount.cpp

@@ -38,7 +38,6 @@
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STBase.h>
-#include <xrpl/protocol/STNumber.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/UintTypes.h>
@@ -91,13 +90,13 @@ setSTAmountCanonicalizeSwitchover(bool v)
     *getStaticSTAmountCanonicalizeSwitchover() = v;
 }
 
-static std::uint64_t const tenTo14 = 100000000000000ull;
-static std::uint64_t const tenTo14m1 = tenTo14 - 1;
-static std::uint64_t const tenTo17 = tenTo14 * 1000;
+static const std::uint64_t tenTo14 = 100000000000000ull;
+static const std::uint64_t tenTo14m1 = tenTo14 - 1;
+static const std::uint64_t tenTo17 = tenTo14 * 1000;
 
 //------------------------------------------------------------------------------
 static std::int64_t
-getInt64Value(STAmount const& amount, bool valid, char const* error)
+getInt64Value(STAmount const& amount, bool valid, const char* error)
 {
     if (!valid)
         Throw<std::runtime_error>(error);
@@ -310,7 +309,6 @@ STAmount::xrp() const
             "Cannot return non-native STAmount as XRPAmount");
 
     auto drops = static_cast<XRPAmount::value_type>(mValue);
-    XRPL_ASSERT(mOffset == 0, "ripple::STAmount::xrp : amount is canonical");
 
     if (mIsNegative)
         drops = -drops;
@@ -340,7 +338,6 @@ STAmount::mpt() const
         Throw<std::logic_error>("Cannot return STAmount as MPTAmount");
 
     auto value = static_cast<MPTAmount::value_type>(mValue);
-    XRPL_ASSERT(mOffset == 0, "ripple::STAmount::mpt : amount is canonical");
 
     if (mIsNegative)
         value = -value;
@@ -683,9 +680,9 @@ STAmount::add(Serializer& s) const
 }
 
 bool
-STAmount::isEquivalent(STBase const& t) const
+STAmount::isEquivalent(const STBase& t) const
 {
-    STAmount const* v = dynamic_cast<STAmount const*>(&t);
+    const STAmount* v = dynamic_cast<const STAmount*>(&t);
     return v && (*v == *this);
 }
 
@@ -868,16 +865,75 @@ amountFromQuality(std::uint64_t rate)
 STAmount
 amountFromString(Asset const& asset, std::string const& amount)
 {
-    auto const parts = partsFromString(amount);
-    if ((asset.native() || asset.holds<MPTIssue>()) && parts.exponent < 0)
+    static boost::regex const reNumber(
+        "^"                       // the beginning of the string
+        "([-+]?)"                 // (optional) + or - character
+        "(0|[1-9][0-9]*)"         // a number (no leading zeroes, unless 0)
+        "(\\.([0-9]+))?"          // (optional) period followed by any number
+        "([eE]([+-]?)([0-9]+))?"  // (optional) E, optional + or -, any number
+        "$",
+        boost::regex_constants::optimize);
+
+    boost::smatch match;
+
+    if (!boost::regex_match(amount, match, reNumber))
+        Throw<std::runtime_error>("Number '" + amount + "' is not valid");
+
+    // Match fields:
+    //   0 = whole input
+    //   1 = sign
+    //   2 = integer portion
+    //   3 = whole fraction (with '.')
+    //   4 = fraction (without '.')
+    //   5 = whole exponent (with 'e')
+    //   6 = exponent sign
+    //   7 = exponent number
+
+    // CHECKME: Why 32? Shouldn't this be 16?
+    if ((match[2].length() + match[4].length()) > 32)
+        Throw<std::runtime_error>("Number '" + amount + "' is overlong");
+
+    bool negative = (match[1].matched && (match[1] == "-"));
+
+    // Can't specify XRP or MPT using fractional representation
+    if ((asset.native() || asset.holds<MPTIssue>()) && match[3].matched)
         Throw<std::runtime_error>(
             "XRP and MPT must be specified as integral amount.");
-    return {asset, parts.mantissa, parts.exponent, parts.negative};
+
+    std::uint64_t mantissa;
+    int exponent;
+
+    if (!match[4].matched)  // integer only
+    {
+        mantissa =
+            beast::lexicalCastThrow<std::uint64_t>(std::string(match[2]));
+        exponent = 0;
+    }
+    else
+    {
+        // integer and fraction
+        mantissa = beast::lexicalCastThrow<std::uint64_t>(match[2] + match[4]);
+        exponent = -(match[4].length());
+    }
+
+    if (match[5].matched)
+    {
+        // we have an exponent
+        if (match[6].matched && (match[6] == "-"))
+            exponent -= beast::lexicalCastThrow<int>(std::string(match[7]));
+        else
+            exponent += beast::lexicalCastThrow<int>(std::string(match[7]));
+    }
+
+    return {asset, mantissa, exponent, negative};
 }
 
 STAmount
 amountFromJson(SField const& name, Json::Value const& v)
 {
+    STAmount::mantissa_type mantissa = 0;
+    STAmount::exponent_type exponent = 0;
+    bool negative = false;
     Asset asset;
 
     Json::Value value;
@@ -969,38 +1025,36 @@ amountFromJson(SField const& name, Json::Value const& v)
         }
     }
 
-    NumberParts parts;
-
     if (value.isInt())
     {
         if (value.asInt() >= 0)
         {
-            parts.mantissa = value.asInt();
+            mantissa = value.asInt();
         }
         else
         {
-            parts.mantissa = -value.asInt();
-            parts.negative = true;
+            mantissa = -value.asInt();
+            negative = true;
         }
     }
     else if (value.isUInt())
     {
-        parts.mantissa = v.asUInt();
+        mantissa = v.asUInt();
     }
     else if (value.isString())
     {
-        parts = partsFromString(value.asString());
-        // Can't specify XRP or MPT using fractional representation
-        if ((asset.native() || asset.holds<MPTIssue>()) && parts.exponent < 0)
-            Throw<std::runtime_error>(
-                "XRP and MPT must be specified as integral amount.");
+        auto const ret = amountFromString(asset, value.asString());
+
+        mantissa = ret.mantissa();
+        exponent = ret.exponent();
+        negative = ret.negative();
     }
     else
     {
         Throw<std::runtime_error>("invalid amount type");
     }
 
-    return {name, asset, parts.mantissa, parts.exponent, parts.negative};
+    return {name, asset, mantissa, exponent, negative};
 }
 
 bool
@@ -1011,7 +1065,7 @@ amountFromJsonNoThrow(STAmount& result, Json::Value const& jvSource)
         result = amountFromJson(sfGeneric, jvSource);
         return true;
     }
-    catch (std::exception const& e)
+    catch (const std::exception& e)
     {
         JLOG(debugLog().warn())
             << "amountFromJsonNoThrow: caught: " << e.what();
@@ -1353,30 +1407,6 @@ canonicalizeRoundStrict(
     }
 }
 
-STAmount
-roundToReference(
-    STAmount const value,
-    STAmount referenceValue,
-    Number::rounding_mode rounding)
-{
-    if (value.asset().native() || !value.asset().holds<Issue>())
-        return value;
-
-    NumberRoundModeGuard mg(rounding);
-    if (referenceValue.negative() != value.negative())
-        referenceValue.negate();
-
-    if (value.exponent() > referenceValue.exponent() &&
-        (value.exponent() == referenceValue.exponent() &&
-         value.mantissa() >= referenceValue.mantissa()))
-        return value;
-    // With an IOU, the total will be truncated to the precision of the
-    // larger value: referenceValue
-    STAmount const total = referenceValue + value;
-    STAmount const result = total - referenceValue;
-    return result;
-}
-
 namespace {
 
 // We need a class that has an interface similar to NumberRoundModeGuard

src/libxrpl/protocol/STArray.cpp

@@ -181,9 +181,9 @@ STArray::getSType() const
 }
 
 bool
-STArray::isEquivalent(STBase const& t) const
+STArray::isEquivalent(const STBase& t) const
 {
-    auto v = dynamic_cast<STArray const*>(&t);
+    auto v = dynamic_cast<const STArray*>(&t);
     return v != nullptr && v_ == v->v_;
 }
 
@@ -194,7 +194,7 @@ STArray::isDefault() const
 }
 
 void
-STArray::sort(bool (*compare)(STObject const&, STObject const&))
+STArray::sort(bool (*compare)(const STObject&, const STObject&))
 {
     std::sort(v_.begin(), v_.end(), compare);
 }

src/libxrpl/protocol/STBase.cpp

@@ -40,7 +40,7 @@ STBase::STBase(SField const& n) : fName(&n)
 }
 
 STBase&
-STBase::operator=(STBase const& t)
+STBase::operator=(const STBase& t)
 {
     if (!fName->isUseful())
         fName = t.fName;
@@ -48,13 +48,13 @@ STBase::operator=(STBase const& t)
 }
 
 bool
-STBase::operator==(STBase const& t) const
+STBase::operator==(const STBase& t) const
 {
     return (getSType() == t.getSType()) && isEquivalent(t);
 }
 
 bool
-STBase::operator!=(STBase const& t) const
+STBase::operator!=(const STBase& t) const
 {
     return (getSType() != t.getSType()) || !isEquivalent(t);
 }
@@ -116,7 +116,7 @@ STBase::add(Serializer& s) const
 }
 
 bool
-STBase::isEquivalent(STBase const& t) const
+STBase::isEquivalent(const STBase& t) const
 {
     XRPL_ASSERT(
         getSType() == STI_NOTPRESENT,
@@ -154,7 +154,7 @@ STBase::addFieldID(Serializer& s) const
 //------------------------------------------------------------------------------
 
 std::ostream&
-operator<<(std::ostream& out, STBase const& t)
+operator<<(std::ostream& out, const STBase& t)
 {
     return out << t.getFullText();
 }

src/libxrpl/protocol/STBlob.cpp

@@ -71,9 +71,9 @@ STBlob::add(Serializer& s) const
 }
 
 bool
-STBlob::isEquivalent(STBase const& t) const
+STBlob::isEquivalent(const STBase& t) const
 {
-    STBlob const* v = dynamic_cast<STBlob const*>(&t);
+    const STBlob* v = dynamic_cast<const STBlob*>(&t);
     return v && (value_ == v->value_);
 }
 

src/libxrpl/protocol/STCurrency.cpp

@@ -72,9 +72,9 @@ STCurrency::add(Serializer& s) const
 }
 
 bool
-STCurrency::isEquivalent(STBase const& t) const
+STCurrency::isEquivalent(const STBase& t) const
 {
-    STCurrency const* v = dynamic_cast<STCurrency const*>(&t);
+    const STCurrency* v = dynamic_cast<const STCurrency*>(&t);
     return v && (*v == *this);
 }
 

src/libxrpl/protocol/STInteger.cpp

@@ -22,7 +22,6 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Permissions.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STBase.h>
 #include <xrpl/protocol/STInteger.h>
@@ -178,27 +177,6 @@ template <>
 Json::Value
 STUInt32::getJson(JsonOptions) const
 {
-    if (getFName() == sfPermissionValue)
-    {
-        auto const permissionValue =
-            static_cast<GranularPermissionType>(value_);
-        auto const granular =
-            Permission::getInstance().getGranularName(permissionValue);
-
-        if (granular)
-        {
-            return *granular;
-        }
-        else
-        {
-            auto const txType =
-                Permission::getInstance().permissionToTxType(value_);
-            auto item = TxFormats::getInstance().findByType(txType);
-            if (item != nullptr)
-                return item->getName();
-        }
-    }
-
     return value_;
 }