better early validation logging

This feature improves network efficiency by limiting message propagation from untrusted validators.

Squelching currently reduces the volume of duplicate messages from validators but does not address the volume of unique messages from untrusted validators, who may not contribute meaningfully to network progress.

This change introduces a bounded number of slots for untrusted validators, selected based on message frequency. Once selected, their duplicate messages are subject to standard squelching logic, thereby reducing overall message overhead without impacting trusted validator performance.

.clang-format

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

.codecov.yml

@@ -7,13 +7,13 @@ comment:
   show_carryforward_flags: false
 
 coverage:
-  range: "60..80"
+  range: "70..85"
   precision: 1
   round: nearest
   status:
     project:
       default:
-        target: 60%
+        target: 75%
         threshold: 2%
     patch:
       default:

.github/CODEOWNERS

@@ -0,0 +1,8 @@
+# Allow anyone to review any change by default.
+*
+
+# Require the rpc-reviewers team to review changes to the rpc code.
+include/xrpl/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,9 +1,13 @@
 name: clang-format
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
 
 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

@@ -10,11 +10,11 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  job:
+  documentation:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     steps:
       - name: checkout
         uses: actions/checkout@v4

.github/workflows/levelization.yml

@@ -1,9 +1,13 @@
 name: levelization
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
 
 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,19 +8,21 @@ 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: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/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,6 +1,7 @@
 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)
@@ -18,6 +19,7 @@ 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:
@@ -69,6 +71,9 @@ jobs:
           nproc --version
           echo -n "nproc returns: "
           nproc
+          system_profiler SPHardwareDataType
+          sysctl -n hw.logicalcpu
+          clang --version
       - name: configure Conan
         run : |
           conan profile new default --detect || true

.github/workflows/nix.yml

@@ -1,6 +1,7 @@
 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)
@@ -39,6 +40,7 @@ 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:
@@ -62,7 +64,7 @@ jobs:
               cc: /usr/bin/clang-14
               cxx: /usr/bin/clang++-14
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -124,7 +126,7 @@ jobs:
           - "-Dunity=ON"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -178,7 +180,7 @@ jobs:
           - "-DUNIT_TEST_REFERENCE_FEE=1000"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -229,7 +231,7 @@ jobs:
           - Debug
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
     steps:
@@ -245,7 +247,7 @@ jobs:
           mkdir -p ~/.conan
           tar -xzf conan.tar -C ~/.conan
       - name: install gcovr
-        run: pip install "gcovr>=7,<8"
+        run: pip install "gcovr>=7,<9"
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
@@ -303,7 +305,7 @@ jobs:
   conan:
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     env:
       build_dir: .build
       configuration: Release
@@ -358,6 +360,7 @@ 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,6 +2,7 @@ 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)
@@ -21,6 +22,7 @@ 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,9 +83,17 @@ 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
 
-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).
+[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
 
 ### Additions and bugfixes in 2.4.0
 

BUILD.md

@@ -288,7 +288,7 @@ It fixes some source files to add missing `#include`s.
    Single-config generators:
 
    ```
-   cmake --build .
+   cmake --build . -j $(nproc)
    ```
 
    Multi-config generators:

README.md

@@ -1,3 +1,5 @@
+[![codecov](https://codecov.io/gh/XRPLF/rippled/graph/badge.svg?token=WyFr5ajq3O)](https://codecov.io/gh/XRPLF/rippled)
+
 # The XRP Ledger
 
 The [XRP Ledger](https://xrpl.org/) is a decentralized cryptographic ledger powered by a network of peer-to-peer nodes. The XRP Ledger uses a novel Byzantine Fault Tolerant consensus algorithm to settle and record transactions in a secure distributed database without a central operator.

cfg/validators-example.txt

@@ -26,7 +26,7 @@
 #
 #   Examples:
 #    https://vl.ripple.com
-#    https://vl.xrplf.org
+#    https://unl.xrplf.org
 #    http://127.0.0.1:8000
 #    file:///etc/opt/ripple/vl.txt
 #

cmake/CodeCoverage.cmake

@@ -98,6 +98,9 @@
 # 2024-04-03, Bronek Kozicki
 #     - add support for output formats: jacoco, clover, lcov
 #
+# 2025-05-12, Jingchen Wu
+#     - add -fprofile-update=atomic to ensure atomic profile generation
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -200,15 +203,27 @@ set(COVERAGE_COMPILER_FLAGS "-g --coverage"
     CACHE INTERNAL "")
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
+    include(CheckCCompilerFlag)
+
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
     if(HAVE_cxx_fprofile_abs_path)
         set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
-    include(CheckCCompilerFlag)
+
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
     if(HAVE_c_fprofile_abs_path)
         set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
+
+    check_cxx_compiler_flag(-fprofile-update HAVE_cxx_fprofile_update)
+    if(HAVE_cxx_fprofile_update)
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS}  -fprofile-update=atomic")
+    endif()
+
+    check_c_compiler_flag(-fprofile-update HAVE_c_fprofile_update)
+    if(HAVE_c_fprofile_update)
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-update=atomic")
+    endif()
 endif()
 
 set(CMAKE_Fortran_FLAGS_COVERAGE

cmake/RippledDocs.cmake

@@ -53,9 +53,9 @@ set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
 file(WRITE
   "${download_script}"
   "file(DOWNLOAD \
-    http://upload.cppreference.com/mwiki/images/b/b2/html_book_20190607.zip \
+    https://github.com/PeterFeicht/cppreference-doc/releases/download/v20250209/html-book-20250209.zip \
     ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
-    EXPECTED_HASH MD5=82b3a612d7d35a83e3cb1195a63689ab \
+    EXPECTED_HASH MD5=bda585f72fbca4b817b29a3d5746567b \
   )\n \
   execute_process( \
     COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \

docs/build/environment.md

@@ -23,7 +23,7 @@ direction.
 
 ```
 apt update
-apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+apt install --yes curl git libssl-dev pipx python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
 
 curl --location --remote-name \
   "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
@@ -35,7 +35,8 @@ make --jobs $(nproc)
 make install
 cd ..
 
-pip3 install 'conan<2'
+pipx install 'conan<2'
+pipx ensurepath
 ```
 
 [1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh

include/xrpl/basics/BasicConfig.h

@@ -367,7 +367,7 @@ get(Section const& section,
 }
 
 inline std::string
-get(Section const& section, std::string const& name, const char* defaultValue)
+get(Section const& section, std::string const& name, char const* 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<const char*>(in),
+        reinterpret_cast<char const*>(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<const char*>(in),
+            reinterpret_cast<char const*>(in),
             reinterpret_cast<char*>(decompressed),
             inSize,
             decompressedSize) != decompressedSize)

include/xrpl/basics/Expected.h

@@ -93,7 +93,7 @@ public:
     {
     }
 
-    constexpr const E&
+    constexpr E const&
     value() const&
     {
         return val_;
@@ -111,7 +111,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr const E&&
+    constexpr E const&&
     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_release))
+                prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
             // 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_release))
+                prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
             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_acq_rel);
+            refCounts.wait(prevIntVal, std::memory_order_acquire);
             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_acq_rel);
+            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
         }
         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_release))
+        curValue, desiredValue, std::memory_order_acq_rel))
     {
         RefCountPair const prev{curValue};
         if (!prev.strong)

include/xrpl/basics/TaggedCache.h

@@ -115,7 +115,7 @@ public:
     sweep();
 
     bool
-    del(const key_type& key, bool valid);
+    del(key_type const& key, bool valid);
 
 public:
     /** Replace aliased objects with originals.
@@ -134,20 +134,20 @@ public:
     template <class R>
     bool
     canonicalize(
-        const key_type& key,
+        key_type const& key,
         SharedPointerType& data,
         R&& replaceCallback);
 
     bool
     canonicalize_replace_cache(
-        const key_type& key,
+        key_type const& key,
         SharedPointerType const& data);
 
     bool
-    canonicalize_replace_client(const key_type& key, SharedPointerType& data);
+    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
 
     SharedPointerType
-    fetch(const key_type& key);
+    fetch(key_type const& 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(const key_type& key, T& data);
+    retrieve(key_type const& key, T& data);
 
     mutex_type&
     peekMutex();
@@ -322,10 +322,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    const int m_target_size;
+    int const m_target_size;
 
     // Desired maximum cache age
-    const clock_type::duration m_target_age;
+    clock_type::duration const 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(const key_type& key, bool valid)
+    Mutex>::del(key_type const& 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(
-        const key_type& key,
+        key_type const& key,
         SharedPointerType& data,
         R&& replaceCallback)
 {
@@ -509,7 +509,7 @@ TaggedCache<
     KeyEqual,
     Mutex>::
     canonicalize_replace_cache(
-        const key_type& key,
+        key_type const& key,
         SharedPointerType const& data)
 {
     return canonicalize(
@@ -535,7 +535,7 @@ TaggedCache<
     Hash,
     KeyEqual,
     Mutex>::
-    canonicalize_replace_client(const key_type& key, SharedPointerType& data)
+    canonicalize_replace_client(key_type const& key, SharedPointerType& data)
 {
     return canonicalize(key, data, []() { return false; });
 }
@@ -558,7 +558,7 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::fetch(const key_type& key)
+    Mutex>::fetch(key_type const& key)
 {
     std::lock_guard<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
@@ -656,7 +656,7 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::retrieve(const key_type& key, T& data)
+    Mutex>::retrieve(key_type const& 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^=(const base_uint& b)
+    operator^=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -383,7 +383,7 @@ public:
     }
 
     base_uint&
-    operator&=(const base_uint& b)
+    operator&=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
@@ -392,7 +392,7 @@ public:
     }
 
     base_uint&
-    operator|=(const base_uint& b)
+    operator|=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] |= b.data_[i];
@@ -415,11 +415,11 @@ public:
         return *this;
     }
 
-    const base_uint
+    base_uint const
     operator++(int)
     {
         // postfix operator
-        const base_uint ret = *this;
+        base_uint const ret = *this;
         ++(*this);
 
         return ret;
@@ -441,11 +441,11 @@ public:
         return *this;
     }
 
-    const base_uint
+    base_uint const
     operator--(int)
     {
         // postfix operator
-        const base_uint ret = *this;
+        base_uint const ret = *this;
         --(*this);
 
         return ret;
@@ -466,7 +466,7 @@ public:
     }
 
     base_uint&
-    operator+=(const base_uint& b)
+    operator+=(base_uint const& b)
     {
         std::uint64_t carry = 0;
 
@@ -511,7 +511,7 @@ public:
     }
 
     [[nodiscard]] constexpr bool
-    parseHex(const char* str)
+    parseHex(char const* str)
     {
         return parseHex(std::string_view{str});
     }

include/xrpl/basics/comparators.h

@@ -43,7 +43,7 @@ struct less
     using result_type = bool;
 
     constexpr bool
-    operator()(const T& left, const T& right) const
+    operator()(T const& left, T const& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(const T& left, const T& right) const
+    operator()(T const& left, T const& 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<const Key, Value>>>
+    typename Alloc = std::allocator<std::pair<Key const, Value>>>
 class partitioned_unordered_map
 {
     std::size_t partitions_;

include/xrpl/basics/tagged_integer.h

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

include/xrpl/beast/hash/uhash.h

@@ -30,7 +30,7 @@ namespace beast {
 template <class Hasher = xxhasher>
 struct uhash
 {
-    explicit uhash() = default;
+    uhash() = default;
 
     using result_type = typename Hasher::result_type;
 

include/xrpl/beast/net/IPEndpoint.h

@@ -215,7 +215,7 @@ namespace std {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    explicit hash() = default;
+    hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const
@@ -230,7 +230,7 @@ namespace boost {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    explicit hash() = default;
+    hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const

include/xrpl/beast/utility/temp_dir.h

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

include/xrpl/json/json_reader.h

@@ -39,7 +39,7 @@ class Reader
 {
 public:
     using Char = char;
-    using Location = const Char*;
+    using Location = Char const*;
 
     /** \brief Constructs a Reader allowing all features
      * for parsing.
@@ -64,7 +64,7 @@ public:
      * error occurred.
      */
     bool
-    parse(const char* beginDoc, const char* endDoc, Value& root);
+    parse(char const* beginDoc, char const* 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, const char* message);
+    expectToken(TokenType type, Token& token, char const* message);
     bool
     readToken(Token& token);
     void

include/xrpl/json/json_value.h

@@ -63,24 +63,24 @@ enum ValueType {
 class StaticString
 {
 public:
-    constexpr explicit StaticString(const char* czstring) : str_(czstring)
+    constexpr explicit StaticString(char const* czstring) : str_(czstring)
     {
     }
 
     constexpr
-    operator const char*() const
+    operator char const*() const
     {
         return str_;
     }
 
-    constexpr const char*
+    constexpr char const*
     c_str() const
     {
         return str_;
     }
 
 private:
-    const char* str_;
+    char const* str_;
 };
 
 inline bool
@@ -158,10 +158,10 @@ public:
     using Int = Json::Int;
     using ArrayIndex = UInt;
 
-    static const Value null;
-    static const Int minInt;
-    static const Int maxInt;
-    static const UInt maxUInt;
+    static Value const null;
+    static Int const minInt;
+    static Int const maxInt;
+    static UInt const maxUInt;
 
 private:
     class CZString
@@ -173,24 +173,24 @@ private:
             duplicateOnCopy
         };
         CZString(int index);
-        CZString(const char* cstr, DuplicationPolicy allocate);
-        CZString(const CZString& other);
+        CZString(char const* cstr, DuplicationPolicy allocate);
+        CZString(CZString const& other);
         ~CZString();
         CZString&
-        operator=(const CZString& other) = delete;
+        operator=(CZString const& other) = delete;
         bool
-        operator<(const CZString& other) const;
+        operator<(CZString const& other) const;
         bool
-        operator==(const CZString& other) const;
+        operator==(CZString const& other) const;
         int
         index() const;
-        const char*
+        char const*
         c_str() const;
         bool
         isStaticString() const;
 
     private:
-        const char* cstr_;
+        char const* cstr_;
         int index_;
     };
 
@@ -217,7 +217,7 @@ public:
     Value(Int value);
     Value(UInt value);
     Value(double value);
-    Value(const char* value);
+    Value(char const* value);
     Value(ripple::Number const& value);
     /** \brief Constructs a value from a static string.
 
@@ -230,10 +230,10 @@ public:
      * Json::Value aValue( StaticString("some text") );
      * \endcode
      */
-    Value(const StaticString& value);
+    Value(StaticString const& value);
     Value(std::string const& value);
     Value(bool value);
-    Value(const Value& other);
+    Value(Value const& other);
     ~Value();
 
     Value&
@@ -250,7 +250,7 @@ public:
     ValueType
     type() const;
 
-    const char*
+    char const*
     asCString() const;
     /** Returns the unquoted string value. */
     std::string
@@ -320,12 +320,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.)
-    const Value&
+    Value const&
     operator[](UInt index) const;
     /// If the array contains at least index+1 elements, returns the element
     /// value, otherwise returns defaultValue.
     Value
-    get(UInt index, const Value& defaultValue) const;
+    get(UInt index, Value const& defaultValue) const;
     /// Return true if index < size().
     bool
     isValidIndex(UInt index) const;
@@ -333,25 +333,25 @@ public:
     ///
     /// Equivalent to jsonvalue[jsonvalue.size()] = value;
     Value&
-    append(const Value& value);
+    append(Value const& value);
     Value&
     append(Value&& value);
 
     /// Access an object value by name, create a null member if it does not
     /// exist.
     Value&
-    operator[](const char* key);
+    operator[](char const* key);
     /// Access an object value by name, returns null if there is no member with
     /// that name.
-    const Value&
-    operator[](const char* key) const;
+    Value const&
+    operator[](char const* 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.
-    const Value&
+    Value const&
     operator[](std::string const& key) const;
     /** \brief Access an object value by name, create a null member if it does
      not exist.
@@ -367,16 +367,16 @@ public:
      * \endcode
      */
     Value&
-    operator[](const StaticString& key);
+    operator[](StaticString const& key);
     Value const&
-    operator[](const StaticString& key) const;
+    operator[](StaticString const& key) const;
 
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(const char* key, const Value& defaultValue) const;
+    get(char const* key, Value const& defaultValue) const;
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(std::string const& key, const Value& defaultValue) const;
+    get(std::string const& key, Value const& defaultValue) const;
 
     /// \brief Remove and return the named member.
     ///
@@ -385,14 +385,14 @@ public:
     /// \pre type() is objectValue or nullValue
     /// \post type() is unchanged
     Value
-    removeMember(const char* key);
+    removeMember(char const* key);
     /// Same as removeMember(const char*)
     Value
     removeMember(std::string const& key);
 
     /// Return true if the object has a member named key.
     bool
-    isMember(const char* key) const;
+    isMember(char const* key) const;
     /// Return true if the object has a member named key.
     bool
     isMember(std::string const& key) const;
@@ -419,13 +419,13 @@ public:
     end();
 
     friend bool
-    operator==(const Value&, const Value&);
+    operator==(Value const&, Value const&);
     friend bool
-    operator<(const Value&, const Value&);
+    operator<(Value const&, Value const&);
 
 private:
     Value&
-    resolveReference(const char* key, bool isStatic);
+    resolveReference(char const* key, bool isStatic);
 
 private:
     union ValueHolder
@@ -448,31 +448,31 @@ to_json(ripple::Number const& number)
 }
 
 bool
-operator==(const Value&, const Value&);
+operator==(Value const&, Value const&);
 
 inline bool
-operator!=(const Value& x, const Value& y)
+operator!=(Value const& x, Value const& y)
 {
     return !(x == y);
 }
 
 bool
-operator<(const Value&, const Value&);
+operator<(Value const&, Value const&);
 
 inline bool
-operator<=(const Value& x, const Value& y)
+operator<=(Value const& x, Value const& y)
 {
     return !(y < x);
 }
 
 inline bool
-operator>(const Value& x, const Value& y)
+operator>(Value const& x, Value const& y)
 {
     return y < x;
 }
 
 inline bool
-operator>=(const Value& x, const Value& y)
+operator>=(Value const& x, Value const& y)
 {
     return !(x < y);
 }
@@ -493,11 +493,11 @@ public:
     virtual ~ValueAllocator() = default;
 
     virtual char*
-    makeMemberName(const char* memberName) = 0;
+    makeMemberName(char const* memberName) = 0;
     virtual void
     releaseMemberName(char* memberName) = 0;
     virtual char*
-    duplicateStringValue(const char* value, unsigned int length = unknown) = 0;
+    duplicateStringValue(char const* value, unsigned int length = unknown) = 0;
     virtual void
     releaseStringValue(char* value) = 0;
 };
@@ -514,16 +514,16 @@ public:
 
     ValueIteratorBase();
 
-    explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
+    explicit ValueIteratorBase(Value::ObjectValues::iterator const& current);
 
     bool
-    operator==(const SelfType& other) const
+    operator==(SelfType const& other) const
     {
         return isEqual(other);
     }
 
     bool
-    operator!=(const SelfType& other) const
+    operator!=(SelfType const& other) const
     {
         return !isEqual(other);
     }
@@ -539,7 +539,7 @@ public:
 
     /// Return the member name of the referenced Value. "" if it is not an
     /// objectValue.
-    const char*
+    char const*
     memberName() const;
 
 protected:
@@ -553,13 +553,13 @@ protected:
     decrement();
 
     difference_type
-    computeDistance(const SelfType& other) const;
+    computeDistance(SelfType const& other) const;
 
     bool
-    isEqual(const SelfType& other) const;
+    isEqual(SelfType const& other) const;
 
     void
-    copy(const SelfType& other);
+    copy(SelfType const& other);
 
 private:
     Value::ObjectValues::iterator current_;
@@ -577,8 +577,8 @@ class ValueConstIterator : public ValueIteratorBase
 public:
     using size_t = unsigned int;
     using difference_type = int;
-    using reference = const Value&;
-    using pointer = const Value*;
+    using reference = Value const&;
+    using pointer = Value const*;
     using SelfType = ValueConstIterator;
 
     ValueConstIterator() = default;
@@ -586,11 +586,11 @@ public:
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
+    explicit ValueConstIterator(Value::ObjectValues::iterator const& current);
 
 public:
     SelfType&
-    operator=(const ValueIteratorBase& other);
+    operator=(ValueIteratorBase const& other);
 
     SelfType
     operator++(int)
@@ -643,17 +643,17 @@ public:
     using SelfType = ValueIterator;
 
     ValueIterator() = default;
-    ValueIterator(const ValueConstIterator& other);
-    ValueIterator(const ValueIterator& other);
+    ValueIterator(ValueConstIterator const& other);
+    ValueIterator(ValueIterator const& other);
 
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueIterator(const Value::ObjectValues::iterator& current);
+    explicit ValueIterator(Value::ObjectValues::iterator const& current);
 
 public:
     SelfType&
-    operator=(const SelfType& other);
+    operator=(SelfType const& other);
 
     SelfType
     operator++(int)

include/xrpl/json/json_writer.h

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

include/xrpl/protocol/AccountID.h

@@ -149,7 +149,7 @@ namespace std {
 template <>
 struct hash<ripple::AccountID> : ripple::AccountID::hasher
 {
-    explicit hash() = default;
+    hash() = default;
 };
 
 }  // namespace std

include/xrpl/protocol/Batch.h

@@ -0,0 +1,37 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2024 Ripple Labs Inc.
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <xrpl/protocol/HashPrefix.h>
+#include <xrpl/protocol/STVector256.h>
+#include <xrpl/protocol/Serializer.h>
+
+namespace ripple {
+
+inline void
+serializeBatch(
+    Serializer& msg,
+    std::uint32_t const& flags,
+    std::vector<uint256> const& txids)
+{
+    msg.add32(HashPrefix::batch);
+    msg.add32(flags);
+    msg.add32(std::uint32_t(txids.size()));
+    for (auto const& txid : txids)
+        msg.addBitString(txid);
+}
+
+}  // namespace ripple

include/xrpl/protocol/Book.h

@@ -104,7 +104,7 @@ private:
         boost::base_from_member<std::hash<ripple::AccountID>, 1>;
 
 public:
-    explicit hash() = default;
+    hash() = default;
 
     using value_type = std::size_t;
     using argument_type = ripple::Issue;
@@ -131,7 +131,7 @@ private:
     hasher m_hasher;
 
 public:
-    explicit hash() = default;
+    hash() = default;
 
     using value_type = std::size_t;
     using argument_type = ripple::Book;
@@ -154,7 +154,7 @@ namespace boost {
 template <>
 struct hash<ripple::Issue> : std::hash<ripple::Issue>
 {
-    explicit hash() = default;
+    hash() = default;
 
     using Base = std::hash<ripple::Issue>;
     // VFALCO NOTE broken in vs2012
@@ -164,7 +164,7 @@ struct hash<ripple::Issue> : std::hash<ripple::Issue>
 template <>
 struct hash<ripple::Book> : std::hash<ripple::Book>
 {
-    explicit hash() = default;
+    hash() = default;
 
     using Base = std::hash<ripple::Book>;
     // VFALCO NOTE broken in vs2012

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,
-    // unused                  68,
+    rpcDELEGATE_ACT_NOT_FOUND = 68,
     rpcSRC_CUR_MALFORMED = 69,
     rpcSRC_ISR_MALFORMED = 70,
     rpcSTREAM_MALFORMED = 71,

include/xrpl/protocol/FeeUnits.h

@@ -336,7 +336,7 @@ public:
 // 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, const TaggedFee<UnitTag, T>& q)
+operator<<(std::basic_ostream<Char, Traits>& os, TaggedFee<UnitTag, T> const& q)
 {
     return os << q.value();
 }

include/xrpl/protocol/HashPrefix.h

@@ -88,6 +88,9 @@ enum class HashPrefix : std::uint32_t {
 
     /** Credentials signature */
     credential = detail::make_hash_prefix('C', 'R', 'D'),
+
+    /** Batch */
+    batch = detail::make_hash_prefix('B', 'C', 'H'),
 };
 
 template <class Hasher>

include/xrpl/protocol/Indexes.h

@@ -279,6 +279,10 @@ 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);
 

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, trust lines allow rippling by default
+        0x00800000,               // True, incoming 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

include/xrpl/protocol/MultiApiJson.h

@@ -80,7 +80,7 @@ struct MultiApiJson
     }
 
     void
-    set(const char* key, auto const& v)
+    set(char const* 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(const char* key) const
+    isMember(char const* key) const
     {
         int count = 0;
         for (auto& a : this->val)

include/xrpl/protocol/Permissions.h

@@ -0,0 +1,97 @@
+//------------------------------------------------------------------------------
+/*
+    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

@@ -122,6 +122,10 @@ 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;
 
@@ -161,6 +165,13 @@ 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;
+
+/** The maximum number of transactions that can be in a batch. */
+std::size_t constexpr maxBatchTxCount = 8;
+
 }  // 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 const int minTickSize = 3;
-    static const int maxTickSize = 16;
+    static int const minTickSize = 3;
+    static int const maxTickSize = 16;
 
 private:
     // This has the same representation as STAmount, see the comment on the

include/xrpl/protocol/SField.h

@@ -181,22 +181,22 @@ public:
         private_access_tag_t,
         SerializedTypeID tid,
         int fv,
-        const char* fn,
+        char const* fn,
         int meta = sMD_Default,
         IsSigning signing = IsSigning::yes);
     explicit SField(private_access_tag_t, int fc);
 
-    static const SField&
+    static SField const&
     getField(int fieldCode);
-    static const SField&
+    static SField const&
     getField(std::string const& fieldName);
-    static const SField&
+    static SField const&
     getField(int type, int value)
     {
         return getField(field_code(type, value));
     }
 
-    static const SField&
+    static SField const&
     getField(SerializedTypeID type, int value)
     {
         return getField(field_code(type, value));
@@ -283,19 +283,19 @@ public:
     }
 
     bool
-    operator==(const SField& f) const
+    operator==(SField const& f) const
     {
         return fieldCode == f.fieldCode;
     }
 
     bool
-    operator!=(const SField& f) const
+    operator!=(SField const& f) const
     {
         return fieldCode != f.fieldCode;
     }
 
     static int
-    compare(const SField& f1, const SField& f2);
+    compare(SField const& f1, SField const& f2);
 
     static std::map<int, SField const*> const&
     getKnownCodeToField()

include/xrpl/protocol/STAccount.h

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

include/xrpl/protocol/STAmount.h

@@ -62,20 +62,20 @@ private:
 public:
     using value_type = STAmount;
 
-    static const int cMinOffset = -96;
-    static const int cMaxOffset = 80;
+    static int const cMinOffset = -96;
+    static int const cMaxOffset = 80;
 
     // Maximum native value supported by the code
-    static const std::uint64_t cMinValue = 1000000000000000ull;
-    static const std::uint64_t cMaxValue = 9999999999999999ull;
-    static const std::uint64_t cMaxNative = 9000000000000000000ull;
+    static std::uint64_t const cMinValue = 1000000000000000ull;
+    static std::uint64_t const cMaxValue = 9999999999999999ull;
+    static std::uint64_t const cMaxNative = 9000000000000000000ull;
 
     // Max native value on network.
-    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 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 std::uint64_t const uRateOne;
 
@@ -283,7 +283,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(const STBase& t) const override;
+    isEquivalent(STBase const& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STArray.h

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

include/xrpl/protocol/STBase.h

@@ -93,7 +93,9 @@ struct JsonOptions
 };
 
 template <typename T>
-    requires requires(T const& t) { t.getJson(JsonOptions::none); }
+    requires requires(T const& t) {
+        { t.getJson(JsonOptions::none) } -> std::convertible_to<Json::Value>;
+    }
 Json::Value
 to_json(T const& t)
 {
@@ -137,16 +139,16 @@ class STBase
 public:
     virtual ~STBase() = default;
     STBase();
-    STBase(const STBase&) = default;
+    STBase(STBase const&) = default;
     STBase&
-    operator=(const STBase& t);
+    operator=(STBase const& t);
 
     explicit STBase(SField const& n);
 
     bool
-    operator==(const STBase& t) const;
+    operator==(STBase const& t) const;
     bool
-    operator!=(const STBase& t) const;
+    operator!=(STBase const& t) const;
 
     template <class D>
     D&
@@ -205,7 +207,7 @@ private:
 //------------------------------------------------------------------------------
 
 std::ostream&
-operator<<(std::ostream& out, const STBase& t);
+operator<<(std::ostream& out, STBase const& t);
 
 template <class D>
 D&

include/xrpl/protocol/STBitString.h

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

include/xrpl/protocol/STBlob.h

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

include/xrpl/protocol/STCurrency.h

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

include/xrpl/protocol/STInteger.h

@@ -54,7 +54,7 @@ public:
     isDefault() const override;
 
     bool
-    isEquivalent(const STBase& t) const override;
+    isEquivalent(STBase const& t) const override;
 
     STInteger&
     operator=(value_type const& v);
@@ -127,9 +127,9 @@ STInteger<Integer>::isDefault() const
 
 template <typename Integer>
 inline bool
-STInteger<Integer>::isEquivalent(const STBase& t) const
+STInteger<Integer>::isEquivalent(STBase const& t) const
 {
-    const STInteger* v = dynamic_cast<const STInteger*>(&t);
+    STInteger const* v = dynamic_cast<STInteger const*>(&t);
     return v && (value_ == v->value_);
 }
 

include/xrpl/protocol/STIssue.h

@@ -48,12 +48,6 @@ public:
 
     STIssue&
     operator=(STIssue const& rhs) = default;
-    STIssue&
-    operator=(Asset const& rhs)
-    {
-        asset_ = rhs;
-        return *this;
-    }
 
     template <ValidIssueType TIss>
     TIss const&
@@ -81,7 +75,7 @@ public:
     add(Serializer& s) const override;
 
     bool
-    isEquivalent(const STBase& t) const override;
+    isEquivalent(STBase const& t) const override;
 
     bool
     isDefault() const override;

include/xrpl/protocol/STLedgerEntry.h

@@ -35,7 +35,7 @@ class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 
 public:
     using pointer = std::shared_ptr<STLedgerEntry>;
-    using ref = const std::shared_ptr<STLedgerEntry>&;
+    using ref = std::shared_ptr<STLedgerEntry> const&;
 
     /** Create an empty object with the given key and type. */
     explicit STLedgerEntry(Keylet const& k);

include/xrpl/protocol/STObject.h

@@ -99,8 +99,8 @@ public:
     STObject&
     operator=(STObject&& other);
 
-    STObject(const SOTemplate& type, SField const& name);
-    STObject(const SOTemplate& type, SerialIter& sit, SField const& name);
+    STObject(SOTemplate const& type, SField const& name);
+    STObject(SOTemplate const& 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(const SOTemplate& type);
+    applyTemplate(SOTemplate const& type);
 
     void
     applyTemplateFromSField(SField const&);
@@ -130,7 +130,7 @@ public:
     isFree() const;
 
     void
-    set(const SOTemplate&);
+    set(SOTemplate const&);
 
     bool
     set(SerialIter& u, int depth = 0);
@@ -139,7 +139,7 @@ public:
     getSType() const override;
 
     bool
-    isEquivalent(const STBase& t) const override;
+    isEquivalent(STBase const& t) const override;
 
     bool
     isDefault() const override;
@@ -182,13 +182,13 @@ public:
     uint256
     getSigningHash(HashPrefix prefix) const;
 
-    const STBase&
+    STBase const&
     peekAtIndex(int offset) const;
 
     STBase&
     getIndex(int offset);
 
-    const STBase*
+    STBase const*
     peekAtPIndex(int offset) const;
 
     STBase*
@@ -200,13 +200,13 @@ public:
     SField const&
     getFieldSType(int index) const;
 
-    const STBase&
+    STBase const&
     peekAtField(SField const& field) const;
 
     STBase&
     getField(SField const& field);
 
-    const STBase*
+    STBase const*
     peekAtPField(SField const& field) const;
 
     STBase*
@@ -240,11 +240,11 @@ public:
     getFieldAmount(SField const& field) const;
     STPathSet const&
     getFieldPathSet(SField const& field) const;
-    const STVector256&
+    STVector256 const&
     getFieldV256(SField const& field) const;
-    const STArray&
+    STArray const&
     getFieldArray(SField const& field) const;
-    const STCurrency&
+    STCurrency const&
     getFieldCurrency(SField const& field) const;
     STNumber const&
     getFieldNumber(SField const& field) const;
@@ -408,12 +408,12 @@ public:
     delField(int index);
 
     bool
-    hasMatchingEntry(const STBase&);
+    hasMatchingEntry(STBase const&);
 
     bool
-    operator==(const STObject& o) const;
+    operator==(STObject const& o) const;
     bool
-    operator!=(const STObject& o) const;
+    operator!=(STObject const& o) const;
 
     class FieldErr;
 
@@ -981,7 +981,7 @@ STObject::getCount() const
     return v_.size();
 }
 
-inline const STBase&
+inline STBase const&
 STObject::peekAtIndex(int offset) const
 {
     return v_[offset].get();
@@ -993,7 +993,7 @@ STObject::getIndex(int offset)
     return v_[offset].get();
 }
 
-inline const STBase*
+inline STBase const*
 STObject::peekAtPIndex(int offset) const
 {
     return &v_[offset].get();
@@ -1128,7 +1128,7 @@ STObject::setFieldH160(SField const& field, base_uint<160, Tag> const& v)
 }
 
 inline bool
-STObject::operator!=(const STObject& o) const
+STObject::operator!=(STObject const& o) const
 {
     return !(*this == o);
 }
@@ -1137,7 +1137,7 @@ template <typename T, typename V>
 V
 STObject::getFieldByValue(SField const& field) const
 {
-    const STBase* rf = peekAtPField(field);
+    STBase const* rf = peekAtPField(field);
 
     if (!rf)
         throwFieldNotFound(field);
@@ -1147,7 +1147,7 @@ STObject::getFieldByValue(SField const& field) const
     if (id == STI_NOTPRESENT)
         return V();  // optional field not present
 
-    const T* cf = dynamic_cast<const T*>(rf);
+    T const* cf = dynamic_cast<T const*>(rf);
 
     if (!cf)
         Throw<std::runtime_error>("Wrong field type");
@@ -1164,7 +1164,7 @@ template <typename T, typename V>
 V const&
 STObject::getFieldByConstRef(SField const& field, V const& empty) const
 {
-    const STBase* rf = peekAtPField(field);
+    STBase const* rf = peekAtPField(field);
 
     if (!rf)
         throwFieldNotFound(field);
@@ -1174,7 +1174,7 @@ STObject::getFieldByConstRef(SField const& field, V const& empty) const
     if (id == STI_NOTPRESENT)
         return empty;  // optional field not present
 
-    const T* cf = dynamic_cast<const T*>(rf);
+    T const* cf = dynamic_cast<T const*>(rf);
 
     if (!cf)
         Throw<std::runtime_error>("Wrong field type");

include/xrpl/protocol/STPathSet.h

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

include/xrpl/protocol/STTx.h

@@ -125,10 +125,16 @@ public:
         @return `true` if valid signature. If invalid, the error message string.
     */
     enum class RequireFullyCanonicalSig : bool { no, yes };
+
     Expected<void, std::string>
     checkSign(RequireFullyCanonicalSig requireCanonicalSig, Rules const& rules)
         const;
 
+    Expected<void, std::string>
+    checkBatchSign(
+        RequireFullyCanonicalSig requireCanonicalSig,
+        Rules const& rules) const;
+
     // SQL Functions with metadata.
     static std::string const&
     getMetaSQLInsertReplaceHeader();
@@ -144,6 +150,9 @@ public:
         char status,
         std::string const& escapedMetaData) const;
 
+    std::vector<uint256>
+    getBatchTransactionIDs() const;
+
 private:
     Expected<void, std::string>
     checkSingleSign(RequireFullyCanonicalSig requireCanonicalSig) const;
@@ -153,12 +162,24 @@ private:
         RequireFullyCanonicalSig requireCanonicalSig,
         Rules const& rules) const;
 
+    Expected<void, std::string>
+    checkBatchSingleSign(
+        STObject const& batchSigner,
+        RequireFullyCanonicalSig requireCanonicalSig) const;
+
+    Expected<void, std::string>
+    checkBatchMultiSign(
+        STObject const& batchSigner,
+        RequireFullyCanonicalSig requireCanonicalSig,
+        Rules const& rules) const;
+
     STBase*
     copy(std::size_t n, void* buf) const override;
     STBase*
     move(std::size_t n, void* buf) override;
 
     friend class detail::STVar;
+    mutable std::vector<uint256> batch_txn_ids_;
 };
 
 bool

include/xrpl/protocol/STVector256.h

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

include/xrpl/protocol/STXChainBridge.h

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

include/xrpl/protocol/Serializer.h

@@ -139,9 +139,9 @@ public:
     int
     addRaw(Slice slice);
     int
-    addRaw(const void* ptr, int len);
+    addRaw(void const* ptr, int len);
     int
-    addRaw(const Serializer& s);
+    addRaw(Serializer const& s);
 
     int
     addVL(Blob const& vector);
@@ -151,7 +151,7 @@ public:
     int
     addVL(Iter begin, Iter end, int len);
     int
-    addVL(const void* ptr, int len);
+    addVL(void const* ptr, int len);
 
     // disassemble functions
     bool
@@ -161,7 +161,7 @@ public:
     bool
     getInteger(Integer& number, int offset)
     {
-        static const auto bytes = sizeof(Integer);
+        static auto const bytes = sizeof(Integer);
         if ((offset + bytes) > mData.size())
             return false;
         number = 0;
@@ -220,7 +220,7 @@ public:
     {
         return mData.size();
     }
-    const void*
+    void const*
     getDataPtr() const
     {
         return mData.data();
@@ -238,7 +238,7 @@ public:
     std::string
     getString() const
     {
-        return std::string(static_cast<const char*>(getDataPtr()), size());
+        return std::string(static_cast<char const*>(getDataPtr()), size());
     }
     void
     erase()
@@ -296,12 +296,12 @@ public:
         return v != mData;
     }
     bool
-    operator==(const Serializer& v) const
+    operator==(Serializer const& v) const
     {
         return v.mData == mData;
     }
     bool
-    operator!=(const Serializer& v) const
+    operator!=(Serializer const& v) const
     {
         return v.mData != mData;
     }

include/xrpl/protocol/TER.h

@@ -139,8 +139,8 @@ enum TEMcodes : TERUnderlyingType {
 
     temARRAY_EMPTY,
     temARRAY_TOO_LARGE,
-
     temBAD_TRANSFER_FEE,
+    temINVALID_INNER_BATCH,
 };
 
 //------------------------------------------------------------------------------
@@ -645,37 +645,37 @@ using TER = TERSubset<CanCvtToTER>;
 //------------------------------------------------------------------------------
 
 inline bool
-isTelLocal(TER x)
+isTelLocal(TER x) noexcept
 {
-    return ((x) >= telLOCAL_ERROR && (x) < temMALFORMED);
+    return (x >= telLOCAL_ERROR && x < temMALFORMED);
 }
 
 inline bool
-isTemMalformed(TER x)
+isTemMalformed(TER x) noexcept
 {
-    return ((x) >= temMALFORMED && (x) < tefFAILURE);
+    return (x >= temMALFORMED && x < tefFAILURE);
 }
 
 inline bool
-isTefFailure(TER x)
+isTefFailure(TER x) noexcept
 {
-    return ((x) >= tefFAILURE && (x) < terRETRY);
+    return (x >= tefFAILURE && x < terRETRY);
 }
 
 inline bool
-isTerRetry(TER x)
+isTerRetry(TER x) noexcept
 {
-    return ((x) >= terRETRY && (x) < tesSUCCESS);
+    return (x >= terRETRY && x < tesSUCCESS);
 }
 
 inline bool
-isTesSuccess(TER x)
+isTesSuccess(TER x) noexcept
 {
-    return ((x) == tesSUCCESS);
+    return (x == tesSUCCESS);
 }
 
 inline bool
-isTecClaim(TER x)
+isTecClaim(TER x) noexcept
 {
     return ((x) >= tecCLAIM);
 }

include/xrpl/protocol/TxFlags.h

@@ -58,7 +58,8 @@ namespace ripple {
 // clang-format off
 // Universal Transaction flags:
 constexpr std::uint32_t tfFullyCanonicalSig                = 0x80000000;
-constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig;
+constexpr std::uint32_t tfInnerBatchTxn                    = 0x40000000;
+constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig | tfInnerBatchTxn;
 constexpr std::uint32_t tfUniversalMask                    = ~tfUniversal;
 
 // AccountSet flags:
@@ -97,6 +98,7 @@ constexpr std::uint32_t tfPassive                          = 0x00010000;
 constexpr std::uint32_t tfImmediateOrCancel                = 0x00020000;
 constexpr std::uint32_t tfFillOrKill                       = 0x00040000;
 constexpr std::uint32_t tfSell                             = 0x00080000;
+
 constexpr std::uint32_t tfOfferCreateMask =
     ~(tfUniversal | tfPassive | tfImmediateOrCancel | tfFillOrKill | tfSell);
 
@@ -120,6 +122,13 @@ 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;
@@ -155,6 +164,8 @@ 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;
@@ -230,9 +241,20 @@ 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);
-// VaultClawback flags:
-constexpr std::uint32_t const tfVaultClawbackUnauth        = 0x00010000;
-constexpr std::uint32_t const tfVaultClawbackMask = ~(tfUniversal | tfVaultClawbackUnauth);
+
+// Batch Flags:
+constexpr std::uint32_t tfAllOrNothing                 = 0x00010000;
+constexpr std::uint32_t tfOnlyOne                      = 0x00020000;
+constexpr std::uint32_t tfUntilFailure                 = 0x00040000;
+constexpr std::uint32_t tfIndependent                  = 0x00080000;
+/**
+ * @note If nested Batch transactions are supported in the future, the tfInnerBatchTxn flag
+ *  will need to be removed from this mask to allow Batch transaction to be inside 
+ *  the sfRawTransactions array.
+ */
+constexpr std::uint32_t const tfBatchMask =
+    ~(tfUniversal | tfAllOrNothing | tfOnlyOne | tfUntilFailure | tfIndependent) | tfInnerBatchTxn;
+
 // clang-format on
 
 }  // namespace ripple

include/xrpl/protocol/TxFormats.h

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

include/xrpl/protocol/TxMeta.h

@@ -46,7 +46,10 @@ private:
         CtorHelper);
 
 public:
-    TxMeta(uint256 const& transactionID, std::uint32_t ledger);
+    TxMeta(
+        uint256 const& transactionID,
+        std::uint32_t ledger,
+        std::optional<uint256> parentBatchId = std::nullopt);
     TxMeta(uint256 const& txID, std::uint32_t ledger, Blob const&);
     TxMeta(uint256 const& txID, std::uint32_t ledger, std::string const&);
     TxMeta(uint256 const& txID, std::uint32_t ledger, STObject const&);
@@ -130,6 +133,27 @@ public:
         return static_cast<bool>(mDelivered);
     }
 
+    void
+    setParentBatchId(uint256 const& parentBatchId)
+    {
+        mParentBatchId = parentBatchId;
+    }
+
+    uint256
+    getParentBatchId() const
+    {
+        XRPL_ASSERT(
+            hasParentBatchId(),
+            "ripple::TxMeta::getParentBatchId : non-null batch id");
+        return *mParentBatchId;
+    }
+
+    bool
+    hasParentBatchId() const
+    {
+        return static_cast<bool>(mParentBatchId);
+    }
+
 private:
     uint256 mTransactionID;
     std::uint32_t mLedger;
@@ -137,6 +161,7 @@ private:
     int mResult;
 
     std::optional<STAmount> mDelivered;
+    std::optional<uint256> mParentBatchId;
 
     STArray mNodes;
 };

include/xrpl/protocol/UintTypes.h

@@ -61,8 +61,7 @@ using NodeID = base_uint<160, detail::NodeIDTag>;
 /** MPTID is a 192-bit value representing MPT Issuance ID,
  * which is a concatenation of a 32-bit sequence (big endian)
  * and a 160-bit account */
-// TODO - edhennis - Add a tag
-using MPTID = uint192;
+using MPTID = base_uint<192>;
 
 /** XRP currency. */
 Currency const&
@@ -120,25 +119,25 @@ namespace std {
 template <>
 struct hash<ripple::Currency> : ripple::Currency::hasher
 {
-    explicit hash() = default;
+    hash() = default;
 };
 
 template <>
 struct hash<ripple::NodeID> : ripple::NodeID::hasher
 {
-    explicit hash() = default;
+    hash() = default;
 };
 
 template <>
 struct hash<ripple::Directory> : ripple::Directory::hasher
 {
-    explicit hash() = default;
+    hash() = default;
 };
 
 template <>
 struct hash<ripple::uint256> : ripple::uint256::hasher
 {
-    explicit hash() = default;
+    hash() = default;
 };
 
 }  // namespace std

include/xrpl/protocol/XRPAmount.h

@@ -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, const XRPAmount& q)
+operator<<(std::basic_ostream<Char, Traits>& os, XRPAmount const& q)
 {
     return os << q.drops();
 }

include/xrpl/protocol/detail/features.macro

@@ -32,7 +32,10 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
+XRPL_FEATURE(Batch,                      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    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (FrozenLPTokenTransfer,      Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -462,11 +462,23 @@ 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, 0x0083, Vault, vault, ({
+LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
     {sfPreviousTxnID,        soeREQUIRED},
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
     {sfSequence,             soeREQUIRED},

include/xrpl/protocol/detail/permissions.macro

@@ -0,0 +1,68 @@
+//------------------------------------------------------------------------------
+/*
+    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

@@ -113,6 +113,7 @@ 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)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -194,12 +195,13 @@ TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
 TYPED_SFIELD(sfVaultID,                  UINT256,   35)
+TYPED_SFIELD(sfParentBatchID,            UINT256,   36)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,           NUMBER,     2)
-TYPED_SFIELD(sfAssetsMaximum,             NUMBER,     3)
-TYPED_SFIELD(sfAssetsTotal,               NUMBER,     4)
+TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2)
+TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3)
+TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4)
 TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5)
 
 // currency amount (common)
@@ -285,6 +287,7 @@ 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)
@@ -334,6 +337,7 @@ 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)
@@ -354,6 +358,8 @@ UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
+UNTYPED_SFIELD(sfRawTransaction,         OBJECT,    34)
+UNTYPED_SFIELD(sfBatchSigner,            OBJECT,    35)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array
@@ -384,3 +390,6 @@ 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)
+UNTYPED_SFIELD(sfRawTransactions,        ARRAY,     30)
+UNTYPED_SFIELD(sfBatchSigners,           ARRAY,     31, SField::sMD_Default, SField::notSigning)

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 const char*
+    virtual char const*
     name() const noexcept override final
     {
         return "TokenCodecError";
@@ -86,7 +86,7 @@ public:
 };
 }  // namespace detail
 
-inline const ripple::detail::TokenCodecErrcCategory&
+inline ripple::detail::TokenCodecErrcCategory const&
 TokenCodecErrcCategory()
 {
     static ripple::detail::TokenCodecErrcCategory c;

include/xrpl/protocol/detail/transactions.macro

@@ -22,14 +22,14 @@
 #endif
 
 /**
- * TRANSACTION(tag, value, name, fields)
+ * TRANSACTION(tag, value, name, delegatable, fields)
  *
  * You must define a transactor class in the `ripple` namespace named `name`,
  * and include its header in `src/xrpld/app/tx/detail/applySteps.cpp`.
  */
 
 /** This transaction type executes a payment. */
-TRANSACTION(ttPAYMENT, 0, Payment, ({
+TRANSACTION(ttPAYMENT, 0, Payment, Delegation::delegatable, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfSendMax, soeOPTIONAL, soeMPTSupported},
@@ -41,7 +41,7 @@ TRANSACTION(ttPAYMENT, 0, Payment, ({
 }))
 
 /** This transaction type creates an escrow object. */
-TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, ({
+TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, Delegation::delegatable, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfCondition, soeOPTIONAL},
@@ -51,7 +51,7 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, ({
 }))
 
 /** This transaction type completes an existing escrow. */
-TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, ({
+TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, Delegation::delegatable, ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
     {sfFulfillment, soeOPTIONAL},
@@ -61,7 +61,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, ({
 
 
 /** This transaction type adjusts various account settings. */
-TRANSACTION(ttACCOUNT_SET, 3, AccountSet, ({
+TRANSACTION(ttACCOUNT_SET, 3, AccountSet, Delegation::notDelegatable, ({
     {sfEmailHash, soeOPTIONAL},
     {sfWalletLocator, soeOPTIONAL},
     {sfWalletSize, soeOPTIONAL},
@@ -75,20 +75,20 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet, ({
 }))
 
 /** This transaction type cancels an existing escrow. */
-TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel, ({
+TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel, Delegation::delegatable, ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
 }))
 
 /** This transaction type sets or clears an account's "regular key". */
-TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey, ({
+TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey, Delegation::notDelegatable, ({
     {sfRegularKey, soeOPTIONAL},
 }))
 
 // 6 deprecated
 
 /** This transaction type creates an offer to trade one asset for another. */
-TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, ({
+TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, Delegation::delegatable, ({
     {sfTakerPays, soeREQUIRED},
     {sfTakerGets, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -96,14 +96,14 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, ({
 }))
 
 /** This transaction type cancels existing offers to trade one asset for another. */
-TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel, ({
+TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel, Delegation::delegatable, ({
     {sfOfferSequence, soeREQUIRED},
 }))
 
 // 9 deprecated
 
 /** This transaction type creates a new set of tickets. */
-TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, ({
+TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, Delegation::delegatable, ({
     {sfTicketCount, soeREQUIRED},
 }))
 
@@ -112,13 +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.
-TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet, ({
+TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet, Delegation::notDelegatable, ({
     {sfSignerQuorum, soeREQUIRED},
     {sfSignerEntries, soeOPTIONAL},
 }))
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
-TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, ({
+TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, Delegation::delegatable, ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfSettleDelay, soeREQUIRED},
@@ -128,14 +128,14 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, ({
 }))
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
-TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund, ({
+TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund, Delegation::delegatable, ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
 }))
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
-TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, ({
+TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, Delegation::delegatable, ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
     {sfBalance, soeOPTIONAL},
@@ -145,7 +145,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, ({
 }))
 
 /** This transaction type creates a new check. */
-TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, ({
+TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, Delegation::delegatable, ({
     {sfDestination, soeREQUIRED},
     {sfSendMax, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -154,19 +154,19 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, ({
 }))
 
 /** This transaction type cashes an existing check. */
-TRANSACTION(ttCHECK_CASH, 17, CheckCash, ({
+TRANSACTION(ttCHECK_CASH, 17, CheckCash, Delegation::delegatable, ({
     {sfCheckID, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
     {sfDeliverMin, soeOPTIONAL},
 }))
 
 /** This transaction type cancels an existing check. */
-TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel, ({
+TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel, Delegation::delegatable, ({
     {sfCheckID, soeREQUIRED},
 }))
 
 /** This transaction type grants or revokes authorization to transfer funds. */
-TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, ({
+TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, Delegation::delegatable, ({
     {sfAuthorize, soeOPTIONAL},
     {sfUnauthorize, soeOPTIONAL},
     {sfAuthorizeCredentials, soeOPTIONAL},
@@ -174,14 +174,14 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, ({
 }))
 
 /** This transaction type modifies a trustline between two accounts. */
-TRANSACTION(ttTRUST_SET, 20, TrustSet, ({
+TRANSACTION(ttTRUST_SET, 20, TrustSet, Delegation::delegatable, ({
     {sfLimitAmount, soeOPTIONAL},
     {sfQualityIn, soeOPTIONAL},
     {sfQualityOut, soeOPTIONAL},
 }))
 
 /** This transaction type deletes an existing account. */
-TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, ({
+TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, Delegation::notDelegatable, ({
     {sfDestination, soeREQUIRED},
     {sfDestinationTag, soeOPTIONAL},
     {sfCredentialIDs, soeOPTIONAL},
@@ -190,7 +190,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, ({
 // 22 reserved
 
 /** This transaction mints a new NFT. */
-TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, ({
+TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, Delegation::delegatable, ({
     {sfNFTokenTaxon, soeREQUIRED},
     {sfTransferFee, soeOPTIONAL},
     {sfIssuer, soeOPTIONAL},
@@ -201,13 +201,13 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, ({
 }))
 
 /** This transaction burns (i.e. destroys) an existing NFT. */
-TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn, ({
+TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn, Delegation::delegatable, ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction creates a new offer to buy or sell an NFT. */
-TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, ({
+TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, Delegation::delegatable, ({
     {sfNFTokenID, soeREQUIRED},
     {sfAmount, soeREQUIRED},
     {sfDestination, soeOPTIONAL},
@@ -216,25 +216,25 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, ({
 }))
 
 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
-TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer, ({
+TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer, Delegation::delegatable, ({
     {sfNFTokenOffers, soeREQUIRED},
 }))
 
 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
-TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer, ({
+TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer, Delegation::delegatable, ({
     {sfNFTokenBuyOffer, soeOPTIONAL},
     {sfNFTokenSellOffer, soeOPTIONAL},
     {sfNFTokenBrokerFee, soeOPTIONAL},
 }))
 
 /** This transaction claws back issued tokens. */
-TRANSACTION(ttCLAWBACK, 30, Clawback, ({
+TRANSACTION(ttCLAWBACK, 30, Clawback, Delegation::delegatable, ({
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction claws back tokens from an AMM pool. */
-TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, ({
+TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, Delegation::delegatable, ({
     {sfHolder, soeREQUIRED},
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -242,14 +242,14 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, ({
 }))
 
 /** This transaction type creates an AMM instance */
-TRANSACTION(ttAMM_CREATE, 35, AMMCreate, ({
+TRANSACTION(ttAMM_CREATE, 35, AMMCreate, Delegation::delegatable, ({
     {sfAmount, soeREQUIRED},
     {sfAmount2, soeREQUIRED},
     {sfTradingFee, soeREQUIRED},
 }))
 
 /** This transaction type deposits into an AMM instance */
-TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, ({
+TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -260,7 +260,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, ({
 }))
 
 /** This transaction type withdraws from an AMM instance */
-TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, ({
+TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -270,14 +270,14 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, ({
 }))
 
 /** This transaction type votes for the trading fee */
-TRANSACTION(ttAMM_VOTE, 38, AMMVote, ({
+TRANSACTION(ttAMM_VOTE, 38, AMMVote, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfTradingFee, soeREQUIRED},
 }))
 
 /** This transaction type bids for the auction slot */
-TRANSACTION(ttAMM_BID, 39, AMMBid, ({
+TRANSACTION(ttAMM_BID, 39, AMMBid, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
     {sfBidMin, soeOPTIONAL},
@@ -286,20 +286,20 @@ TRANSACTION(ttAMM_BID, 39, AMMBid, ({
 }))
 
 /** This transaction type deletes AMM in the empty state */
-TRANSACTION(ttAMM_DELETE, 40, AMMDelete, ({
+TRANSACTION(ttAMM_DELETE, 40, AMMDelete, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
 }))
 
 /** This transactions creates a crosschain sequence number */
-TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID, ({
+TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
     {sfOtherChainSource, soeREQUIRED},
 }))
 
 /** This transactions initiates a crosschain transaction */
-TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, ({
+TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -307,7 +307,7 @@ TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, ({
 }))
 
 /** This transaction completes a crosschain transaction */
-TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, ({
+TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
     {sfDestination, soeREQUIRED},
@@ -316,7 +316,7 @@ TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, ({
 }))
 
 /** This transaction initiates a crosschain account create transaction */
-TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, ({
+TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -324,7 +324,7 @@ TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, ({
 }))
 
 /** This transaction adds an attestation to a claim */
-TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, ({
+TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
 
     {sfAttestationSignerAccount, soeREQUIRED},
@@ -340,7 +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, ({
+TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateAttestation, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
 
     {sfAttestationSignerAccount, soeREQUIRED},
@@ -357,31 +357,31 @@ TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateA
 }))
 
 /** This transaction modifies a sidechain */
-TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge, ({
+TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeOPTIONAL},
     {sfMinAccountCreateAmount, soeOPTIONAL},
 }))
 
 /** This transactions creates a sidechain */
-TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge, ({
+TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge, Delegation::delegatable, ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
     {sfMinAccountCreateAmount, soeOPTIONAL},
 }))
 
 /** This transaction type creates or updates a DID */
-TRANSACTION(ttDID_SET, 49, DIDSet, ({
+TRANSACTION(ttDID_SET, 49, DIDSet, Delegation::delegatable, ({
     {sfDIDDocument, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
     {sfData, soeOPTIONAL},
 }))
 
 /** This transaction type deletes a DID */
-TRANSACTION(ttDID_DELETE, 50, DIDDelete, ({}))
+TRANSACTION(ttDID_DELETE, 50, DIDDelete, Delegation::delegatable, ({}))
 
 /** This transaction type creates an Oracle instance */
-TRANSACTION(ttORACLE_SET, 51, OracleSet, ({
+TRANSACTION(ttORACLE_SET, 51, OracleSet, Delegation::delegatable, ({
     {sfOracleDocumentID, soeREQUIRED},
     {sfProvider, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
@@ -391,18 +391,18 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet, ({
 }))
 
 /** This transaction type deletes an Oracle instance */
-TRANSACTION(ttORACLE_DELETE, 52, OracleDelete, ({
+TRANSACTION(ttORACLE_DELETE, 52, OracleDelete, Delegation::delegatable, ({
     {sfOracleDocumentID, soeREQUIRED},
 }))
 
 /** This transaction type fixes a problem in the ledger state */
-TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, ({
+TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, Delegation::delegatable, ({
     {sfLedgerFixType, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction type creates a MPTokensIssuance instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, Delegation::delegatable, ({
     {sfAssetScale, soeOPTIONAL},
     {sfTransferFee, soeOPTIONAL},
     {sfMaximumAmount, soeOPTIONAL},
@@ -410,24 +410,24 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, ({
 }))
 
 /** This transaction type destroys a MPTokensIssuance instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, Delegation::delegatable, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
 }))
 
 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, ({
+TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, Delegation::delegatable, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction type authorizes a MPToken instance */
-TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize, ({
+TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize, Delegation::delegatable, ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction type create an Credential instance */
-TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, ({
+TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, Delegation::delegatable, ({
     {sfSubject, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
     {sfExpiration, soeOPTIONAL},
@@ -435,38 +435,44 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, ({
 }))
 
 /** This transaction type accept an Credential object */
-TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept, ({
+TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept, Delegation::delegatable, ({
     {sfIssuer, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
 }))
 
 /** This transaction type delete an Credential object */
-TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete, ({
+TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete, Delegation::delegatable, ({
     {sfSubject, soeOPTIONAL},
     {sfIssuer, soeOPTIONAL},
     {sfCredentialType, soeREQUIRED},
 }))
 
 /** This transaction type modify a NFToken */
-TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify, ({
+TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify, Delegation::delegatable, ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
 }))
 
 /** This transaction type creates or modifies a Permissioned Domain */
-TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet, ({
+TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet, Delegation::delegatable, ({
     {sfDomainID, soeOPTIONAL},
     {sfAcceptedCredentials, soeREQUIRED},
 }))
 
 /** This transaction type deletes a Permissioned Domain */
-TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete, ({
+TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete, Delegation::delegatable, ({
     {sfDomainID, soeREQUIRED},
 }))
 
+/** This transaction type delegates authorized account specified permissions */
+TRANSACTION(ttDELEGATE_SET, 64, DelegateSet, Delegation::notDelegatable, ({
+    {sfAuthorize, soeREQUIRED},
+    {sfPermissions, soeREQUIRED},
+}))
+
 /** This transaction creates a single asset vault. */
-TRANSACTION(ttVAULT_CREATE, 64, VaultCreate, ({
+TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
     {sfAsset, soeREQUIRED, soeMPTSupported},
     {sfAssetsMaximum, soeOPTIONAL},
     {sfMPTokenMetadata, soeOPTIONAL},
@@ -476,7 +482,7 @@ TRANSACTION(ttVAULT_CREATE, 64, VaultCreate, ({
 }))
 
 /** This transaction updates a single asset vault. */
-TRANSACTION(ttVAULT_SET, 65, VaultSet, ({
+TRANSACTION(ttVAULT_SET, 66, VaultSet, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfAssetsMaximum, soeOPTIONAL},
     {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
@@ -484,35 +490,41 @@ TRANSACTION(ttVAULT_SET, 65, VaultSet, ({
 }))
 
 /** This transaction deletes a single asset vault. */
-TRANSACTION(ttVAULT_DELETE, 66, VaultDelete, ({
+TRANSACTION(ttVAULT_DELETE, 67, VaultDelete, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
 }))
 
 /** This transaction trades assets for shares with a vault. */
-TRANSACTION(ttVAULT_DEPOSIT, 67, VaultDeposit, ({
+TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
 }))
 
 /** This transaction trades shares for assets with a vault. */
-TRANSACTION(ttVAULT_WITHDRAW, 68, VaultWithdraw, ({
+TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfDestination, soeOPTIONAL},
 }))
 
 /** This transaction claws back tokens from a vault. */
-TRANSACTION(ttVAULT_CLAWBACK, 69, VaultClawback, ({
+TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback, Delegation::delegatable, ({
     {sfVaultID, soeREQUIRED},
     {sfHolder, soeREQUIRED},
     {sfAmount, soeOPTIONAL, soeMPTSupported},
 }))
 
+/** This transaction type batches together transactions. */
+TRANSACTION(ttBATCH, 71, Batch, Delegation::notDelegatable, ({
+    {sfRawTransactions, soeREQUIRED},
+    {sfBatchSigners, soeOPTIONAL},
+}))
+
 /** This system-generated transaction type is used to update the status of the various amendments.
 
     For details, see: https://xrpl.org/amendments.html
  */
-TRANSACTION(ttAMENDMENT, 100, EnableAmendment, ({
+TRANSACTION(ttAMENDMENT, 100, EnableAmendment, Delegation::notDelegatable, ({
     {sfLedgerSequence, soeREQUIRED},
     {sfAmendment, soeREQUIRED},
 }))
@@ -520,7 +532,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, ({
+TRANSACTION(ttFEE, 101, SetFee, Delegation::notDelegatable, ({
     {sfLedgerSequence, soeOPTIONAL},
     // Old version uses raw numbers
     {sfBaseFee, soeOPTIONAL},
@@ -537,9 +549,8 @@ TRANSACTION(ttFEE, 101, SetFee, ({
 
     For details, see: https://xrpl.org/negative-unl.html
  */
-TRANSACTION(ttUNL_MODIFY, 102, UNLModify, ({
+TRANSACTION(ttUNL_MODIFY, 102, UNLModify, Delegation::notDelegatable, ({
     {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()}
     {
     }
-    const char*
+    char const*
     what() const noexcept override
     {
         if (msg.empty())
@@ -40,7 +40,7 @@ struct JsonTypeMismatchError : std::exception
         : key{k.c_str()}, expectedType{std::move(et)}
     {
     }
-    const char*
+    char const*
     what() const noexcept override
     {
         if (msg.empty())

include/xrpl/protocol/jss.h

@@ -83,13 +83,14 @@ JSS(PriceDataSeries);                    // field.
 JSS(PriceData);                          // field.
 JSS(Provider);                           // field.
 JSS(QuoteAsset);                         // in: Oracle.
+JSS(RawTransaction);                     // in: Batch
+JSS(RawTransactions);                    // in: Batch
 JSS(SLE_hit_rate);                       // out: GetCounts.
 JSS(Scale);                              // field.
 JSS(SettleDelay);                        // in: TransactionSign
 JSS(SendMax);                            // in: TransactionSign
 JSS(Sequence);                           // in/out: TransactionSign; field.
 JSS(SetFlag);                            // field.
-JSS(SharesTotal);                        // out: Vault
 JSS(Signer);                             // field.
 JSS(Signers);                            // field.
 JSS(SigningPubKey);                      // field.
@@ -101,7 +102,6 @@ JSS(TransactionType);                    // in: TransactionSign.
 JSS(TransferRate);                       // in: TransferRate.
 JSS(TxnSignature);                       // field.
 JSS(URI);                                // field.
-JSS(VaultID);                            // field.
 JSS(VoteSlots);                          // out: AMM Vote
 JSS(aborted);                            // out: InboundLedger
 JSS(accepted);               // out: LedgerToJson, OwnerInfo, SubmitTransaction
@@ -147,6 +147,7 @@ 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
@@ -687,6 +688,7 @@ 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 +705,7 @@ JSS(write_load);              // out: GetCounts
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION
 
-#define TRANSACTION(tag, value, name, fields) JSS(name);
+#define TRANSACTION(tag, value, name, delegatable, fields) JSS(name);
 
 #include <xrpl/protocol/detail/transactions.macro>
 
@@ -730,8 +732,6 @@ JSS(write_load);              // out: GetCounts
 
 #undef JSS
 
-// clang-format on
-
 }  // namespace jss
 }  // namespace ripple
 

include/xrpl/resource/detail/Key.h

@@ -53,7 +53,7 @@ struct Key
 
     struct key_equal
     {
-        explicit key_equal() = default;
+        key_equal() = default;
 
         bool
         operator()(Key const& lhs, Key const& rhs) const

src/libxrpl/basics/Archive.cpp

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

src/libxrpl/basics/FileUtilities.cpp

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

src/libxrpl/basics/Number.cpp

@@ -469,7 +469,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
-    const uint128_t f = 100'000'000'000'000'000;
+    uint128_t const 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];
-    const std::string domain = smMatch[4];
+    std::string const domain = smMatch[4];
     // We need to use Endpoint to parse the domain to
     // strip surrounding brackets from IPv6 addresses,
     // e.g. [::1] => ::1.
-    const auto result = beast::IP::Endpoint::from_string_checked(domain);
+    auto const result = beast::IP::Endpoint::from_string_checked(domain);
     pUrl.domain = result ? result->address().to_string() : domain;
-    const std::string port = smMatch[5];
+    std::string const 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 const auto init = start_clock();
+    static auto const init = start_clock();
 
     // Return the number of seconds since rippled start
     return time_point{duration{now_}};

src/libxrpl/basics/mulDiv.cpp

@@ -31,9 +31,7 @@ namespace ripple {
 std::optional<std::uint64_t>
 mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div)
 {
-    using namespace boost::multiprecision;
-
-    uint128_t result;
+    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, const char*> jsonSpecialCharacterEscape = {
+std::map<char, char const*> jsonSpecialCharacterEscape = {
     {'"', "\\\""},
     {'\\', "\\\\"},
     {'/', "\\/"},
@@ -47,13 +47,13 @@ std::map<char, const char*> jsonSpecialCharacterEscape = {
 static size_t const jsonEscapeLength = 2;
 
 // All other JSON punctuation.
-const char closeBrace = '}';
-const char closeBracket = ']';
-const char colon = ':';
-const char comma = ',';
-const char openBrace = '{';
-const char openBracket = '[';
-const char quote = '"';
+char const closeBrace = '}';
+char const closeBracket = ']';
+char const colon = ':';
+char const comma = ',';
+char const openBrace = '{';
+char const openBracket = '[';
+char const 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;
-    const char* begin = document_.c_str();
-    const char* end = begin + document_.length();
+    char const* begin = document_.c_str();
+    char const* end = begin + document_.length();
     return parse(begin, end, root);
 }
 
@@ -99,7 +99,7 @@ Reader::parse(std::istream& sin, Value& root)
 }
 
 bool
-Reader::parse(const char* beginDoc, const char* endDoc, Value& root)
+Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
 {
     begin_ = beginDoc;
     end_ = endDoc;
@@ -193,7 +193,7 @@ Reader::skipCommentTokens(Token& token)
 }
 
 bool
-Reader::expectToken(TokenType type, Token& token, const char* message)
+Reader::expectToken(TokenType type, Token& token, char const* message)
 {
     readToken(token);
 
@@ -629,7 +629,7 @@ bool
 Reader::decodeDouble(Token& token)
 {
     double value = 0;
-    const int bufferSize = 32;
+    int const 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)
     {
-        const ErrorInfo& error = *itError;
+        ErrorInfo const& error = *itError;
         formattedMessage +=
             "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
         formattedMessage += "  " + error.message_ + "\n";

src/libxrpl/json/json_value.cpp

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

src/libxrpl/json/json_valueiterator.cpp

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

src/libxrpl/json/json_writer.cpp

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

src/libxrpl/protocol/BuildInfo.cpp

@@ -36,7 +36,7 @@ namespace BuildInfo {
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
-char const* const versionString = "2.4.0"
+char const* const versionString = "2.5.0-b1"
 // clang-format on
 
 #if defined(DEBUG) || defined(SANITIZER)

src/libxrpl/protocol/ErrorCodes.cpp

@@ -96,6 +96,7 @@ 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},
@@ -106,6 +107,7 @@ 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");
-        const auto& sequence = features.get<Feature::byIndex>();
+        auto const& sequence = features.get<Feature::byIndex>();
         return sequence[i];
     }
     size_t
     getIndex(Feature const& feature) const
     {
-        const auto& sequence = features.get<Feature::byIndex>();
+        auto const& 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
     {
-        const auto& feature_index = features.get<Feature::byFeature>();
+        auto const& 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
     {
-        const auto& name_index = features.get<Feature::byName>();
+        auto const& 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, const char* logicErrorMessage)
+check(bool condition, char const* logicErrorMessage)
 {
     if (!condition)
         LogicError(logicErrorMessage);
@@ -437,9 +437,13 @@ 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);
-#define XRPL_RETIRE(name)                                                     \
-    [[deprecated("The referenced amendment has been retired"), maybe_unused]] \
+
+// clang-format off
+#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>
 
@@ -455,7 +459,7 @@ featureToName(uint256 const& f)
 //
 // Use initialization of one final static variable to set
 // featureCollections::readOnly.
-[[maybe_unused]] static const bool readOnlySet =
+[[maybe_unused]] static bool const readOnlySet =
     featureCollections.registrationIsDone();
 
 }  // namespace ripple

src/libxrpl/protocol/Indexes.cpp

@@ -94,6 +94,7 @@ enum class LedgerNameSpace : std::uint16_t {
     MPTOKEN = 't',
     CREDENTIAL = 'D',
     PERMISSIONED_DOMAIN = 'm',
+    DELEGATE = 'E',
     VAULT = 'V',
 
     // No longer used or supported. Left here to reserve the space
@@ -453,6 +454,14 @@ 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)
 {

src/libxrpl/protocol/InnerObjectFormats.cpp

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

src/libxrpl/protocol/LedgerFormats.cpp

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

src/libxrpl/protocol/Permissions.cpp

@@ -0,0 +1,148 @@
+//------------------------------------------------------------------------------
+/*
+    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, fields) {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 const std::uint64_t mod[17] = {
+    static std::uint64_t const mod[17] = {
         /* 0 */ 10000000000000000,
         /* 1 */ 1000000000000000,
         /* 2 */ 100000000000000,

src/libxrpl/protocol/SField.cpp

@@ -87,7 +87,7 @@ SField::SField(
     private_access_tag_t,
     SerializedTypeID tid,
     int fv,
-    const char* fn,
+    char const* fn,
     int meta,
     IsSigning signing)
     : fieldCode(field_code(tid, fv))

src/libxrpl/protocol/STAccount.cpp

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

src/libxrpl/protocol/STAmount.cpp

@@ -91,13 +91,13 @@ setSTAmountCanonicalizeSwitchover(bool v)
     *getStaticSTAmountCanonicalizeSwitchover() = v;
 }
 
-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::uint64_t const tenTo14 = 100000000000000ull;
+static std::uint64_t const tenTo14m1 = tenTo14 - 1;
+static std::uint64_t const tenTo17 = tenTo14 * 1000;
 
 //------------------------------------------------------------------------------
 static std::int64_t
-getInt64Value(STAmount const& amount, bool valid, const char* error)
+getInt64Value(STAmount const& amount, bool valid, char const* error)
 {
     if (!valid)
         Throw<std::runtime_error>(error);
@@ -683,9 +683,9 @@ STAmount::add(Serializer& s) const
 }
 
 bool
-STAmount::isEquivalent(const STBase& t) const
+STAmount::isEquivalent(STBase const& t) const
 {
-    const STAmount* v = dynamic_cast<const STAmount*>(&t);
+    STAmount const* v = dynamic_cast<STAmount const*>(&t);
     return v && (*v == *this);
 }
 
@@ -1011,7 +1011,7 @@ amountFromJsonNoThrow(STAmount& result, Json::Value const& jvSource)
         result = amountFromJson(sfGeneric, jvSource);
         return true;
     }
-    catch (const std::exception& e)
+    catch (std::exception const& e)
     {
         JLOG(debugLog().warn())
             << "amountFromJsonNoThrow: caught: " << e.what();