Merge branch 'develop' into FN-36-credential_pins_pseudo_account

2026-08-21 22:30:57 +00:00 · 2026-08-13 10:25:12 +02:00
parent c7c42559cc 8e9b1791c5
commit 0ab294ed96
203 changed files with 7124 additions and 1932 deletions
--- a/.cspell.config.yaml
+++ b/.cspell.config.yaml
@@ -366,6 +366,7 @@ words:
  - xchain
  - ximinez
  - XMACRO
+  - xored
  - xrpkuwait
  - xrpl
  - xrpld
--- a/.envrc
+++ b/.envrc
@@ -1,3 +1,7 @@
 watch_file nix/*.nix

+# The dev shell derivation includes all of conan/ (see nix/devshell.nix), so any
+# change in there has to invalidate direnv's cached environment.
+watch_dir conan
+
 use flake
--- a/API-CHANGELOG.md
+++ b/API-CHANGELOG.md
@@ -54,6 +54,8 @@ This section contains changes targeting a future version.
 - `submit`: The `fail_hard` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - `subscribe`: The `taker` field in the `books` array now returns `actMalformed` instead of `badIssuer` if the value is not a valid account. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - Fixed a bug in `Forwarded` HTTP header parsing where the extracted IP address could be incorrect when no comma or semicolon delimiter follows the address. This could cause the server to misidentify a client's IP address when operating behind a reverse proxy. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `gateway_balances`: The `account` and `ident` fields now return an `invalidParams` error if the value is not a string, instead of an `internal` error. [#7655](https://github.com/XRPLF/rippled/pull/7655)
+- `account_lines`: The `peer` field now returns an error if the value is not a string. [#7728](https://github.com/XRPLF/rippled/pull/7728)

 ## XRP Ledger server version 3.1.0

--- a/BUILD.md
+++ b/BUILD.md
@@ -4,34 +4,14 @@

 ## Minimum Requirements

-See [System Requirements](https://xrpl.org/system-requirements.html).
+For the hardware needed to run a node, see
+[System Requirements](https://xrpl.org/system-requirements.html).

-Building xrpld generally requires Git, Python, Conan, CMake, and a C++
-compiler.
-
- [Python](https://www.python.org/downloads/)
- [Conan](https://conan.io/downloads.html)
- [CMake](https://cmake.org/download/)
-
-You can verify that the required tools are installed and runnable with:
-
-```bash
-./bin/check-tools.sh
-```
-
-`xrpld` is written in the C++23 dialect. The [tested compiler versions][cpp23-support] are:
-
-| Compiler    | Version         |
-| ----------- | --------------- |
-| GCC         | 15.2            |
-| Clang       | 22              |
-| Apple Clang | 21              |
-| MSVC        | 19.44[^windows] |
+For the software needed to build xrpld, see the
+[environment setup guide](./docs/build/environment.md).

 ## Operating Systems

-Please see the [environment setup guide](./docs/build/environment.md) for detailed instructions for all platforms.
-
 ### Linux

 The Ubuntu Linux distribution has received the highest level of quality
@@ -47,9 +27,8 @@ CI testing is done in macOS 26 (Tahoe), but the build defaults `CMAKE_OSX_DEPLOY

 ### Windows

-Windows is used by some engineers for development only.
-
-[^windows]: Windows is not recommended for production use.
+Windows is used by some engineers for development only, and is not recommended
+for production use.

 ## Steps

@@ -74,37 +53,25 @@ releases](https://github.com/XRPLF/rippled/releases).

 ### Set Up Conan

-After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python,
-Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
-
-These instructions assume a basic familiarity with Conan and CMake. If you are
-unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official
-[Getting Started][conan-getting-started] walkthrough.
-
-#### Profiles
-
-We recommend that you install our Conan profiles:
+Once your [development environment](./docs/build/environment.md) is ready, set
+Conan up for this repository:

 ```bash
-conan config install conan/profiles/ -tf $(conan config home)/profiles/
+./conan/init.sh
 ```

-You can check your Conan profile by running:
+That installs our [`global.conf`](./conan/global.conf), our Conan
+[profiles](./conan/profiles), and the `xrplf` remote that hosts some of our
+dependencies. It honours `CONAN_HOME` and never deletes an existing Conan home,
+so it is safe to re-run — it only overwrites the files it manages.

-```bash
-conan profile show
-```
+> [!TIP]
+> In the [Nix development shell](./docs/build/nix.md#conan-configuration) this is
+> already done for you: the script runs on entry.

-If the default profile is not suitable for your environment, you can create a custom profile and pass it to Conan.
-More information on customizing Conan can be found in the [Advanced Conan configuration](./docs/build/advanced_conan.md).
-
-#### Add xrplf remote
-
-Run the following command to add the `xrplf` remote, which hosts some of our dependencies:
-
-```bash
-conan remote add --index 0 --force xrplf https://conan.xrplf.org/repository/conan/
-```
+You can inspect the resulting profile with `conan profile show`. If it is not
+suitable for your environment, create a custom profile and pass it to Conan — see
+[Advanced Conan configuration](./docs/build/advanced_conan.md).

 ### Set Up Ccache

@@ -269,10 +236,14 @@ which is only enabled when the `coverage` option is set, e.g. with
 Prerequisites for the coverage report:

 - [gcovr tool][gcovr] (can be installed e.g. with [pip][python-pip])
- `gcov` for GCC (installed with the compiler by default) or
- `llvm-cov` for Clang (installed with the compiler by default)
+- `gcov` for GCC or `llvm-cov` for Clang, usually installed with the compiler
 - `Debug` build type

+> [!NOTE]
+> Clang coverage is not available in the [Nix development shell](./docs/build/nix.md#building-xrpld-in-the-nix-shell):
+> its `clang` shells do not ship `llvm-cov`. Use a `gcc` shell instead (`.#gcc`,
+> or `.#gcc-plain` on Linux), which provides a `gcov` matching its compiler.
+
 A coverage report is created when the following steps are completed, in order:

 1. `xrpld` binary built with instrumentation data, enabled by the `coverage`
@@ -389,10 +360,14 @@ After any updates or changes to dependencies, you may need to do the following:
 4. [Regenerate lockfile](./docs/build/advanced_conan.md#conan-lockfile).
 5. Re-run [conan install](#build-and-test).

+If you are using the Nix development shell, whether prebuilt Conan binaries apply
+depends on your platform — see
+[Prebuilt packages](./docs/build/nix.md#prebuilt-packages).
+
 #### ERROR: Package not resolved

 If you're seeing an error like `ERROR: Package 'snappy/1.1.10' not resolved: Unable to find 'snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246' in remotes.`,
-please [add `xrplf` remote](#add-xrplf-remote) or re-run `conan export` for [patched recipes](./docs/build/advanced_conan.md#patched-recipes).
+please [set Conan up](#set-up-conan) so the `xrplf` remote is configured, or re-run `conan export` for [patched recipes](./docs/build/advanced_conan.md#patched-recipes).

 ### `protobuf/port_def.inc` file not found

@@ -412,7 +387,6 @@ For example, if you want to build Debug:
 1. For conan install, pass `--settings build_type=Debug`
 2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`

-[cpp23-support]: https://en.cppreference.com/w/cpp/compiler_support/23
 [conan-getting-started]: https://docs.conan.io/en/latest/getting_started.html
 [unity-build]: https://en.wikipedia.org/wiki/Unity_build
 [gcovr]: https://gcovr.com/en/stable/getting-started.html
--- a/cmake/XrplCompiler.cmake
+++ b/cmake/XrplCompiler.cmake
@@ -266,10 +266,50 @@ elseif(use_lld)
    )
    if("${LD_VERSION}" MATCHES "LLD")
        target_link_libraries(common INTERFACE -fuse-ld=lld)
+        # remembered for the linker flag probe below
+        set(fuse_ld_flag "-fuse-ld=lld")
    endif()
    unset(LD_VERSION)
 endif()

+# Linker warnings are errors where we control the toolchain and the dependencies: CI and the Nix dev shell.
+# On non-Nix macOS we suppress the deployment target warning: an old Conan profile may not pin os.version.
+# Only the new Apple linker understands the flag, so probe the actual linker (lld may be selected above).
+if(is_macos OR is_linux)
+    if(is_ci OR is_nix_compiler)
+        if(is_macos)
+            set(fatal_warnings_flag "-Wl,-fatal_warnings")
+        else()
+            set(fatal_warnings_flag "-Wl,--fatal-warnings")
+        endif()
+        message(
+            STATUS
+            "Treating all linker warnings as errors (${fatal_warnings_flag})"
+        )
+        target_link_options(common INTERFACE "${fatal_warnings_flag}")
+        unset(fatal_warnings_flag)
+    elseif(is_macos)
+        set(silence_flag "-Wl,-deployment_target_mismatches,suppress")
+        set(probe_flags ${fuse_ld_flag} "${silence_flag}")
+        include(CheckLinkerFlag)
+        check_linker_flag(
+            CXX
+            "${probe_flags}"
+            have_deployment_target_mismatches
+        )
+        if(have_deployment_target_mismatches)
+            message(
+                STATUS
+                "Silencing macOS deployment target mismatch warnings (${silence_flag})"
+            )
+            target_link_options(common INTERFACE "${silence_flag}")
+        endif()
+        unset(probe_flags)
+        unset(silence_flag)
+    endif()
+endif()
+unset(fuse_ld_flag)
+
 if(assert)
    foreach(var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
        string(REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
--- a/cmake/XrplCov.cmake
+++ b/cmake/XrplCov.cmake
@@ -44,6 +44,7 @@ setup_target_for_coverage_gcovr(
    EXCLUDE
        "src/test"
        "src/tests"
+        "src/benchmarks"
        "include/xrpl/beast/test"
        "include/xrpl/beast/unit_test"
        "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
--- a/conan/init.sh
+++ b/conan/init.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Install our Conan configuration, profiles and the xrplf remote into CONAN_HOME.
+# Safe to re-run; never deletes the Conan home.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+CONAN_DIR="$(conan config home)"
+
+echo "Installing Conan configuration into ${CONAN_DIR}"
+conan config install "${SCRIPT_DIR}/global.conf"
+conan config install "${SCRIPT_DIR}/profiles" -tf "${CONAN_DIR}/profiles"
+# This script manages these files, so make them read-only - Conan does not
+# preserve the source mode. Only the files: the directories must stay writable
+# for `conan config install` to replace them.
+chmod a-w "${CONAN_DIR}/global.conf"
+find "${CONAN_DIR}/profiles" -type f -exec chmod a-w {} +
+
+echo "Adding the xrplf Conan remote"
+# --index 0: our patched recipes must win over Conan Center.
+conan remote add --index 0 --force xrplf https://conan.xrplf.org/repository/conan/
--- a/conan/profiles/default
+++ b/conan/profiles/default
@@ -1,10 +1,7 @@
 {% set os = detect_api.detect_os() %}
 {% set arch = detect_api.detect_arch() %}
 {% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
-{% set compiler_version = version %}
-{% if os == "Linux" %}
 {% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
-{% endif %}
 {% if os == "Macos" %}
 {# Minimum macOS the dependencies target. #}
 {# Without this, Conan builds each dependency against the (possibly newer) host SDK, so the #}
--- a/docs/NodeStoreRefactoringCaseStudy.pdf
+++ b/docs/NodeStoreRefactoringCaseStudy.pdf
--- a/docs/build/environment.md
+++ b/docs/build/environment.md
@@ -6,22 +6,52 @@ This document explains how to set one up.

 ## Tested compiler versions

-`xrpld` is built in the **C++23** dialect by default.
-Make sure your toolchain is recent enough — the compiler versions currently tested in CI are:
+`xrpld` is built in the **C++23** dialect by default, so your toolchain has to
+support it — see [compiler support for C++23][cpp23-support].
+The versions currently tested in CI are:

-| Compiler    | Version |
-| ----------- | ------- |
-| GCC         | 15.2    |
-| Clang       | 22      |
-| Apple Clang | 17      |
-| MSVC        | 19.44   |
+| Compiler    | Version            |
+| ----------- | ------------------ |
+| GCC         | 15.2               |
+| Clang       | 22                 |
+| Apple Clang | 21                 |
+| MSVC        | Visual Studio 2026 |

 LLVM tools (`clang-tidy` and `clang-format`) are also pinned to version 22.

+### Older compilers
+
 Older compilers may fail to build the latest `develop` code: the codebase now
 relies on C++23 features and has been adjusted for `clang-tidy`.
 If the latest code doesn't build for you, update your build toolchain first.

+If updating isn't an option for you, we do accept pull requests that fix builds
+on older compilers, as long as the change is small and doesn't make the code
+harder to read. What we can't promise is that older compilers will keep working:
+only the versions in the table above are tested in CI, and we won't hold back
+the use of C++23 features or add invasive workarounds to keep an untested
+compiler building. Treat support for anything outside the table as best-effort.
+
+## Required tools
+
+Besides a compiler, building `xrpld` requires:
+
+| Tool                                        | Minimum version |
+| ------------------------------------------- | --------------- |
+| [Git](https://git-scm.com/downloads)        | any recent      |
+| [Python](https://www.python.org/downloads/) | 3.11            |
+| [Conan](https://conan.io/downloads.html)    | 2.17            |
+| [CMake](https://cmake.org/download/)        | 3.16            |
+
+On Linux and macOS, the [Nix development shell](./nix.md) provides all of them
+(see below). On Windows they have to be installed manually.
+
+Once they are in place, verify that everything is installed and runnable with:
+
+```bash
+./bin/check-tools.sh
+```
+
 ## Linux and macOS

 The **recommended way** to get a development environment on Linux and macOS is
@@ -39,20 +69,15 @@ Clang. If you instead opt to use your system-wide Apple Clang (via
 below).

 See [Using the Nix development shell](./nix.md) for installation and usage
-details, including how to select a different compiler.
-
-> [!NOTE]
-> Using Nix is not mandatory. Any custom environment (Homebrew packages or
-> anything else) will continue to work, but then it is up to you to keep it in
-> sync with the environment used in CI. Nix unifies the development environment
-> for everyone and synchronizes updates, which is why we recommend it.
+details, including how to select a different compiler and why we recommend Nix
+over a hand-maintained environment.

 ### macOS: managing the Apple Clang version

 If you use your system-wide Apple Clang on macOS (via `nix develop .#apple-clang`),
 the compiler version is whatever your installed Xcode (or Command Line Tools)
 provides. The following command should return a version greater than or equal to
-the [minimum required](#tested-compiler-versions):
+the [tested one](#tested-compiler-versions):

 ```bash
 clang --version
@@ -89,23 +114,23 @@ building xrpld. You may want to install and pin a specific version of Xcode:
 Nix is not available on Windows, so the required tools have to be installed
 manually:

- [Visual Studio 2022](https://visualstudio.microsoft.com/) with the
+- [Visual Studio 2026](https://visualstudio.microsoft.com/) with the
  **"Desktop development with C++"** workload — this provides MSVC and the
-  "x64 Native Tools Command Prompt".
+  "x64 Native Tools Command Prompt". CI configures CMake with the
+  `Visual Studio 18 2026` generator.
 - [Git for Windows](https://git-scm.com/download/win)
- [Python 3.11](https://www.python.org/downloads/), or higher
- [Conan 2.17](https://conan.io/downloads.html), or higher
- [CMake 3.22](https://cmake.org/download/), or higher
-
-> [!NOTE]
-> Windows is used for development only and is not recommended for production.
+- Python, Conan, and CMake, at the versions listed in
+  [Required tools](#required-tools).

 ## Clang-tidy

 `clang-tidy` is required to run static analysis checks locally (see
 [CONTRIBUTING.md](../../CONTRIBUTING.md)). It is not required to build the
-project. This project currently uses `clang-tidy` version 22.
+project. The version this project uses is listed in
+[Tested compiler versions](#tested-compiler-versions).

-On Linux and macOS, the [Nix development shell](./nix.md) provides `clang-tidy`
-22 out of the box — run it via `run-clang-tidy`. No separate installation is
-needed.
+On Linux and macOS, the [Nix development shell](./nix.md) provides that exact
+version out of the box — run it via `run-clang-tidy`. No separate installation
+is needed.
+
+[cpp23-support]: https://en.cppreference.com/w/cpp/compiler_support/23
--- a/docs/build/nix.md
+++ b/docs/build/nix.md
@@ -120,7 +120,7 @@ nix develop -c "$SHELL"
 >
 > If it doesn't, either adjust your shell configuration so it doesn't override `$PATH`, or use [direnv](#automatic-activation-with-direnv) (below), which loads the environment _after_ your shell config and so takes precedence regardless of the shell you use.

-## Building xrpld with Nix
+## Building xrpld in the Nix shell

 Once inside the Nix development shell, follow the standard [build instructions](../../BUILD.md#steps). The Nix shell provides all necessary tools (CMake, Ninja, Conan, etc.).

@@ -128,6 +128,28 @@ Coverage builds (`-Dcoverage=ON`) work in the `gcc` shell (and `gcc-plain` on Li
 each ships a `gcov` matching its compiler, since Nix's cc-wrapper does not expose one.
 The `clang` shells do not include `llvm-cov`, so use a `gcc` shell for coverage.

+## Conan configuration
+
+The shell runs [`conan/init.sh`](../../conan/init.sh) on entry, so
+[Set Up Conan](../../BUILD.md#set-up-conan) is already done for you. It installs
+into the shell's own Conan home: `CONAN_HOME=~/.conan2-nix`.
+
+### Prebuilt packages
+
+On **Linux**, the binaries on the `xrplf` remote are built in this same Nix
+environment — CI runs in Docker images that bundle the dev shell's toolchain (see
+[`nix/docker`](../../nix/docker)) — so `.#gcc` and `.#clang` can reuse them. The
+`-plain` shells do not match that toolchain's glibc, so binaries from the remote
+are not a reliable match there.
+
+On **macOS**, CI builds with Apple Clang, so the remote holds nothing for the Nix
+`clang` toolchain and dependencies are compiled locally. We do not publish
+Nix-built macOS binaries because a Conan package ID records the compiler version
+but not the nixpkgs revision.
+
+To compile everything from source, add `--build '*'` to the `conan install`
+command.
+
 ## Automatic Activation with direnv

 [direnv](https://direnv.net/) or [nix-direnv](https://github.com/nix-community/nix-direnv) can automatically activate the Nix development shell when you enter the repository directory.
@@ -142,14 +164,6 @@ The repository already ships an `.envrc` at its root that activates the Nix flak
 > [!NOTE]
 > direnv only caches the `.direnv` directory (already listed in `.gitignore`); no other repository files are affected.

-## Conan and Prebuilt Packages
-
-Please note that there is no guarantee that binaries from conan cache will work when using nix. If you encounter any errors, please use `--build '*'` to force conan to compile everything from source:
-
-```bash
-conan install .. --output-folder . --build '*' --settings build_type=Release
-```
-
 ## Updating `flake.lock` file

 To update `flake.lock` to the latest revision use `nix flake update` command.
--- a/docs/sample_chart.doc
+++ b/docs/sample_chart.doc
@@ -1,24 +0,0 @@
-/*!
-    \page somestatechart Example state diagram
-
-    \startuml SomeState "my state diagram"
-    scale 600 width
-
-    [*] -> State1
-    State1 --> State2 : Succeeded
-    State1 --> [*] : Aborted
-    State2 --> State3 : Succeeded
-    State2 --> [*] : Aborted
-    state State3 {
-      state "Accumulate Enough Data\nLong State Name" as long1
-      long1 : Just a test
-      [*] --> long1
-      long1 --> long1 : New Data
-      long1 --> ProcessData : Enough Data
-    }
-    State3 --> State3 : Failed
-    State3 --> [*] : Succeeded / Save Result
-    State3 --> [*] : Aborted
-
-    \enduml
-*/
--- a/include/xrpl/basics/Archive.h
+++ b/include/xrpl/basics/Archive.h
@@ -1,6 +1,6 @@
 #pragma once

-#include <boost/filesystem.hpp>
+#include <filesystem>

 namespace xrpl {

@@ -13,6 +13,6 @@ namespace xrpl {
 * @throws runtime_error
 */
 void
-extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const& dst);
+extractTarLz4(std::filesystem::path const& src, std::filesystem::path const& dst);

 }  // namespace xrpl
--- a/include/xrpl/basics/Buffer.h
+++ b/include/xrpl/basics/Buffer.h
@@ -3,6 +3,7 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/beast/utility/instrumentation.h>

+#include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -156,6 +157,19 @@ public:
    }
    /** @} */

+    /**
+     * Set every byte in the buffer to the given value.
+     *
+     * The size is unchanged, and this is a no-op on an empty buffer.
+     *
+     * @param value the byte to write to every position.
+     */
+    void
+    fill(std::uint8_t value) noexcept
+    {
+        std::fill_n(p_.get(), size_, value);
+    }
+
    /**
     * Reset the buffer.
     * All memory is deallocated. The resulting size is 0.
@@ -226,10 +240,4 @@ operator==(Buffer const& lhs, Buffer const& rhs) noexcept
    return std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
 }

-inline bool
-operator!=(Buffer const& lhs, Buffer const& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
 }  // namespace xrpl
--- a/include/xrpl/basics/FileUtilities.h
+++ b/include/xrpl/basics/FileUtilities.h
@@ -1,24 +1,79 @@
 #pragma once

-#include <boost/filesystem.hpp>
-#include <boost/system/error_code.hpp>
-
 #include <cstddef>
+#include <filesystem>
 #include <optional>
 #include <string>
+#include <system_error>

 namespace xrpl {

 std::string
 getFileContents(
-    boost::system::error_code& ec,
-    boost::filesystem::path const& sourcePath,
+    std::error_code& ec,
+    std::filesystem::path const& sourcePath,
    std::optional<std::size_t> maxSize = std::nullopt);

 void
 writeFileContents(
-    boost::system::error_code& ec,
-    boost::filesystem::path const& destPath,
+    std::error_code& ec,
+    std::filesystem::path const& destPath,
    std::string const& contents);

+/**
+ * Generate a unique, non-existing path under @p base whose filename starts with
+ * @p prefix and ends with a random hex suffix.
+ *
+ * Attempts up to @p maxAttempts paths. Throws `std::runtime_error` if a unique
+ * path cannot be found or if the filesystem returns an error while checking for
+ * existence.
+ */
+std::filesystem::path
+uniqueRandomPath(
+    std::filesystem::path const& base,
+    std::string const& prefix = "",
+    std::size_t maxAttempts = 100);
+
+/**
+ * RAII temporary directory.
+ *
+ * The directory and all its contents are deleted when
+ * the instance of `TempDir` is destroyed.
+ */
+class TempDir
+{
+    std::filesystem::path path_;
+
+public:
+#if !GENERATING_DOCS
+    TempDir(TempDir const&) = delete;
+    TempDir&
+    operator=(TempDir const&) = delete;
+#endif
+
+    /**
+     * Construct a temporary directory.
+     */
+    TempDir();
+
+    /**
+     * Destroy a temporary directory.
+     */
+    ~TempDir();
+
+    /**
+     * Get the native path for the temporary directory.
+     */
+    [[nodiscard]] std::string
+    path() const;
+
+    /**
+     * Get the native path for a file.
+     *
+     * The file does not need to exist.
+     */
+    [[nodiscard]] std::string
+    file(std::string const& name) const;
+};
+
 }  // namespace xrpl
--- a/include/xrpl/basics/IntrusivePointer.h
+++ b/include/xrpl/basics/IntrusivePointer.h
@@ -96,9 +96,6 @@ public:
    SharedIntrusive&
    operator=(SharedIntrusive const& rhs);

-    bool
-    operator!=(std::nullptr_t) const;
-
    bool
    operator==(std::nullptr_t) const;

--- a/include/xrpl/basics/IntrusivePointer.ipp
+++ b/include/xrpl/basics/IntrusivePointer.ipp
@@ -111,13 +111,6 @@ SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
    return *this;
 }

-template <class T>
-bool
-SharedIntrusive<T>::operator!=(std::nullptr_t) const
-{
-    return this->get() != nullptr;
-}
-
 template <class T>
 bool
 SharedIntrusive<T>::operator==(std::nullptr_t) const
--- a/include/xrpl/basics/Log.h
+++ b/include/xrpl/basics/Log.h
@@ -3,8 +3,8 @@
 #include <xrpl/beast/utility/Journal.h>

 #include <boost/beast/core/string.hpp>
-#include <boost/filesystem.hpp>

+#include <filesystem>
 #include <fstream>
 #include <map>
 #include <memory>
@@ -84,7 +84,7 @@ private:
         * @return `true` if the file was opened.
         */
        bool
-        open(boost::filesystem::path const& path);
+        open(std::filesystem::path const& path);

        /**
         * Close and re-open the system file associated with the log
@@ -133,7 +133,7 @@ private:

    private:
        std::unique_ptr<std::ofstream> stream_;
-        boost::filesystem::path path_;
+        std::filesystem::path path_;
    };

    std::mutex mutable mutex_;
@@ -152,7 +152,7 @@ public:
    virtual ~Logs() = default;

    bool
-    open(boost::filesystem::path const& pathToLogFile);
+    open(std::filesystem::path const& pathToLogFile);

    beast::Journal::Sink&
    get(std::string const& name);
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -304,7 +304,7 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
 *      on-ledger are non-negative. This is due to implementation details of
 *      several operations which use unsigned arithmetic internally. This is
 *      sufficient to represent all valid XRP values (where the absolute value
- *      can not exceed INITIAL_XRP: 10^17), and MPT values (where the absolute
+ *      can not exceed kInitialXRP: 10^17), and MPT values (where the absolute
 *      value can not exceed maxMPTokenAmount: 2^63-1).
 *
 * ---- Mantissa Range Switching ----
@@ -449,12 +449,6 @@ public:
            x.exponent_ == y.exponent_;
    }

-    friend constexpr bool
-    operator!=(Number const& x, Number const& y) noexcept
-    {
-        return !(x == y);
-    }
-
    friend constexpr bool
    operator<(Number const& l, Number const& r) noexcept
    {
--- a/include/xrpl/basics/SHAMapHash.h
+++ b/include/xrpl/basics/SHAMapHash.h
@@ -85,12 +85,6 @@ public:
    }
 };

-inline bool
-operator!=(SHAMapHash const& x, SHAMapHash const& y)
-{
-    return !(x == y);
-}
-
 template <>
 inline std::size_t
 extract(SHAMapHash const& key)
--- a/include/xrpl/basics/Slice.h
+++ b/include/xrpl/basics/Slice.h
@@ -208,12 +208,6 @@ operator==(Slice const& lhs, Slice const& rhs) noexcept
    return std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
 }

-inline bool
-operator!=(Slice const& lhs, Slice const& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
 inline bool
 operator<(Slice const& lhs, Slice const& rhs) noexcept
 {
--- a/include/xrpl/basics/StringUtilities.h
+++ b/include/xrpl/basics/StringUtilities.h
@@ -125,9 +125,31 @@ struct ParsedUrl
 bool
 parseUrl(ParsedUrl& pUrl, std::string const& strUrl);

+/**
+ * Remove leading and trailing ASCII whitespace.
+ *
+ * Whitespace is the fixed set " \t\n\v\f\r"; the current locale is not
+ * consulted, so the result depends only on the input.
+ *
+ * @param str The string to trim.
+ * @return @p str without leading or trailing whitespace.
+ */
 std::string
 trimWhitespace(std::string str);

+/**
+ * Fold ASCII upper case letters to lower case.
+ *
+ * Only 'A' through 'Z' are remapped; every other byte is left alone and the
+ * current locale is not consulted, so the result depends only on the input.
+ *
+ * @param str The string to fold.
+ * @return @p str with each ASCII upper case letter replaced by its lower case
+ *         equivalent.
+ */
+std::string
+toLower(std::string str);
+
 std::optional<std::uint64_t>
 toUInt64(std::string const& s);

--- a/include/xrpl/basics/partitioned_unordered_map.h
+++ b/include/xrpl/basics/partitioned_unordered_map.h
@@ -116,12 +116,6 @@ public:
        {
            return lhs.map == rhs.map && lhs.ait == rhs.ait && lhs.mit == rhs.mit;
        }
-
-        friend bool
-        operator!=(Iterator const& lhs, Iterator const& rhs)
-        {
-            return !(lhs == rhs);
-        }
    };

    struct ConstIterator
@@ -189,12 +183,6 @@ public:
        {
            return lhs.map == rhs.map && lhs.ait == rhs.ait && lhs.mit == rhs.mit;
        }
-
-        friend bool
-        operator!=(ConstIterator const& lhs, ConstIterator const& rhs)
-        {
-            return !(lhs == rhs);
-        }
    };

 private:
--- a/include/xrpl/beast/container/detail/aged_ordered_container.h
+++ b/include/xrpl/beast/container/detail/aged_ordered_container.h
@@ -1038,25 +1038,6 @@ public:
               Compare,
               OtherAllocator> const& other) const;

-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
-    bool
-    operator!=(AgedOrderedContainer<
-               OtherIsMulti,
-               OtherIsMap,
-               Key,
-               OtherT,
-               OtherDuration,
-               Compare,
-               OtherAllocator> const& other) const
-    {
-        return !(this->operator==(other));
-    }
-
    template <
        bool OtherIsMulti,
        bool OtherIsMap,
--- a/include/xrpl/beast/container/detail/aged_unordered_container.h
+++ b/include/xrpl/beast/container/detail/aged_unordered_container.h
@@ -1340,28 +1340,6 @@ public:
               OtherAllocator> const& other) const
        requires MaybeMulti;

-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherKey,
-        class OtherT,
-        class OtherDuration,
-        class OtherHash,
-        class OtherAllocator>
-    bool
-    operator!=(AgedUnorderedContainer<
-               OtherIsMulti,
-               OtherIsMap,
-               OtherKey,
-               OtherT,
-               OtherDuration,
-               OtherHash,
-               KeyEqual,
-               OtherAllocator> const& other) const
-    {
-        return !(this->operator==(other));
-    }
-
 private:
    bool
    wouldExceed(size_type additional) const
--- a/include/xrpl/beast/core/List.h
+++ b/include/xrpl/beast/core/List.h
@@ -82,13 +82,6 @@ public:
        return node_ == other.node_;
    }

-    template <typename M>
-    bool
-    operator!=(ListIterator<M> const& other) const noexcept
-    {
-        return !((*this) == other);
-    }
-
    reference
    operator*() const noexcept
    {
--- a/include/xrpl/beast/net/IPEndpoint.h
+++ b/include/xrpl/beast/net/IPEndpoint.h
@@ -110,12 +110,6 @@ public:
    operator==(Endpoint const& lhs, Endpoint const& rhs);
    friend bool
    operator<(Endpoint const& lhs, Endpoint const& rhs);
-
-    friend bool
-    operator!=(Endpoint const& lhs, Endpoint const& rhs)
-    {
-        return !(lhs == rhs);
-    }
    friend bool
    operator>(Endpoint const& lhs, Endpoint const& rhs)
    {
--- a/include/xrpl/beast/rfc2616.h
+++ b/include/xrpl/beast/rfc2616.h
@@ -229,12 +229,6 @@ public:
        return other.it_ == it_ && other.end_ == end_ && other.value_.size() == value_.size();
    }

-    bool
-    operator!=(ListIterator const& other) const
-    {
-        return !(*this == other);
-    }
-
    reference
    operator*() const
    {
--- a/include/xrpl/beast/unit_test/reporter.h
+++ b/include/xrpl/beast/unit_test/reporter.h
@@ -8,7 +8,6 @@
 #include <xrpl/beast/unit_test/runner.h>
 #include <xrpl/beast/unit_test/suite_info.h>

-#include <boost/lexical_cast.hpp>
 #include <boost/optional.hpp>

 #include <algorithm>
@@ -188,7 +187,7 @@ Reporter<Unused>::fmtdur(clock_type::duration const& d)
    using namespace std::chrono;
    auto const ms = duration_cast<milliseconds>(d);
    if (ms < seconds{1})
-        return boost::lexical_cast<std::string>(ms.count()) + "ms";
+        return std::to_string(ms.count()) + "ms";
    std::stringstream ss;
    ss << std::fixed << std::setprecision(1) << (ms.count() / 1000.) << "s";
    return ss.str();
--- a/include/xrpl/beast/unit_test/suite.h
+++ b/include/xrpl/beast/unit_test/suite.h
@@ -6,11 +6,10 @@

 #include <xrpl/beast/unit_test/runner.h>

-#include <boost/filesystem.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/throw_exception.hpp>

 #include <exception>
+#include <filesystem>
 #include <memory>
 #include <ostream>
 #include <sstream>
@@ -27,10 +26,10 @@ makeReason(String const& reason, char const* file, int line)
    std::string s(reason);
    if (!s.empty())
        s.append(": ");
-    namespace fs = boost::filesystem;
+    namespace fs = std::filesystem;
    s.append(fs::path{file}.filename().string());
    s.append("(");
-    s.append(boost::lexical_cast<std::string>(line));
+    s.append(std::to_string(line));
    s.append(")");
    return s;
 }
--- a/include/xrpl/beast/utility/temp_dir.h
+++ b/include/xrpl/beast/utility/temp_dir.h
@@ -1,71 +0,0 @@
-#pragma once
-
-#include <boost/filesystem.hpp>
-
-#include <string>
-
-namespace beast {
-
-/**
- * RAII temporary directory.
- *
- * The directory and all its contents are deleted when
- * the instance of `temp_dir` is destroyed.
- */
-class TempDir
-{
-    boost::filesystem::path path_;
-
-public:
-#if !GENERATING_DOCS
-    TempDir(TempDir const&) = delete;
-    TempDir&
-    operator=(TempDir const&) = delete;
-#endif
-
-    /**
-     * Construct a temporary directory.
-     */
-    TempDir()
-    {
-        auto const dir = boost::filesystem::temp_directory_path();
-        do
-        {
-            path_ = dir / boost::filesystem::unique_path();
-        } while (boost::filesystem::exists(path_));
-        boost::filesystem::create_directory(path_);
-    }
-
-    /**
-     * Destroy a temporary directory.
-     */
-    ~TempDir()
-    {
-        // use non-throwing calls in the destructor
-        boost::system::error_code ec;
-        boost::filesystem::remove_all(path_, ec);
-        // TODO: warn/notify if ec set ?
-    }
-
-    /**
-     * Get the native path for the temporary directory
-     */
-    [[nodiscard]] std::string
-    path() const
-    {
-        return path_.string();
-    }
-
-    /**
-     * Get the native path for the a file.
-     *
-     * The file does not need to exist.
-     */
-    [[nodiscard]] std::string
-    file(std::string const& name) const
-    {
-        return (path_ / name).string();
-    }
-};
-
-}  // namespace beast
--- a/include/xrpl/conditions/Condition.h
+++ b/include/xrpl/conditions/Condition.h
@@ -92,10 +92,4 @@ operator==(Condition const& lhs, Condition const& rhs)
        lhs.fingerprint == rhs.fingerprint;
 }

-inline bool
-operator!=(Condition const& lhs, Condition const& rhs)
-{
-    return !(lhs == rhs);
-}
-
 }  // namespace xrpl::cryptoconditions
--- a/include/xrpl/conditions/Fulfillment.h
+++ b/include/xrpl/conditions/Fulfillment.h
@@ -93,12 +93,6 @@ operator==(Fulfillment const& lhs, Fulfillment const& rhs)
        lhs.fingerprint() == rhs.fingerprint();
 }

-inline bool
-operator!=(Fulfillment const& lhs, Fulfillment const& rhs)
-{
-    return !(lhs == rhs);
-}
-
 /**
 * Determine whether the given fulfillment and condition match
 */
--- a/include/xrpl/core/PerfLog.h
+++ b/include/xrpl/core/PerfLog.h
@@ -4,10 +4,9 @@
 #include <xrpl/core/Job.h>
 #include <xrpl/json/json_value.h>

-#include <boost/filesystem.hpp>
-
 #include <chrono>
 #include <cstdint>
+#include <filesystem>
 #include <functional>
 #include <memory>
 #include <string>
@@ -44,7 +43,7 @@ public:
     */
    struct Setup
    {
-        boost::filesystem::path perfLog;
+        std::filesystem::path perfLog;
        // log_interval is in milliseconds to support faster testing.
        milliseconds logInterval{seconds(1)};
    };
@@ -149,7 +148,7 @@ public:
 };

 PerfLog::Setup
-setupPerfLog(Section const& section, boost::filesystem::path const& configDir);
+setupPerfLog(Section const& section, std::filesystem::path const& configDir);

 std::unique_ptr<PerfLog>
 makePerfLog(
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -4,6 +4,7 @@
 #include <xrpl/json/json_forwards.h>

 #include <cstring>
+#include <iterator>
 #include <limits>
 #include <map>
 #include <string>
@@ -72,36 +73,18 @@ operator==(StaticString x, StaticString y)
    return strcmp(x.cStr(), y.cStr()) == 0;
 }

-inline bool
-operator!=(StaticString x, StaticString y)
-{
-    return !(x == y);
-}
-
 inline bool
 operator==(std::string const& x, StaticString y)
 {
    return strcmp(x.c_str(), y.cStr()) == 0;
 }

-inline bool
-operator!=(std::string const& x, StaticString y)
-{
-    return !(x == y);
-}
-
 inline bool
 operator==(StaticString x, std::string const& y)
 {
    return y == x;
 }

-inline bool
-operator!=(StaticString x, std::string const& y)
-{
-    return !(y == x);
-}
-
 /**
 * @brief Represents a <a HREF="http://www.json.org">JSON</a> value.
 *
@@ -489,12 +472,6 @@ toJson(xrpl::Number const& number)
 bool
 operator==(Value const&, Value const&);

-inline bool
-operator!=(Value const& x, Value const& y)
-{
-    return !(x == y);
-}
-
 bool
 operator<(Value const&, Value const&);

@@ -548,6 +525,7 @@ public:
 class ValueIteratorBase
 {
 public:
+    using iterator_category = std::bidirectional_iterator_tag;
    using size_t = unsigned int;
    using difference_type = int;
    using SelfType = ValueIteratorBase;
@@ -562,12 +540,6 @@ public:
        return isEqual(other);
    }

-    bool
-    operator!=(SelfType const& other) const
-    {
-        return !isEqual(other);
-    }
-
    /**
     * Return either the index or the member name of the referenced value as a
     * Value.
--- a/include/xrpl/ledger/BookDirs.h
+++ b/include/xrpl/ledger/BookDirs.h
@@ -49,12 +49,6 @@ public:
    bool
    operator==(const_iterator const& other) const;

-    bool
-    operator!=(const_iterator const& other) const
-    {
-        return !(*this == other);
-    }
-
    reference
    operator*() const;

--- a/include/xrpl/ledger/CanonicalTXSet.h
+++ b/include/xrpl/ledger/CanonicalTXSet.h
@@ -59,12 +59,6 @@ private:
            return lhs.txId_ == rhs.txId_;
        }

-        friend bool
-        operator!=(Key const& lhs, Key const& rhs)
-        {
-            return !(lhs == rhs);
-        }
-
        [[nodiscard]] uint256 const&
        getAccount() const
        {
--- a/include/xrpl/ledger/Dir.h
+++ b/include/xrpl/ledger/Dir.h
@@ -59,12 +59,6 @@ public:
    bool
    operator==(ConstIterator const& other) const;

-    bool
-    operator!=(ConstIterator const& other) const
-    {
-        return !(*this == other);
-    }
-
    reference
    operator*() const;

--- a/include/xrpl/ledger/View.h
+++ b/include/xrpl/ledger/View.h
@@ -35,6 +35,11 @@ enum class SkipEntry : bool { No = false, Yes };
 //
 //------------------------------------------------------------------------------

+/**
+ * Whether an expiration check should be inclusive or exclusive.
+ */
+enum class ExpiryComparison { Inclusive, Exclusive };
+
 /**
 * Determines whether the given expiration time has passed.
 *
@@ -54,11 +59,16 @@ enum class SkipEntry : bool { No = false, Yes };
 *
 * @param view The ledger whose parent time is used as the clock.
 * @param exp The optional expiration time we want to check.
+ * @param comparison Whether the boundary is inclusive (`now >= exp`, the
+ *                   default) or exclusive (`now > exp`).
 *
 * @return `true` if `exp` is in the past; `false` otherwise.
 */
 [[nodiscard]] bool
-hasExpired(ReadView const& view, std::optional<std::uint32_t> const& exp);
+hasExpired(
+    ReadView const& view,
+    std::optional<std::uint32_t> const& exp,
+    ExpiryComparison comparison = ExpiryComparison::Inclusive);

 // Note, depth parameter is used to limit the recursion depth
 [[nodiscard]] bool
--- a/include/xrpl/ledger/detail/ReadViewFwdRange.h
+++ b/include/xrpl/ledger/detail/ReadViewFwdRange.h
@@ -85,9 +85,6 @@ public:
        bool
        operator==(Iterator const& other) const;

-        bool
-        operator!=(Iterator const& other) const;
-
        // Can throw
        reference
        operator*() const;
--- a/include/xrpl/ledger/detail/ReadViewFwdRange.ipp
+++ b/include/xrpl/ledger/detail/ReadViewFwdRange.ipp
@@ -64,13 +64,6 @@ ReadViewFwdRange<ValueType>::Iterator::operator==(Iterator const& other) const
    return impl_ == other.impl_;
 }

-template <class ValueType>
-bool
-ReadViewFwdRange<ValueType>::Iterator::operator!=(Iterator const& other) const
-{
-    return !(*this == other);
-}
-
 template <class ValueType>
 auto
 ReadViewFwdRange<ValueType>::Iterator::operator*() const -> reference
--- a/include/xrpl/ledger/helpers/AMMHelpers.h
+++ b/include/xrpl/ledger/helpers/AMMHelpers.h
@@ -226,7 +226,7 @@ getAMMOfferStartWithTakerGets(

    auto getAmounts = [&pool, &tfee](Number const& nTakerGetsProposed) {
        // Round downward to minimize the offer and to maximize the quality.
-        // This has the most impact when takerGets is XRP.
+        // This has the most impact when takerGets is integral.
        auto const takerGets =
            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::RoundingMode::Downward);
        return TAmounts<TIn, TOut>{swapAssetOut(pool, takerGets, tfee), takerGets};
@@ -294,7 +294,7 @@ getAMMOfferStartWithTakerPays(

    auto getAmounts = [&pool, &tfee](Number const& nTakerPaysProposed) {
        // Round downward to minimize the offer and to maximize the quality.
-        // This has the most impact when takerPays is XRP.
+        // This has the most impact when takerPays is integral.
        auto const takerPays =
            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::RoundingMode::Downward);
        return TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
@@ -313,11 +313,11 @@ getAMMOfferStartWithTakerPays(
 * is equal to LOB quality (in this case AMM offer quality is
 * better than LOB quality) or AMM offer is equal to LOB quality
 * (in this case SPQ is better than LOB quality).
- * Pre-amendment code calculates takerPays first. If takerGets is XRP,
- * it is rounded down, which results in worse offer quality than
- * LOB quality, and the offer might fail to generate.
- * Post-amendment code calculates the XRP offer side first. The result
- * is rounded down, which makes the offer quality better.
+ * Pre-amendment code calculates takerPays first. If takerGets is the
+ * economically coarser integral side, it is rounded down, which results in
+ * worse offer quality than LOB quality, and the offer might fail to generate.
+ * Post-amendment code calculates the economically coarser integral offer side
+ * first. The result is rounded down, which makes the offer quality better.
 *   It might not be possible to match either SPQ or AMM offer to LOB
 * quality. This generally happens at higher fees.
 * @param pool AMM pool balances
@@ -396,10 +396,18 @@ changeSpotPriceQuality(
        return std::nullopt;
    }

-    // Generate the offer starting with XRP side. Return seated offer amounts
-    // if the offer can be generated, otherwise nullopt.
    auto amounts = [&]() {
-        if (isXRP(getAsset(pool.out)))
+        bool const inIntegral = getAsset(pool.in).integral();
+        bool const outIntegral = getAsset(pool.out).integral();
+
+        // Preserve historical behavior for fractional pairs and XRP/IOU-style
+        // one-integral-side pairs. For two integral assets, pick the side whose
+        // minimum unit is economically coarser at this quality.
+        //
+        // Quality::rate() is input units per output unit, so one output unit is
+        // coarser when it costs at least one input unit. Ties use takerGets,
+        // matching the historical XRP-output behavior.
+        if (outIntegral && (!inIntegral || Number(quality.rate()) >= 1))
            return getAMMOfferStartWithTakerGets(pool, quality, tfee);
        return getAMMOfferStartWithTakerPays(pool, quality, tfee);
    }();
--- a/include/xrpl/ledger/helpers/CredentialHelpers.h
+++ b/include/xrpl/ledger/helpers/CredentialHelpers.h
@@ -7,6 +7,7 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/STArray.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STTx.h>
@@ -58,7 +59,7 @@ deletePseudoAccountCredentials(

 // Amendment and parameters checks for sfCredentialIDs field
 NotTEC
-checkFields(STTx const& tx, beast::Journal j);
+checkFields(STTx const& tx, Rules const& rules, beast::Journal j);

 // Accessing the ledger to check if provided credentials are valid. Do not use
 // in doApply (only in preclaim) since it does not remove expired credentials.
--- a/include/xrpl/ledger/helpers/MPTokenHelpers.h
+++ b/include/xrpl/ledger/helpers/MPTokenHelpers.h
@@ -261,6 +261,14 @@ checkCreateMPT(
    xrpl::MPTIssue const& mptIssue,
    xrpl::AccountID const& holder,
    SLE::ref sponsorSle,
+    std::uint32_t flags,
+    beast::Journal j);
+
+TER
+checkCreateMPT(
+    xrpl::ApplyView& view,
+    xrpl::MPTIssue const& mptIssue,
+    xrpl::AccountID const& holder,
    beast::Journal j);

 //------------------------------------------------------------------------------
--- a/include/xrpl/ledger/helpers/VaultHelpers.h
+++ b/include/xrpl/ledger/helpers/VaultHelpers.h
@@ -6,10 +6,13 @@
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>

+#include <cstdint>
 #include <optional>

 namespace xrpl {

+class STTx;
+
 /**
 * From the perspective of a vault, return the number of shares to give
 * depositor when they offer a fixed amount of assets. Note, since shares are
@@ -123,4 +126,82 @@ isSoleShareholder(ReadView const& view, AccountID const& account, SLE::const_ref
 [[nodiscard]] VaultVersion
 getVaultVersion(SLE::const_ref vault);

+/**
+ * Resolves the VaultKind of a vault SLE. Returns VaultKind::ClosedEnded when
+ * sfVaultKind is present and equal to that value; anything else (including an
+ * absent field or an unrecognised value) is treated as VaultKind::OpenEnded.
+ *
+ * @param vault The vault SLE.
+ */
+[[nodiscard]] VaultKind
+getVaultKind(SLE::const_ref vault);
+
+/**
+ * Reads sfVaultKind from a transaction. An absent field resolves to
+ * VaultKind::OpenEnded (matching the on-ledger default); any unrecognised
+ * value is also treated as VaultKind::OpenEnded, mirroring the SLE overload.
+ * Callers that need to reject out-of-range values (e.g. preflight) should
+ * gate on isValidVaultKind() first.
+ *
+ * @param tx The transaction.
+ */
+[[nodiscard]] VaultKind
+getVaultKind(STTx const& tx);
+
+/**
+ * Returns true iff sfVaultKind is either absent from @p tx or is present and
+ * equal to a recognised VaultKind enumerator. Intended for use in preflight
+ * to reject malformed transactions before decoding with getVaultKind().
+ *
+ * @param tx The transaction.
+ */
+[[nodiscard]] bool
+isValidVaultKind(STTx const& tx);
+
+/**
+ * Returns true iff the (SubscriptionDate, RedemptionDate) gap of a
+ * closed-ended vault satisfies
+ * kMinInvestmentPeriod <= (red - sub) < kMaxInvestmentPeriod. The arithmetic
+ * is performed in std::int64_t so that @p sub near UINT32_MAX does not
+ * overflow. Shared by VaultCreate::preflight and the ValidVault invariant.
+ *
+ * @param sub The value of sfSubscriptionDate.
+ * @param red The value of sfRedemptionDate.
+ */
+[[nodiscard]] bool
+isValidClosedEndedGap(std::uint32_t sub, std::uint32_t red);
+
+/**
+ * Returns the current lifecycle phase of a vault. Open-ended
+ * vaults are always NoPhase. For closed-ended vaults the phase is derived
+ * from the parent ledger close time and the vault's immutable
+ * SubscriptionDate and RedemptionDate.
+ *
+ * @param view The ledger view whose parent close time is used as the clock.
+ * @param vault The vault SLE.
+ */
+[[nodiscard]] VaultPhase
+getVaultPhase(ReadView const& view, SLE::const_ref vault);
+
+/**
+ * Raw-fields overload of getVaultPhase. Derives the phase from an already
+ * decomposed vault snapshot: an absent or non-ClosedEnded @p vaultKind
+ * resolves to VaultPhase::NoPhase; otherwise the phase is computed from
+ * @p subscriptionDate and @p redemptionDate against the view's parent
+ * close time using the same boundary semantics as the SLE overload
+ * (Subscription is inclusive of now == SubscriptionDate; Investment starts
+ * strictly after).
+ *
+ * @param view The ledger view whose parent close time is used as the clock.
+ * @param vaultKind The value of sfVaultKind, or nullopt if absent.
+ * @param subscriptionDate The value of sfSubscriptionDate, or nullopt if absent.
+ * @param redemptionDate The value of sfRedemptionDate, or nullopt if absent.
+ */
+[[nodiscard]] VaultPhase
+getVaultPhase(
+    ReadView const& view,
+    std::optional<std::uint8_t> vaultKind,
+    std::optional<std::uint32_t> subscriptionDate,
+    std::optional<std::uint32_t> redemptionDate);
+
 }  // namespace xrpl
--- a/include/xrpl/protocol/AMMCore.h
+++ b/include/xrpl/protocol/AMMCore.h
@@ -47,7 +47,7 @@ ammLPTIssue(Asset const& asset1, Asset const& asset2, AccountID const& ammAccoun

 /**
 * Validate the amount.
- * If validZero is false and amount is beast::zero then invalid amount.
+ * If validZero is false and amount is beast::kZero then invalid amount.
 * Return error code if invalid amount.
 * If pair then validate amount's issue matches one of the pair's issue.
 */
--- a/include/xrpl/protocol/AmountConversions.h
+++ b/include/xrpl/protocol/AmountConversions.h
@@ -154,7 +154,7 @@ T
 toAmount(Asset const& asset, Number const& n, Number::RoundingMode mode = Number::getround())
 {
    SaveNumberRoundMode const rm(Number::getround());
-    if (isXRP(asset))
+    if (asset.integral())
        Number::setround(mode);

    if constexpr (std::is_same_v<IOUAmount, T>)
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -9,6 +9,7 @@
 #include <mpt_protocol.h>
 #include <secp256k1_mpt.h>

+#include <chrono>
 #include <cstddef>
 #include <cstdint>

@@ -327,6 +328,36 @@ enum class VaultVersion : uint8_t {
    CashBasis,
 };

+/**
+ * Vault kind. Distinguishes closed-ended vaults from the default open-ended
+ * kind. Persisted as sfVaultKind (UINT8); absent means OpenEnded.
+ */
+enum class VaultKind : std::uint8_t {
+    OpenEnded = 0,
+    ClosedEnded = 1,
+};
+
+/**
+ * Lifecycle phase of a vault. Open-ended vaults are always NoPhase; the other
+ * three values are the phases of a closed-ended vault.
+ */
+enum class VaultPhase : std::uint8_t {
+    NoPhase = 0,
+    Subscription,
+    Investment,
+    Redemption,
+};
+
+/**
+ * Bounds on the length of a closed-ended vault's Investment phase
+ * (RedemptionDate - SubscriptionDate). At vault creation the gap must satisfy
+ * kMinInvestmentPeriod <= gap < kMaxInvestmentPeriod.
+ */
+constexpr std::uint32_t kMinInvestmentPeriod =
+    std::chrono::seconds{std::chrono::minutes{1}}.count();
+// This is 946708560 seconds which 30 x 365.2425 days (the average length of a Gregorian year).
+constexpr std::uint32_t kMaxInvestmentPeriod = std::chrono::seconds{std::chrono::years{30}}.count();
+
 /**
 * Maximum recursion depth for vault shares being put as an asset inside
 * another vault; counted from 0
--- a/include/xrpl/protocol/Quality.h
+++ b/include/xrpl/protocol/Quality.h
@@ -75,13 +75,6 @@ operator==(TAmounts<In, Out> const& lhs, TAmounts<In, Out> const& rhs) noexcept
    return lhs.in == rhs.in && lhs.out == rhs.out;
 }

-template <class In, class Out>
-bool
-operator!=(TAmounts<In, Out> const& lhs, TAmounts<In, Out> const& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
 //------------------------------------------------------------------------------

 // XRPL specific constant used for parsing qualities and other things
@@ -271,12 +264,6 @@ public:
        return lhs.value_ == rhs.value_;
    }

-    friend bool
-    operator!=(Quality const& lhs, Quality const& rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
    friend std::ostream&
    operator<<(std::ostream& os, Quality const& quality)
    {
--- a/include/xrpl/protocol/QualityFunction.h
+++ b/include/xrpl/protocol/QualityFunction.h
@@ -60,6 +60,15 @@ public:
    std::optional<Number>
    outFromAvgQ(Quality const& quality);

+    /**
+     * Return whether `out` produces at least the requested
+     * average quality.
+     * @param quality requested average quality (quality limit)
+     * @param out output amount to test
+     */
+    [[nodiscard]] bool
+    satisfiesAvgQ(Quality const& quality, Number const& out) const;
+
    /**
     * Return true if the quality function is constant
     */
--- a/include/xrpl/protocol/Rules.h
+++ b/include/xrpl/protocol/Rules.h
@@ -98,9 +98,6 @@ public:
     */
    bool
    operator==(Rules const&) const;
-
-    bool
-    operator!=(Rules const& other) const;
 };

 std::optional<Rules> const&
--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -642,12 +642,6 @@ operator==(STAmount const& lhs, STAmount const& rhs);
 bool
 operator<(STAmount const& lhs, STAmount const& rhs);

-inline bool
-operator!=(STAmount const& lhs, STAmount const& rhs)
-{
-    return !(lhs == rhs);
-}
-
 inline bool
 operator>(STAmount const& lhs, STAmount const& rhs)
 {
--- a/include/xrpl/protocol/STArray.h
+++ b/include/xrpl/protocol/STArray.h
@@ -133,9 +133,6 @@ public:
    bool
    operator==(STArray const& s) const;

-    bool
-    operator!=(STArray const& s) const;
-
    iterator
    erase(iterator pos);

@@ -283,12 +280,6 @@ STArray::operator==(STArray const& s) const
    return v_ == s.v_;
 }

-inline bool
-STArray::operator!=(STArray const& s) const
-{
-    return v_ != s.v_;
-}
-
 inline STArray::iterator
 STArray::erase(iterator pos)
 {
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -140,8 +140,6 @@ public:

    bool
    operator==(STBase const& t) const;
-    bool
-    operator!=(STBase const& t) const;

    template <class D>
    D&
--- a/include/xrpl/protocol/STCurrency.h
+++ b/include/xrpl/protocol/STCurrency.h
@@ -93,12 +93,6 @@ operator==(STCurrency const& lhs, STCurrency const& rhs)
    return lhs.currency() == rhs.currency();
 }

-inline bool
-operator!=(STCurrency const& lhs, STCurrency const& rhs)
-{
-    return !operator==(lhs, rhs);
-}
-
 inline bool
 operator<(STCurrency const& lhs, STCurrency const& rhs)
 {
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -432,8 +432,6 @@ public:

    bool
    operator==(STObject const& o) const;
-    bool
-    operator!=(STObject const& o) const;

    class FieldErr;

@@ -667,36 +665,6 @@ public:
        return !lhs.engaged() || *lhs == *rhs;
    }

-    friend bool
-    operator!=(OptionalProxy const& lhs, std::nullopt_t) noexcept
-    {
-        return !(lhs == std::nullopt);
-    }
-
-    friend bool
-    operator!=(std::nullopt_t, OptionalProxy const& rhs) noexcept
-    {
-        return !(rhs == std::nullopt);
-    }
-
-    friend bool
-    operator!=(OptionalProxy const& lhs, optional_type const& rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
-    friend bool
-    operator!=(optional_type const& lhs, OptionalProxy const& rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
-    friend bool
-    operator!=(OptionalProxy const& lhs, OptionalProxy const& rhs) noexcept
-    {
-        return !(lhs == rhs);
-    }
-
    // Emulate std::optional::value_or
    [[nodiscard]] value_type
    valueOr(value_type val) const;
@@ -1202,12 +1170,6 @@ STObject::setFieldH160(SField const& field, BaseUInt<160, Tag> const& v)
    }
 }

-inline bool
-STObject::operator!=(STObject const& o) const
-{
-    return !(*this == o);
-}
-
 template <typename T, typename V>
 V
 STObject::getFieldByValue(SField const& field) const
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -115,9 +115,6 @@ public:
    bool
    operator==(STPathElement const& t) const;

-    bool
-    operator!=(STPathElement const& t) const;
-
 private:
    static std::size_t
    getHash(STPathElement const& element);
@@ -432,12 +429,6 @@ STPathElement::operator==(STPathElement const& t) const
        accountID_ == t.accountID_ && assetID_ == t.assetID_ && issuerID_ == t.issuerID_;
 }

-inline bool
-STPathElement::operator!=(STPathElement const& t) const
-{
-    return !operator==(t);
-}
-
 // ------------ STPath ------------

 inline STPath::STPath(std::vector<STPathElement> p) : path_(std::move(p))
--- a/include/xrpl/protocol/SeqProxy.h
+++ b/include/xrpl/protocol/SeqProxy.h
@@ -123,12 +123,6 @@ public:
        return (lhs.value() == rhs.value());
    }

-    friend constexpr bool
-    operator!=(SeqProxy lhs, SeqProxy rhs)
-    {
-        return !(lhs == rhs);
-    }
-
    friend constexpr bool
    operator<(SeqProxy lhs, SeqProxy rhs)
    {
--- a/include/xrpl/protocol/Serializer.h
+++ b/include/xrpl/protocol/Serializer.h
@@ -265,20 +265,10 @@ public:
        return v == data_;
    }
    bool
-    operator!=(Blob const& v) const
-    {
-        return v != data_;
-    }
-    bool
    operator==(Serializer const& v) const
    {
        return v.data_ == data_;
    }
-    bool
-    operator!=(Serializer const& v) const
-    {
-        return v.data_ != data_;
-    }

    static int
    decodeLengthLength(int b1);
--- a/include/xrpl/protocol/TxFlags.h
+++ b/include/xrpl/protocol/TxFlags.h
@@ -425,8 +425,7 @@ inline constexpr FlagValue tfDepositSubTx =
    ASF_FLAG(asfDefaultRipple, 8)                 \
    ASF_FLAG(asfDepositAuth, 9)                   \
    ASF_FLAG(asfAuthorizedNFTokenMinter, 10)      \
-    /*  11 is reserved for Hooks amendment */     \
-    /* ASF_FLAG(asfTshCollect, 11) */             \
+    /*  11 is unused */                           \
    ASF_FLAG(asfDisallowIncomingNFTokenOffer, 12) \
    ASF_FLAG(asfDisallowIncomingCheck, 13)        \
    ASF_FLAG(asfDisallowIncomingPayChan, 14)      \
--- a/include/xrpl/protocol/Units.h
+++ b/include/xrpl/protocol/Units.h
@@ -258,13 +258,6 @@ public:
        return value_ == other;
    }

-    template <Compatible<ValueUnit> Other>
-    constexpr bool
-    operator!=(ValueUnit<unit_type, Other> const& other) const
-    {
-        return !operator==(other);
-    }
-
    constexpr bool
    operator<(ValueUnit const& other) const
    {
--- a/include/xrpl/protocol/detail/STVar.h
+++ b/include/xrpl/protocol/detail/STVar.h
@@ -152,10 +152,4 @@ operator==(STVar const& lhs, STVar const& rhs)
    return lhs.get().isEquivalent(rhs.get());
 }

-inline bool
-operator!=(STVar const& lhs, STVar const& rhs)
-{
-    return !(lhs == rhs);
-}
-
 }  // namespace xrpl::detail
--- a/include/xrpl/protocol/detail/ledger_entries.macro
+++ b/include/xrpl/protocol/detail/ledger_entries.macro
@@ -506,6 +506,9 @@ LEDGER_ENTRY(ltVAULT, 0x0084, Vault, vault, ({
    {sfWithdrawalPolicy,     SoeRequired},
    {sfScale,                SoeDefault},
    {sfLEVersion,            SoeDefault},
+    {sfVaultKind,            SoeDefault},
+    {sfSubscriptionDate,     SoeOptional},
+    {sfRedemptionDate,       SoeOptional},
    // no SharesTotal ever (use MPTIssuance.sfOutstandingAmount)
    // no PermissionedDomainID ever (use MPTIssuance.sfDomainID)
 }))
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -23,9 +23,11 @@ TYPED_SFIELD(sfLEVersion,                UINT8,      6)
 // 8-bit integers (uncommon)
 TYPED_SFIELD(sfTickSize,                 UINT8,     16)
 TYPED_SFIELD(sfUNLModifyDisabling,       UINT8,     17)
-TYPED_SFIELD(sfHookResult,               UINT8,     18)
+// 18 unused
 TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
 TYPED_SFIELD(sfWithdrawalPolicy,         UINT8,     20)
+TYPED_SFIELD(sfContractResult,           UINT8,     21)
+TYPED_SFIELD(sfVaultKind,                UINT8,     22)

 // 16-bit integers (common)
 TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::kSmdNever)
@@ -37,10 +39,7 @@ TYPED_SFIELD(sfDiscountedFee,            UINT16,     6)

 // 16-bit integers (uncommon)
 TYPED_SFIELD(sfVersion,                  UINT16,    16)
-TYPED_SFIELD(sfHookStateChangeCount,     UINT16,    17)
-TYPED_SFIELD(sfHookEmitCount,            UINT16,    18)
-TYPED_SFIELD(sfHookExecutionIndex,       UINT16,    19)
-TYPED_SFIELD(sfHookApiVersion,           UINT16,    20)
+// 17 to 20 unused
 TYPED_SFIELD(sfLedgerFixType,            UINT16,    21)
 TYPED_SFIELD(sfManagementFeeRate,        UINT16,    22) // 1/10 basis points (bips)

@@ -91,9 +90,7 @@ TYPED_SFIELD(sfTicketSequence,           UINT32,    41)
 TYPED_SFIELD(sfNFTokenTaxon,             UINT32,    42)
 TYPED_SFIELD(sfMintedNFTokens,           UINT32,    43)
 TYPED_SFIELD(sfBurnedNFTokens,           UINT32,    44)
-TYPED_SFIELD(sfHookStateCount,           UINT32,    45)
-TYPED_SFIELD(sfEmitGeneration,           UINT32,    46)
-//                                                  47 reserved for Hooks
+// 45 to 47 unused
 TYPED_SFIELD(sfVoteWeight,               UINT32,    48)
 TYPED_SFIELD(sfFirstNFTokenSequence,     UINT32,    50)
 TYPED_SFIELD(sfOracleDocumentID,         UINT32,    51)
@@ -120,6 +117,8 @@ TYPED_SFIELD(sfSponsoringOwnerCount,     UINT32,    71)
 TYPED_SFIELD(sfSponsoringAccountCount,   UINT32,    72)
 TYPED_SFIELD(sfRemainingOwnerCount,      UINT32,    73)
 TYPED_SFIELD(sfSponsorFlags,             UINT32,    74)
+TYPED_SFIELD(sfSubscriptionDate,         UINT32,    75)
+TYPED_SFIELD(sfRedemptionDate,           UINT32,    76)

 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -137,9 +136,7 @@ TYPED_SFIELD(sfNFTokenOfferNode,         UINT64,    12)
 TYPED_SFIELD(sfEmitBurden,               UINT64,    13)

 // 64-bit integers (uncommon)
-TYPED_SFIELD(sfHookOn,                   UINT64,    16)
-TYPED_SFIELD(sfHookInstructionCount,     UINT64,    17)
-TYPED_SFIELD(sfHookReturnCode,           UINT64,    18)
+// 16 to 18 unused
 TYPED_SFIELD(sfReferenceCount,           UINT64,    19)
 TYPED_SFIELD(sfXChainClaimID,            UINT64,    20)
 TYPED_SFIELD(sfXChainAccountCreateCount, UINT64,    21)
@@ -203,10 +200,7 @@ TYPED_SFIELD(sfPreviousPageMin,          UINT256,   26)
 TYPED_SFIELD(sfNextPageMin,              UINT256,   27)
 TYPED_SFIELD(sfNFTokenBuyOffer,          UINT256,   28)
 TYPED_SFIELD(sfNFTokenSellOffer,         UINT256,   29)
-TYPED_SFIELD(sfHookStateKey,             UINT256,   30)
-TYPED_SFIELD(sfHookHash,                 UINT256,   31)
-TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
-TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
+// 30 to 33 unused
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
 TYPED_SFIELD(sfVaultID,                  UINT256,   35,
    SField::kSmdPseudoAccount | SField::kSmdDefault)
@@ -237,7 +231,7 @@ TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::kSmdNeedsAsset
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
 TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSmdNeedsAsset | SField::kSmdDefault)

-// int32
+// 32-bit signed (common)
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
 TYPED_SFIELD(sfRemainingOwnerCountDelta, INT32,      2)

@@ -261,15 +255,13 @@ TYPED_SFIELD(sfMinimumOffer,             AMOUNT,    16)
 TYPED_SFIELD(sfRippleEscrow,             AMOUNT,    17)
 TYPED_SFIELD(sfDeliveredAmount,          AMOUNT,    18)
 TYPED_SFIELD(sfNFTokenBrokerFee,         AMOUNT,    19)
-
-// Reserve 20 & 21 for Hooks.
-
+// 20 to 21 unused
 // currency amount (fees)
 TYPED_SFIELD(sfBaseFeeDrops,             AMOUNT,    22)
 TYPED_SFIELD(sfReserveBaseDrops,         AMOUNT,    23)
 TYPED_SFIELD(sfReserveIncrementDrops,    AMOUNT,    24)

-// currency amount (AMM)
+// currency amount (more)
 TYPED_SFIELD(sfLPTokenOut,               AMOUNT,    25)
 TYPED_SFIELD(sfLPTokenIn,                AMOUNT,    26)
 TYPED_SFIELD(sfEPrice,                   AMOUNT,    27)
@@ -304,10 +296,7 @@ TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::kSmdDefault, SFi
 TYPED_SFIELD(sfUNLModifyValidator,       VL,        19)
 TYPED_SFIELD(sfValidatorToDisable,       VL,        20)
 TYPED_SFIELD(sfValidatorToReEnable,      VL,        21)
-TYPED_SFIELD(sfHookStateData,            VL,        22)
-TYPED_SFIELD(sfHookReturnString,         VL,        23)
-TYPED_SFIELD(sfHookParameterName,        VL,        24)
-TYPED_SFIELD(sfHookParameterValue,       VL,        25)
+// 22 to 25 unused
 TYPED_SFIELD(sfDIDDocument,              VL,        26)
 TYPED_SFIELD(sfData,                     VL,        27)
 TYPED_SFIELD(sfAssetClass,               VL,        28)
@@ -345,7 +334,7 @@ TYPED_SFIELD(sfHolder,                   ACCOUNT,   11)
 TYPED_SFIELD(sfDelegate,                 ACCOUNT,   12)

 // account (uncommon)
-TYPED_SFIELD(sfHookAccount,              ACCOUNT,   16)
+// 16 unused
 TYPED_SFIELD(sfOtherChainSource,         ACCOUNT,   18)
 TYPED_SFIELD(sfOtherChainDestination,    ACCOUNT,   19)
 TYPED_SFIELD(sfAttestationSignerAccount, ACCOUNT,   20)
@@ -398,7 +387,7 @@ UNTYPED_SFIELD(sfMemo,                   OBJECT,    10)
 UNTYPED_SFIELD(sfSignerEntry,            OBJECT,    11)
 UNTYPED_SFIELD(sfNFToken,                OBJECT,    12)
 UNTYPED_SFIELD(sfEmitDetails,            OBJECT,    13)
-UNTYPED_SFIELD(sfHook,                   OBJECT,    14)
+// 14 unused
 UNTYPED_SFIELD(sfPermission,             OBJECT,    15)

 // inner object (uncommon)
@@ -406,11 +395,7 @@ UNTYPED_SFIELD(sfSigner,                 OBJECT,    16)
 //                                                  17 unused
 UNTYPED_SFIELD(sfMajority,               OBJECT,    18)
 UNTYPED_SFIELD(sfDisabledValidator,      OBJECT,    19)
-UNTYPED_SFIELD(sfEmittedTxn,             OBJECT,    20)
-UNTYPED_SFIELD(sfHookExecution,          OBJECT,    21)
-UNTYPED_SFIELD(sfHookDefinition,         OBJECT,    22)
-UNTYPED_SFIELD(sfHookParameter,          OBJECT,    23)
-UNTYPED_SFIELD(sfHookGrant,              OBJECT,    24)
+// 20 to 24 unused
 UNTYPED_SFIELD(sfVoteEntry,              OBJECT,    25)
 UNTYPED_SFIELD(sfAuctionSlot,            OBJECT,    26)
 UNTYPED_SFIELD(sfAuthAccount,            OBJECT,    27)
@@ -438,16 +423,14 @@ UNTYPED_SFIELD(sfSufficient,             ARRAY,      7)
 UNTYPED_SFIELD(sfAffectedNodes,          ARRAY,      8)
 UNTYPED_SFIELD(sfMemos,                  ARRAY,      9)
 UNTYPED_SFIELD(sfNFTokens,               ARRAY,     10)
-UNTYPED_SFIELD(sfHooks,                  ARRAY,     11)
+// 11 unused
 UNTYPED_SFIELD(sfVoteSlots,              ARRAY,     12)
 UNTYPED_SFIELD(sfAdditionalBooks,        ARRAY,     13)

 // array of objects (uncommon)
 UNTYPED_SFIELD(sfMajorities,             ARRAY,     16)
 UNTYPED_SFIELD(sfDisabledValidators,     ARRAY,     17)
-UNTYPED_SFIELD(sfHookExecutions,         ARRAY,     18)
-UNTYPED_SFIELD(sfHookParameters,         ARRAY,     19)
-UNTYPED_SFIELD(sfHookGrants,             ARRAY,     20)
+// 18 to 20 unused
 UNTYPED_SFIELD(sfXChainClaimAttestations, ARRAY,    21)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestations, ARRAY, 22)
 //                                                  23 unused
--- a/include/xrpl/protocol/detail/transactions.macro
+++ b/include/xrpl/protocol/detail/transactions.macro
@@ -862,6 +862,9 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
    {sfWithdrawalPolicy, SoeOptional},
    {sfData, SoeOptional},
    {sfScale, SoeOptional},
+    {sfVaultKind, SoeOptional},
+    {sfSubscriptionDate, SoeOptional},
+    {sfRedemptionDate, SoeOptional},
 }))

 /** This transaction updates a single asset vault. */
--- a/include/xrpl/protocol_autogen/ledger_entries/Vault.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Vault.h
@@ -311,6 +311,78 @@ public:
    {
        return this->sle_->isFieldPresent(sfLEVersion);
    }
+
+    /**
+     * @brief Get sfVaultKind (SoeDefault)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getVaultKind() const
+    {
+        if (hasVaultKind())
+            return this->sle_->at(sfVaultKind);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfVaultKind is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasVaultKind() const
+    {
+        return this->sle_->isFieldPresent(sfVaultKind);
+    }
+
+    /**
+     * @brief Get sfSubscriptionDate (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSubscriptionDate() const
+    {
+        if (hasSubscriptionDate())
+            return this->sle_->at(sfSubscriptionDate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSubscriptionDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSubscriptionDate() const
+    {
+        return this->sle_->isFieldPresent(sfSubscriptionDate);
+    }
+
+    /**
+     * @brief Get sfRedemptionDate (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getRedemptionDate() const
+    {
+        if (hasRedemptionDate())
+            return this->sle_->at(sfRedemptionDate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfRedemptionDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasRedemptionDate() const
+    {
+        return this->sle_->isFieldPresent(sfRedemptionDate);
+    }
 };

 /**
@@ -543,6 +615,39 @@ public:
        return *this;
    }

+    /**
+     * @brief Set sfVaultKind (SoeDefault)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setVaultKind(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfVaultKind] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSubscriptionDate (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setSubscriptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSubscriptionDate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfRedemptionDate (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setRedemptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfRedemptionDate] = value;
+        return *this;
+    }
+
    /**
     * @brief Build and return the completed Vault wrapper.
     * @param index The ledger entry index.
--- a/include/xrpl/protocol_autogen/transactions/VaultCreate.h
+++ b/include/xrpl/protocol_autogen/transactions/VaultCreate.h
@@ -214,6 +214,84 @@ public:
    {
        return this->tx_->isFieldPresent(sfScale);
    }
+
+    /**
+     * @brief Get sfVaultKind (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getVaultKind() const
+    {
+        if (hasVaultKind())
+        {
+            return this->tx_->at(sfVaultKind);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfVaultKind is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasVaultKind() const
+    {
+        return this->tx_->isFieldPresent(sfVaultKind);
+    }
+
+    /**
+     * @brief Get sfSubscriptionDate (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSubscriptionDate() const
+    {
+        if (hasSubscriptionDate())
+        {
+            return this->tx_->at(sfSubscriptionDate);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSubscriptionDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSubscriptionDate() const
+    {
+        return this->tx_->isFieldPresent(sfSubscriptionDate);
+    }
+
+    /**
+     * @brief Get sfRedemptionDate (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getRedemptionDate() const
+    {
+        if (hasRedemptionDate())
+        {
+            return this->tx_->at(sfRedemptionDate);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfRedemptionDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasRedemptionDate() const
+    {
+        return this->tx_->isFieldPresent(sfRedemptionDate);
+    }
 };

 /**
@@ -338,6 +416,39 @@ public:
        return *this;
    }

+    /**
+     * @brief Set sfVaultKind (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultCreateBuilder&
+    setVaultKind(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfVaultKind] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSubscriptionDate (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultCreateBuilder&
+    setSubscriptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSubscriptionDate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfRedemptionDate (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultCreateBuilder&
+    setRedemptionDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfRedemptionDate] = value;
+        return *this;
+    }
+
    /**
     * @brief Build and return the VaultCreate wrapper.
     * @param publicKey The public key for signing.
--- a/include/xrpl/rdb/DatabaseCon.h
+++ b/include/xrpl/rdb/DatabaseCon.h
@@ -6,13 +6,12 @@
 #include <xrpl/core/StartUpType.h>
 #include <xrpl/rdb/SociDB.h>

-#include <boost/filesystem/path.hpp>
-
 #include <soci/statement.h>

 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <filesystem>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -80,7 +79,7 @@ public:

        StartUpType startUp = StartUpType::Normal;
        bool standAlone = false;
-        boost::filesystem::path dataDir;
+        std::filesystem::path dataDir;
        // Indicates whether or not to return the `globalPragma`
        // from commonPragma()
        bool useGlobalPragma = false;
@@ -143,7 +142,7 @@ public:

    template <std::size_t N, std::size_t M>
    DatabaseCon(
-        boost::filesystem::path const& dataDir,
+        std::filesystem::path const& dataDir,
        std::string const& dbName,
        std::array<std::string, N> const& pragma,
        std::array<char const*, M> const& initSQL,
@@ -155,7 +154,7 @@ public:
    // Use this constructor to setup checkpointing
    template <std::size_t N, std::size_t M>
    DatabaseCon(
-        boost::filesystem::path const& dataDir,
+        std::filesystem::path const& dataDir,
        std::string const& dbName,
        std::array<std::string, N> const& pragma,
        std::array<char const*, M> const& initSQL,
@@ -190,7 +189,7 @@ private:

    template <std::size_t N, std::size_t M>
    DatabaseCon(
-        boost::filesystem::path const& pPath,
+        std::filesystem::path const& pPath,
        std::vector<std::string> const* commonPragma,
        std::array<std::string, N> const& pragma,
        std::array<char const*, M> const& initSQL,
--- a/include/xrpl/rdb/RelationalDatabase.h
+++ b/include/xrpl/rdb/RelationalDatabase.h
@@ -14,7 +14,6 @@
 #include <xrpl/protocol/TxMeta.h>
 #include <xrpl/protocol/TxSearched.h>

-#include <boost/filesystem.hpp>
 #include <boost/variant.hpp>

 #include <concepts>
--- a/include/xrpl/server/Manifest.h
+++ b/include/xrpl/server/Manifest.h
@@ -306,12 +306,6 @@ operator==(Manifest const& lhs, Manifest const& rhs)
        lhs.serialized == rhs.serialized;
 }

-inline bool
-operator!=(Manifest const& lhs, Manifest const& rhs)
-{
-    return !(lhs == rhs);
-}
-
 struct ValidatorToken
 {
    std::string manifest;
--- a/include/xrpl/server/State.h
+++ b/include/xrpl/server/State.h
@@ -4,8 +4,6 @@
 #include <xrpl/rdb/DatabaseCon.h>
 #include <xrpl/rdb/SociDB.h>

-#include <boost/filesystem.hpp>
-
 #include <string>

 namespace xrpl {
--- a/include/xrpl/shamap/SHAMap.h
+++ b/include/xrpl/shamap/SHAMap.h
@@ -789,12 +789,6 @@ operator==(SHAMap::ConstIterator const& x, SHAMap::ConstIterator const& y)
    return x.item_ == y.item_;
 }

-inline bool
-operator!=(SHAMap::ConstIterator const& x, SHAMap::ConstIterator const& y)
-{
-    return !(x == y);
-}
-
 inline SHAMap::ConstIterator
 SHAMap::begin() const
 {
--- a/include/xrpl/shamap/SHAMapNodeID.h
+++ b/include/xrpl/shamap/SHAMapNodeID.h
@@ -3,6 +3,7 @@
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/basics/base_uint.h>

+#include <compare>
 #include <cstddef>
 #include <optional>
 #include <ostream>
@@ -65,45 +66,32 @@ public:
    static SHAMapNodeID
    createID(int depth, uint256 const& key);

-    // FIXME-C++20: use spaceship and operator synthesis
    /**
     * Comparison operators
+     *
+     * <, >, <= and >= are synthesized from the spaceship. It is written out
+     * rather than defaulted because the ordering is by depth first, and the
+     * members are not declared in that order.
     */
-    bool
-    operator<(SHAMapNodeID const& n) const
+    std::strong_ordering
+    operator<=>(SHAMapNodeID const& n) const
    {
-        return std::tie(depth_, id_) < std::tie(n.depth_, n.id_);
-    }
-
-    bool
-    operator>(SHAMapNodeID const& n) const
-    {
-        return n < *this;
-    }
-
-    bool
-    operator<=(SHAMapNodeID const& n) const
-    {
-        return !(n < *this);
-    }
-
-    bool
-    operator>=(SHAMapNodeID const& n) const
-    {
-        return !(*this < n);
+        return std::tie(depth_, id_) <=> std::tie(n.depth_, n.id_);
    }

+    /**
+     * Equality, which the spaceship above does not provide.
+     *
+     * Only a *defaulted* operator<=> implicitly declares a defaulted
+     * operator==; the one above is user-provided, so == has to be written.
+     * It cannot be defaulted either, because a defaulted == would also compare
+     * the CountedObject base, which is not equality comparable.
+     */
    bool
    operator==(SHAMapNodeID const& n) const
    {
        return (depth_ == n.depth_) && (id_ == n.id_);
    }
-
-    bool
-    operator!=(SHAMapNodeID const& n) const
-    {
-        return !(*this == n);
-    }
 };

 inline std::string
--- a/include/xrpl/tx/invariants/FreezeInvariant.h
+++ b/include/xrpl/tx/invariants/FreezeInvariant.h
@@ -69,7 +69,8 @@ private:
        IssuerChanges const& changes,
        STTx const& tx,
        beast::Journal const& j,
-        bool enforce);
+        bool enforce,
+        bool fixOverrideFreeze);

    static bool
    validateFrozenState(
@@ -78,7 +79,8 @@ private:
        STTx const& tx,
        beast::Journal const& j,
        bool enforce,
-        bool globalFreeze);
+        bool globalFreeze,
+        bool fixOverrideFreeze);
 };

 }  // namespace xrpl
--- a/include/xrpl/tx/invariants/InvariantCheck.h
+++ b/include/xrpl/tx/invariants/InvariantCheck.h
@@ -198,7 +198,7 @@ public:

 /**
 * @brief Invariant: An account XRP balance must be in XRP and take a value
- *                   between 0 and INITIAL_XRP drops, inclusive.
+ *                   between 0 and kInitialXRP drops, inclusive.
 *
 * We iterate all account roots modified by the transaction and ensure that
 * their XRP balances are reasonable.
@@ -290,7 +290,7 @@ public:

 /**
 * @brief Invariant: an escrow entry must take a value between 0 and
- *                   INITIAL_XRP drops exclusive.
+ *                   kInitialXRP drops exclusive.
 */
 class NoZeroEscrow
 {
--- a/include/xrpl/tx/invariants/LoanInvariant.h
+++ b/include/xrpl/tx/invariants/LoanInvariant.h
@@ -16,6 +16,8 @@ namespace xrpl {
 * @brief Invariants: Loans are internally consistent
 *
 * 1. If `Loan.PaymentRemaining = 0` then `Loan.PrincipalOutstanding = 0`
+ * 2. A newly-created Loan against a closed-ended vault must satisfy
+ *    `StartDate + PaymentInterval * PaymentRemaining < Vault.RedemptionDate`.
 *
 */
 class ValidLoan
--- a/include/xrpl/tx/invariants/VaultInvariant.h
+++ b/include/xrpl/tx/invariants/VaultInvariant.h
@@ -38,7 +38,17 @@ namespace xrpl {
 * - vault set must not alter the vault assets or shares balance
 * - no vault transaction can change loss unrealized (it's updated by loan
 *   transactions)
+ * - a created closed-ended vault must satisfy
+ *   MIN_INVESTMENT_PERIOD <= RedemptionDate - SubscriptionDate <
+ *   MAX_INVESTMENT_PERIOD
+ * - vault deposit may only succeed when the vault phase is NoPhase or
+ *   Subscription
+ * - vault withdrawal may not succeed when the vault phase is Investment
+ * - closed-ended loan origination (ttLOAN_SET) may only succeed when the
+ *   vault phase is Investment
 *
+ * Immutability of VaultKind, SubscriptionDate and RedemptionDate is enforced
+ * by NoModifiedUnmodifiableFields (see InvariantCheck.cpp).
 */
 class ValidVault
 {
@@ -55,6 +65,9 @@ class ValidVault
        Number assetsAvailable = 0;
        Number assetsMaximum = 0;
        Number lossUnrealized = 0;
+        std::optional<std::uint8_t> vaultKind;
+        std::optional<std::uint32_t> subscriptionDate;
+        std::optional<std::uint32_t> redemptionDate;

        Vault static make(SLE const&);
    };
@@ -153,6 +166,17 @@ private:
    [[nodiscard]] static bool
    isVaultEmpty(Vault const& vault);

+    /**
+     * @brief Invariant check for @c ttLOAN_SET.
+     *
+     * For a closed-ended vault, a loan may only be originated while the vault is in the Investment
+     * phase (strictly past @c SubscriptionDate and before @c RedemptionDate). Open-ended vaults (@c
+     * NoPhase) are unaffected. The complementary maturity bound (final payment strictly precedes @c
+     * RedemptionDate) is enforced by @c ValidLoan.
+     */
+    [[nodiscard]] bool
+    finalizeLoanSet(ReadView const& view, beast::Journal const& j) const;
+
 public:
    // Compute the coarsest scale required to represent all numbers
    [[nodiscard]] static std::int32_t
--- a/include/xrpl/tx/paths/detail/Steps.h
+++ b/include/xrpl/tx/paths/detail/Steps.h
@@ -274,19 +274,6 @@ public:
        return lhs.equal(rhs);
    }

-    /**
-     * Return true if lhs != rhs.
-     *
-     * @param lhs Step to compare.
-     * @param rhs Step to compare.
-     * @return true if lhs != rhs.
-     */
-    friend bool
-    operator!=(Step const& lhs, Step const& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
    /**
     * Streaming operator for a Step.
     */
--- a/include/xrpl/tx/paths/detail/StrandFlow.h
+++ b/include/xrpl/tx/paths/detail/StrandFlow.h
@@ -1,6 +1,7 @@
 #pragma once

 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/Number.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/beast/utility/Zero.h>
@@ -373,7 +374,7 @@ qualityUpperBound(ReadView const& v, Strand const& strand)
 * increases quality of AMM steps, increasing the strand's composite
 * quality as the result.
 */
-template <typename TOutAmt>
+template <StepAmount TOutAmt>
 inline TOutAmt
 limitOut(
    ReadView const& v,
@@ -411,21 +412,29 @@ limitOut(
        auto const out = qf->outFromAvgQ(limitQuality);
        if (!out)
            return remainingOut;
-        if constexpr (std::is_same_v<TOutAmt, XRPAmount>)
+        if constexpr (std::is_same_v<TOutAmt, XRPAmount> || std::is_same_v<TOutAmt, MPTAmount>)
        {
-            return XRPAmount{*out};
+            auto const roundedOut = TOutAmt{*out};
+            // Integral outputs that round above the continuous target can
+            // realize worse average quality than the requested limit. Keep the
+            // default rounded value when it still satisfies the limit, since it
+            // is the largest matching offer; otherwise round down.
+            if (v.rules().enabled(featureMPTokensV2) && roundedOut > *out &&
+                !qf->satisfiesAvgQ(limitQuality, roundedOut))
+            {
+                NumberRoundModeGuard const g(Number::RoundingMode::Downward);
+                return TOutAmt{*out};
+            }
+            return roundedOut;
        }
        else if constexpr (std::is_same_v<TOutAmt, IOUAmount>)
        {
            return IOUAmount{*out};
        }
-        else if constexpr (std::is_same_v<TOutAmt, MPTAmount>)
-        {
-            return MPTAmount{*out};
-        }
        else
        {
-            return STAmount{remainingOut.asset(), out->mantissa(), out->exponent()};
+            static constexpr bool kAlwaysFalse = !std::is_same_v<TOutAmt, TOutAmt>;
+            static_assert(kAlwaysFalse, "Unhandled StepAmount type");
        }
    }();
    // A tiny difference could be due to the round off
--- a/include/xrpl/tx/transactors/dex/AMMWithdraw.h
+++ b/include/xrpl/tx/transactors/dex/AMMWithdraw.h
@@ -118,6 +118,7 @@ public:
        Sandbox& view,
        SLE const& ammSle,
        AccountID const account,
+        std::optional<AccountID> const& clawbackIssuer,
        AccountID const& ammAccount,
        STAmount const& amountBalance,
        STAmount const& amount2Balance,
@@ -138,6 +139,11 @@ public:
     * @param view
     * @param ammSle AMM ledger entry
     * @param ammAccount AMM account
+     * @param clawbackIssuer when set (AMMClawback path), the issuer performing
+     *        the clawback. A recreated MPToken is only auto-authorized when the
+     *        asset's issuer matches this account, so a clawback cannot grant
+     *        authorization on behalf of a different (paired-asset) issuer.
+     * @param account LP account
     * @param amountBalance current LP asset1 balance
     * @param amountWithdraw asset1 withdraw amount
     * @param amount2Withdraw asset2 withdraw amount
@@ -153,6 +159,7 @@ public:
        Sandbox& view,
        SLE const& ammSle,
        AccountID const& ammAccount,
+        std::optional<AccountID> const& clawbackIssuer,
        AccountID const& account,
        STAmount const& amountBalance,
        STAmount const& amountWithdraw,
--- a/nix/devshell.nix
+++ b/nix/devshell.nix
@@ -30,10 +30,29 @@ let
  };
  customGccGcov = if pkgs.stdenv.isLinux then customCompilers.customGcov else plainGcov;

+  # Whole directory: init.sh locates the profiles relative to itself.
+  conanDir = ../conan;
+
+  # Own Conan home, so Nix-built packages never share a cache with a system
+  # Conan. The stamp holds a content-addressed store path, so init.sh re-runs
+  # only when something in conan/ changes.
+  conanHook = ''
+    export CONAN_HOME=~/.conan2-nix
+    _xrpl_conan_stamp="$CONAN_HOME/.xrpld-devshell"
+    if [ "$(cat "$_xrpl_conan_stamp" 2>/dev/null)" != "${conanDir}" ]; then
+      if ${conanDir}/init.sh; then
+        printf '%s' "${conanDir}" >"$_xrpl_conan_stamp"
+      else
+        echo "⚠️ Conan setup failed - run ./conan/init.sh from the repository root to retry."
+      fi
+    fi
+    unset _xrpl_conan_stamp
+  '';
+
  # Shown when entering a *-plain shell. These exist only on Linux (see below),
  # where the stock toolchain diverges from CI.
  plainWarningHook = ''
-    echo "⚠️  WARNING: this is the stock nixpkgs toolchain and does not match CI's glibc. Prefer 'nix develop .#gcc' / '.#clang' unless you need to skip the custom-glibc build."
+    echo "⚠️ WARNING: this is the stock nixpkgs toolchain and does not match CI's glibc. Prefer 'nix develop .#gcc' / '.#clang' unless you need to skip the custom-glibc build."
  '';

  # Tools to expose under version-suffixed names (see mkVersionedToolLinks).
@@ -87,6 +106,7 @@ let
        shellHook = ''
          echo "Welcome to xrpld development shell";
          ${compilerVersionHook}
+          ${conanHook}
          ${warningHook}
        '';
      }
--- a/nix/packages.nix
+++ b/nix/packages.nix
@@ -129,15 +129,6 @@ in
    perl # needed for openssl
    pkg-config
    pre-commit
-    # protoc generates the Go gRPC bindings and embeds its own version string into every committed
-    # .pb.go file. To allow CI to verify those files with a plain `git diff`, we pin the version to
-    # `protobuf_34` rather than the rolling `protobuf` to keep regeneration reproducible across the
-    # Nix frequently changing unstable channel. The protoc-gen-go* plugins have no versioned
-    # attributes in nixpkgs; protoc-gen-go's version is in turn constrained by the go.mod require
-    # on google.golang.org/protobuf.
-    protobuf_34 # provides protoc
-    protoc-gen-go # protoc plugin for the Go message bindings
-    protoc-gen-go-grpc # protoc plugin for the Go gRPC service stubs
    python3
    runClangTidy
    vim
@@ -146,7 +137,6 @@ in
    cargo-audit
    cargo-llvm-cov
    cargo-nextest
-    corrosion
    rustToolchain
  ];
 }
--- a/src/benchmarks/libxrpl/nodestore/Backend.cpp
+++ b/src/benchmarks/libxrpl/nodestore/Backend.cpp
@@ -41,10 +41,11 @@ struct RunState
    release()
    {
        harness.reset();
-        Batch{}.swap(present);
-        Batch{}.swap(recent);
-        std::vector<uint256>{}.swap(missing);
-        std::vector<std::size_t>{}.swap(shuffle);
+        present = Batch{};
+        recent = Batch{};
+        missing = std::vector<uint256>{};
+        shuffle = std::vector<std::size_t>{};
+        avgPayload = 0;
    }
 };

@@ -239,9 +240,13 @@ registerWorkload(BackendConfig const& bc, Workload const& w)
    if (!w.pinToPool)
    {
        auto rs = std::make_shared<RunState>();
-        auto* b = benchmark::RegisterBenchmark(name, makeRunner(w, cfg, rs));
-        b->RangeMultiplier(10)->Range(kPoolSizes.front(), kPoolSizes.back());
-        b->Threads(1)->Threads(4)->Threads(8)->UseRealTime();
+        benchmark::RegisterBenchmark(name, makeRunner(w, cfg, rs))
+            ->RangeMultiplier(10)
+            ->Range(kPoolSizes.front(), kPoolSizes.back())
+            ->Threads(1)
+            ->Threads(4)
+            ->Threads(8)
+            ->UseRealTime();

        return;
    }
--- a/src/benchmarks/libxrpl/nodestore/NodeStoreBench.h
+++ b/src/benchmarks/libxrpl/nodestore/NodeStoreBench.h
@@ -2,10 +2,10 @@

 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/ByteUtilities.h>
+#include <xrpl/basics/FileUtilities.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/utility/temp_dir.h>
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/config/BasicConfig.h>
 #include <xrpl/nodestore/Backend.h>
@@ -227,7 +227,7 @@ sliceFixedBatches(Batch const& pool, std::size_t batchSize)
 */
 struct BackendHarness
 {
-    beast::TempDir tempDir;  ///< Declared first so it is destroyed last
+    TempDir tempDir;  ///< Declared first so it is destroyed last
    DummyScheduler scheduler;
    beast::Journal journal{beast::Journal::getNullSink()};
    std::unique_ptr<Backend> backend;
@@ -257,7 +257,7 @@ struct BackendHarness
 */
 struct DatabaseHarness
 {
-    beast::TempDir tempDir;
+    TempDir tempDir;
    DummyScheduler scheduler;
    beast::Journal journal{beast::Journal::getNullSink()};
    std::unique_ptr<Database> db;
@@ -297,12 +297,11 @@ struct BackendConfig
 inline std::vector<BackendConfig> const&
 backendConfigs()
 {
+    // Use factory settings for each DB
    static std::vector<BackendConfig> const kConfigs = {
        {.name = "nudb", .config = "type=nudb"},
 #if XRPL_ROCKSDB_AVAILABLE
-        {.name = "rocksdb",
-         .config = "type=rocksdb,open_files=2000,filter_bits=12,cache_mb=256,"
-                   "file_size_mb=8,file_size_mult=2"},
+        {.name = "rocksdb", .config = "type=rocksdb"},
 #endif
    };
    return kConfigs;
--- a/src/libxrpl/basics/Archive.cpp
+++ b/src/libxrpl/basics/Archive.cpp
@@ -2,22 +2,20 @@

 #include <xrpl/basics/contract.h>

-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
-
 #include <archive.h>
 #include <archive_entry.h>

 #include <cstddef>
+#include <filesystem>
 #include <memory>
 #include <stdexcept>

 namespace xrpl {

 void
-extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const& dst)
+extractTarLz4(std::filesystem::path const& src, std::filesystem::path const& dst)
 {
-    if (!is_regular_file(src))
+    if (!std::filesystem::is_regular_file(src))
        Throw<std::runtime_error>("Invalid source file");

    using archive_ptr = std::unique_ptr<struct archive, void (*)(struct archive*)>;
--- a/src/libxrpl/basics/FileUtilities.cpp
+++ b/src/libxrpl/basics/FileUtilities.cpp
@@ -1,29 +1,31 @@
 #include <xrpl/basics/FileUtilities.h>

-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
-#include <boost/system/detail/errc.hpp>
-#include <boost/system/detail/error_code.hpp>
-#include <boost/system/errc.hpp>
+#include <xrpl/basics/contract.h>

 #include <cerrno>
 #include <cstddef>
+#include <filesystem>
 #include <fstream>
+#include <iomanip>
 #include <ios>
+#include <iostream>
 #include <iterator>
 #include <optional>
+#include <random>
+#include <sstream>
+#include <stdexcept>
 #include <string>
+#include <system_error>

 namespace xrpl {

 std::string
 getFileContents(
-    boost::system::error_code& ec,
-    boost::filesystem::path const& sourcePath,
+    std::error_code& ec,
+    std::filesystem::path const& sourcePath,
    std::optional<std::size_t> maxSize)
 {
-    using namespace boost::filesystem;
-    using namespace boost::system::errc;
+    using namespace std::filesystem;

    path const fullPath{canonical(sourcePath, ec)};
    if (ec)
@@ -32,15 +34,15 @@ getFileContents(
    if (maxSize && (file_size(fullPath, ec) > *maxSize || ec))
    {
        if (!ec)
-            ec = make_error_code(file_too_large);
+            ec = make_error_code(std::errc::file_too_large);
        return {};
    }

-    std::ifstream fileStream(fullPath.string(), std::ios::in);
+    std::ifstream fileStream(fullPath, std::ios::in);

    if (!fileStream)
    {
-        ec = make_error_code(static_cast<errc_t>(errno));
+        ec.assign(errno, std::generic_category());
        return {};
    }

@@ -49,7 +51,7 @@ getFileContents(

    if (fileStream.bad())
    {
-        ec = make_error_code(static_cast<errc_t>(errno));
+        ec.assign(errno, std::generic_category());
        return {};
    }

@@ -58,18 +60,15 @@ getFileContents(

 void
 writeFileContents(
-    boost::system::error_code& ec,
-    boost::filesystem::path const& destPath,
+    std::error_code& ec,
+    std::filesystem::path const& destPath,
    std::string const& contents)
 {
-    using namespace boost::filesystem;
-    using namespace boost::system::errc;
-
-    std::ofstream fileStream(destPath.string(), std::ios::out | std::ios::trunc);
+    std::ofstream fileStream(destPath, std::ios::out | std::ios::trunc);

    if (!fileStream)
    {
-        ec = make_error_code(static_cast<errc_t>(errno));
+        ec.assign(errno, std::generic_category());
        return;
    }

@@ -77,9 +76,64 @@ writeFileContents(

    if (fileStream.bad())
    {
-        ec = make_error_code(static_cast<errc_t>(errno));
+        ec.assign(errno, std::generic_category());
        return;
    }
 }

+std::filesystem::path
+uniqueRandomPath(
+    std::filesystem::path const& base,
+    std::string const& prefix,
+    std::size_t maxAttempts)
+{
+    std::random_device rd;
+    for (std::size_t attempt = 0; attempt < maxAttempts; ++attempt)
+    {
+        std::ostringstream oss;
+        oss << prefix << std::hex << std::setfill('0') << std::setw(8) << rd() << std::setw(8)
+            << rd();
+        auto candidate = base / oss.str();
+        std::error_code ec;
+        bool const exists = std::filesystem::exists(candidate, ec);
+        if (ec)
+        {
+            Throw<std::runtime_error>(
+                "Unable to check path '" + candidate.string() + "': " + ec.message());
+        }
+        if (!exists)
+            return candidate;
+    }
+    Throw<std::runtime_error>("Unable to generate a unique path under '" + base.string() + "'");
+}
+
+TempDir::TempDir() : path_(uniqueRandomPath(std::filesystem::temp_directory_path()))
+{
+    std::filesystem::create_directory(path_);
+}
+
+TempDir::~TempDir()
+{
+    // use non-throwing calls in the destructor
+    std::error_code ec;
+    std::filesystem::remove_all(path_, ec);
+    if (ec)
+    {
+        std::cerr << "Unable to remove temporary directory '" << path_.string()
+                  << "': " << ec.message() << '\n';
+    }
+}
+
+std::string
+TempDir::path() const
+{
+    return path_.string();
+}
+
+std::string
+TempDir::file(std::string const& name) const
+{
+    return (path_ / name).string();
+}
+
 }  // namespace xrpl
--- a/src/libxrpl/basics/Log.cpp
+++ b/src/libxrpl/basics/Log.cpp
@@ -5,10 +5,10 @@
 #include <xrpl/beast/utility/instrumentation.h>

 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/filesystem/path.hpp>

 #include <chrono>
 #include <cstring>
+#include <filesystem>
 #include <fstream>
 #include <functional>
 #include <iostream>
@@ -54,7 +54,7 @@ Logs::File::isOpen() const noexcept
 }

 bool
-Logs::File::open(boost::filesystem::path const& path)
+Logs::File::open(std::filesystem::path const& path)
 {
    close();

@@ -114,7 +114,7 @@ Logs::Logs(beast::Severity thresh) : thresh_(thresh)  // default severity
 }

 bool
-Logs::open(boost::filesystem::path const& pathToLogFile)
+Logs::open(std::filesystem::path const& pathToLogFile)
 {
    return file_.open(pathToLogFile);
 }
--- a/src/libxrpl/basics/StringUtilities.cpp
+++ b/src/libxrpl/basics/StringUtilities.cpp
@@ -5,15 +5,15 @@
 #include <xrpl/beast/net/IPEndpoint.h>

 #include <boost/algorithm/hex.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/trim.hpp>
 #include <boost/regex/v5/regbase.hpp>
 #include <boost/regex/v5/regex.hpp>
 #include <boost/regex/v5/regex_match.hpp>

+#include <algorithm>
 #include <cstdint>
 #include <iterator>
 #include <optional>
+#include <ranges>
 #include <string>
 #include <string_view>

@@ -67,7 +67,7 @@ parseUrl(ParsedUrl& pUrl, std::string const& strUrl)
    }

    pUrl.scheme = smMatch[1];
-    boost::algorithm::to_lower(pUrl.scheme);
+    pUrl.scheme = toLower(pUrl.scheme);
    pUrl.username = smMatch[2];
    pUrl.password = smMatch[3];
    std::string const domain = smMatch[4];
@@ -93,10 +93,42 @@ parseUrl(ParsedUrl& pUrl, std::string const& strUrl)
    return true;
 }

+namespace {
+
+// Deliberately not std::isspace / std::tolower: those consult the current C
+// locale, so the same input could trim or fold differently depending on
+// process-wide state set by something else entirely. Everything these helpers
+// are used on (config keys and values, URL schemes, hex digests) is ASCII, and
+// the callers want a fixed answer, so spell the ASCII rules out.
+
+constexpr bool
+isAsciiSpace(char c)
+{
+    return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+constexpr char
+toAsciiLower(char c)
+{
+    return (c >= 'A' && c <= 'Z') ? static_cast<char>(c - 'A' + 'a') : c;
+}
+
+}  // namespace
+
 std::string
 trimWhitespace(std::string str)
 {
-    boost::trim(str);
+    auto const end = std::ranges::find_if_not(str | std::views::reverse, isAsciiSpace).base();
+    str.erase(end, str.end());
+    str.erase(str.begin(), std::ranges::find_if_not(str, isAsciiSpace));
+
+    return str;
+}
+
+std::string
+toLower(std::string str)
+{
+    std::ranges::transform(str, str.begin(), toAsciiLower);
    return str;
 }

--- a/src/libxrpl/crypto/RFC1751.cpp
+++ b/src/libxrpl/crypto/RFC1751.cpp
@@ -1,11 +1,11 @@
 #include <xrpl/crypto/RFC1751.h>

+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/beast/utility/instrumentation.h>

 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/constants.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/trim.hpp>
 #include <boost/range/adaptor/copied.hpp>

 #include <cctype>
@@ -397,7 +397,7 @@ RFC1751::getKeyFromEnglish(std::string& strKey, std::string const& strHuman)

    std::string strTrimmed(strHuman);

-    boost::algorithm::trim(strTrimmed);
+    strTrimmed = trimWhitespace(strTrimmed);

    boost::algorithm::split(
        vWords, strTrimmed, boost::algorithm::is_space(), boost::algorithm::token_compress_on);
--- a/src/libxrpl/ledger/View.cpp
+++ b/src/libxrpl/ledger/View.cpp
@@ -45,12 +45,20 @@ namespace xrpl {
 //------------------------------------------------------------------------------

 bool
-hasExpired(ReadView const& view, std::optional<std::uint32_t> const& exp)
+hasExpired(
+    ReadView const& view,
+    std::optional<std::uint32_t> const& exp,
+    ExpiryComparison comparison)
 {
    using d = NetClock::duration;
    using tp = NetClock::time_point;

-    return exp && (view.parentCloseTime() >= tp{d{*exp}});
+    if (!exp)
+        return false;
+    auto const boundary = tp{d{*exp}};
+    return comparison == ExpiryComparison::Inclusive  //
+        ? view.parentCloseTime() >= boundary
+        : view.parentCloseTime() > boundary;
 }

 bool
--- a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp
@@ -24,6 +24,7 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/digest.h>

+#include <algorithm>
 #include <cstdint>
 #include <expected>
 #include <limits>
@@ -54,6 +55,9 @@ removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j)
    for (auto const& h : arr)
    {
        // Credentials already checked in preclaim. Look only for expired here.
+        if (view.rules().enabled(fixCleanup3_4_0) && h.isZero())
+            return std::unexpected(tecINTERNAL);  // LCOV_EXCL_LINE
+
        auto const k = keylet::credential(h);
        auto const sleCred = view.peek(k);

@@ -156,7 +160,7 @@ deletePseudoAccountCredentials(
 }

 NotTEC
-checkFields(STTx const& tx, beast::Journal j)
+checkFields(STTx const& tx, Rules const& rules, beast::Journal j)
 {
    if (!tx.isFieldPresent(sfCredentialIDs))
        return tesSUCCESS;
@@ -169,6 +173,13 @@ checkFields(STTx const& tx, beast::Journal j)
        return temMALFORMED;
    }

+    if (rules.enabled(fixCleanup3_4_0) &&
+        std::ranges::any_of(credentials, [](uint256 const& id) { return id.isZero(); }))
+    {
+        JLOG(j.trace()) << "Malformed transaction: zero credential ID.";
+        return temMALFORMED;
+    }
+
    std::unordered_set<uint256> duplicates;
    for (auto const& cred : credentials)
    {
@@ -192,6 +203,14 @@ valid(STTx const& tx, ReadView const& view, AccountID const& src, beast::Journal
    auto const& credIDs(tx.getFieldV256(sfCredentialIDs));
    for (auto const& h : credIDs)
    {
+        if (view.rules().enabled(fixCleanup3_4_0) && h.isZero())
+        {
+            // LCOV_EXCL_START
+            JLOG(j.trace()) << "Zero credential ID.";
+            return tecINTERNAL;
+            // LCOV_EXCL_STOP
+        }
+
        auto const sleCred = view.read(keylet::credential(h));
        if (!sleCred)
        {
@@ -266,6 +285,9 @@ authorizedDepositPreauth(ReadView const& view, STVector256 const& credIDs, Accou
    lifeExtender.reserve(credIDs.size());
    for (auto const& h : credIDs)
    {
+        if (view.rules().enabled(fixCleanup3_4_0) && h.isZero())
+            return tefINTERNAL;  // LCOV_EXCL_LINE
+
        auto sleCred = view.read(keylet::credential(h));
        if (!sleCred)            // already checked in preclaim
            return tefINTERNAL;  // LCOV_EXCL_LINE
--- a/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/MPTokenHelpers.cpp
@@ -952,6 +952,7 @@ checkCreateMPT(
    xrpl::MPTIssue const& mptIssue,
    xrpl::AccountID const& holder,
    SLE::ref sponsorSle,
+    std::uint32_t flags,
    beast::Journal j)
 {
    if (mptIssue.getIssuer() == holder)
@@ -961,7 +962,7 @@ checkCreateMPT(
    auto const mptokenID = keylet::mptoken(mptIssuanceID.key, holder);
    if (!view.exists(mptokenID))
    {
-        if (auto const err = createMPToken(view, mptIssue.getMptID(), holder, sponsorSle, 0);
+        if (auto const err = createMPToken(view, mptIssue.getMptID(), holder, sponsorSle, flags);
            !isTesSuccess(err))
        {
            return err;
@@ -977,6 +978,16 @@ checkCreateMPT(
    return tesSUCCESS;
 }

+TER
+checkCreateMPT(
+    xrpl::ApplyView& view,
+    xrpl::MPTIssue const& mptIssue,
+    xrpl::AccountID const& holder,
+    beast::Journal j)
+{
+    return checkCreateMPT(view, mptIssue, holder, {}, 0, j);
+}
+
 std::int64_t
 maxMPTAmount(SLE const& sleIssuance)
 {
--- a/src/libxrpl/ledger/helpers/VaultHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/VaultHelpers.cpp
@@ -3,6 +3,7 @@
 #include <xrpl/basics/Number.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
@@ -11,6 +12,7 @@
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STNumber.h>  // IWYU pragma: keep
+#include <xrpl/protocol/STTx.h>

 #include <cstdint>
 #include <optional>
@@ -157,4 +159,74 @@ getVaultVersion(SLE::const_ref vault)
    return static_cast<VaultVersion>(version);
 }

+namespace {
+
+[[nodiscard]] VaultKind
+decodeVaultKind(std::optional<std::uint8_t> vaultKind)
+{
+    if (vaultKind && *vaultKind == std::to_underlying(VaultKind::ClosedEnded))
+        return VaultKind::ClosedEnded;
+    return VaultKind::OpenEnded;
+}
+
+}  // namespace
+
+[[nodiscard]] VaultKind
+getVaultKind(SLE::const_ref vault)
+{
+    XRPL_ASSERT(vault && vault->getType() == ltVAULT, "xrpl::getVaultKind : valid Vault sle");
+    return decodeVaultKind(vault->at(~sfVaultKind));
+}
+
+[[nodiscard]] VaultKind
+getVaultKind(STTx const& tx)
+{
+    return decodeVaultKind(tx[~sfVaultKind]);
+}
+
+[[nodiscard]] bool
+isValidVaultKind(STTx const& tx)
+{
+    auto const kindField = tx[~sfVaultKind];
+    if (!kindField)
+        return true;
+    return *kindField == std::to_underlying(VaultKind::OpenEnded) ||
+        *kindField == std::to_underlying(VaultKind::ClosedEnded);
+}
+
+[[nodiscard]] bool
+isValidClosedEndedGap(std::uint32_t sub, std::uint32_t red)
+{
+    auto const s = static_cast<std::int64_t>(sub);
+    auto const r = static_cast<std::int64_t>(red);
+    return r >= s + kMinInvestmentPeriod && r < s + kMaxInvestmentPeriod;
+}
+
+[[nodiscard]] VaultPhase
+getVaultPhase(ReadView const& view, SLE::const_ref vault)
+{
+    XRPL_ASSERT(vault && vault->getType() == ltVAULT, "xrpl::getVaultPhase : valid Vault sle");
+    return getVaultPhase(
+        view, (*vault)[~sfVaultKind], (*vault)[~sfSubscriptionDate], (*vault)[~sfRedemptionDate]);
+}
+
+[[nodiscard]] VaultPhase
+getVaultPhase(
+    ReadView const& view,
+    std::optional<std::uint8_t> vaultKind,
+    std::optional<std::uint32_t> subscriptionDate,
+    std::optional<std::uint32_t> redemptionDate)
+{
+    if (!vaultKind || *vaultKind != std::to_underlying(VaultKind::ClosedEnded))
+        return VaultPhase::NoPhase;
+
+    // Subscription includes now == SubscriptionDate; Investment starts
+    // strictly after SubscriptionDate.
+    if (!hasExpired(view, subscriptionDate, ExpiryComparison::Exclusive))
+        return VaultPhase::Subscription;
+    if (!hasExpired(view, redemptionDate))
+        return VaultPhase::Investment;
+    return VaultPhase::Redemption;
+}
+
 }  // namespace xrpl
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -16,8 +16,6 @@
 #include <xrpl/nodestore/detail/EncodedBlob.h>
 #include <xrpl/nodestore/detail/codec.h>

-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
 #include <boost/system/detail/errc.hpp>

 #include <nudb/context.hpp>
@@ -36,12 +34,14 @@
 #include <cstdint>
 #include <cstdio>
 #include <exception>
+#include <filesystem>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <system_error>
 #include <utility>

 namespace xrpl::node_store {
@@ -131,7 +131,7 @@ public:
    void
    open(bool createIfMissing, uint64_t appType, uint64_t uid, uint64_t salt) override
    {
-        using namespace boost::filesystem;
+        using namespace std::filesystem;
        if (db.is_open())
        {
            // LCOV_EXCL_START
@@ -194,11 +194,12 @@ public:

            if (deletePath)
            {
-                boost::filesystem::remove_all(name, ec);
-                if (ec)
+                std::error_code fsec;
+                std::filesystem::remove_all(name, fsec);
+                if (fsec)
                {
-                    JLOG(j.fatal())
-                        << "Filesystem remove_all of " << name << " failed with: " << ec.message();
+                    JLOG(j.fatal()) << "Filesystem remove_all of " << name
+                                    << " failed with: " << fsec.message();
                }
            }
        }
@@ -352,7 +353,7 @@ private:
    static std::size_t
    parseBlockSize(std::string const& name, Section const& keyValues, beast::Journal journal)
    {
-        using namespace boost::filesystem;
+        using namespace std::filesystem;
        auto const folder = path(name);
        auto const kp = (folder / "nudb.key").string();

--- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
@@ -19,9 +19,6 @@
 #include <xrpl/nodestore/detail/DecodedBlob.h>
 #include <xrpl/nodestore/detail/EncodedBlob.h>

-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
-
 #include <rocksdb/advanced_options.h>
 #include <rocksdb/cache.h>
 #include <rocksdb/compression_type.h>
@@ -37,6 +34,7 @@

 #include <atomic>
 #include <cstddef>
+#include <filesystem>
 #include <functional>
 #include <memory>
 #include <stdexcept>
@@ -262,8 +260,8 @@ public:
            db.reset();
            if (deletePath_)
            {
-                boost::filesystem::path const dir = name;
-                boost::filesystem::remove_all(dir);
+                std::filesystem::path const dir = name;
+                std::filesystem::remove_all(dir);
            }
        }
    }
--- a/src/libxrpl/protocol/ConfidentialTransfer.cpp
+++ b/src/libxrpl/protocol/ConfidentialTransfer.cpp
@@ -4,6 +4,7 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
@@ -124,7 +125,12 @@ std::optional<EcPair>
 makeEcPair(Slice const& buffer)
 {
    if (buffer.length() != 2 * kEcCiphertextComponentLength)
-        return std::nullopt;  // LCOV_EXCL_LINE
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::makeEcPair : callers must pre-validate ciphertext length");
+        return std::nullopt;
+        // LCOV_EXCL_STOP
+    }

    auto parsePubKey = [](Slice const& slice, secp256k1_pubkey& out) {
        return secp256k1_ec_pubkey_parse(secp256k1Context(), &out, slice.data(), slice.length());
@@ -266,7 +272,13 @@ std::optional<Buffer>
 encryptCanonicalZeroAmount(Slice const& pubKeySlice, AccountID const& account, MPTID const& mptId)
 {
    if (pubKeySlice.size() != kEcPubKeyLength)
-        return std::nullopt;  // LCOV_EXCL_LINE
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::encryptCanonicalZeroAmount : callers must pre-validate public key length");
+        return std::nullopt;
+        // LCOV_EXCL_STOP
+    }

    EcPair pair{};
    secp256k1_pubkey pubKey;
@@ -274,14 +286,24 @@ encryptCanonicalZeroAmount(Slice const& pubKeySlice, AccountID const& account, M
            secp256k1Context(), &pubKey, pubKeySlice.data(), kEcPubKeyLength);
        res != 1)
    {
-        return std::nullopt;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::encryptCanonicalZeroAmount : public key read from the ledger must already be "
+            "valid");
+        return std::nullopt;
+        // LCOV_EXCL_STOP
    }

    if (auto res = generate_canonical_encrypted_zero(
            secp256k1Context(), &pair.c1, &pair.c2, &pubKey, account.data(), mptId.data());
        res != 1)
    {
-        return std::nullopt;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::encryptCanonicalZeroAmount : canonical zero generation cannot fail for a "
+            "valid public key");
+        return std::nullopt;
+        // LCOV_EXCL_STOP
    }

    return serializeEcPair(pair);
@@ -301,7 +323,11 @@ verifyRevealedAmount(
        issuer.publicKey.size() != kEcPubKeyLength ||
        issuer.encryptedAmount.size() != kEcGamalEncryptedTotalLength)
    {
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::verifyRevealedAmount : callers must pre-validate holder/issuer field lengths");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
    }

    auto const holderP = toParticipant(holder);
@@ -313,7 +339,11 @@ verifyRevealedAmount(
        if (auditor->publicKey.size() != kEcPubKeyLength ||
            auditor->encryptedAmount.size() != kEcGamalEncryptedTotalLength)
        {
-            return tecINTERNAL;  // LCOV_EXCL_LINE
+            // LCOV_EXCL_START
+            UNREACHABLE(
+                "xrpl::verifyRevealedAmount : callers must pre-validate auditor field lengths");
+            return tecINTERNAL;
+            // LCOV_EXCL_STOP
        }
        auditorP = toParticipant(*auditor);
        auditorPtr = &auditorP;
@@ -337,7 +367,12 @@ checkEncryptedAmountFormat(STObject const& object)
    if (!object.isFieldPresent(sfHolderEncryptedAmount) ||
        !object.isFieldPresent(sfIssuerEncryptedAmount))
    {
-        return temMALFORMED;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::checkEncryptedAmountFormat : callers already enforce that these fields are "
+            "present");
+        return temMALFORMED;
+        // LCOV_EXCL_STOP
    }

    if (object[sfHolderEncryptedAmount].length() != kEcGamalEncryptedTotalLength ||
@@ -366,7 +401,12 @@ TER
 verifySchnorrProof(Slice const& pubKeySlice, Slice const& proofSlice, uint256 const& contextHash)
 {
    if (proofSlice.size() != kEcSchnorrProofLength || pubKeySlice.size() != kEcPubKeyLength)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::verifySchnorrProof : callers must pre-validate proof/public key length");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }

    if (mpt_verify_convert_proof(proofSlice.data(), pubKeySlice.data(), contextHash.data()) != 0)
        return tecBAD_PROOF;
@@ -385,7 +425,12 @@ verifyClawbackProof(
    if (ciphertext.size() != kEcGamalEncryptedTotalLength ||
        pubKeySlice.size() != kEcPubKeyLength || proof.size() != kEcClawbackProofLength)
    {
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::verifyClawbackProof : callers must pre-validate ciphertext/public "
+            "key/proof length");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
    }

    if (mpt_verify_clawback_proof(
@@ -420,7 +465,12 @@ verifySendProof(
        amountCommitment.size() != kEcPedersenCommitmentLength ||
        balanceCommitment.size() != kEcPedersenCommitmentLength)
    {
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::verifySendProof : callers must pre-validate proof/participant/commitment "
+            "lengths");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
    }

    std::vector<mpt_confidential_participant> participants;
@@ -433,12 +483,22 @@ verifySendProof(
        if (auditor->publicKey.size() != kEcPubKeyLength ||
            auditor->encryptedAmount.size() != kEcGamalEncryptedTotalLength)
        {
-            return tecINTERNAL;  // LCOV_EXCL_LINE
+            // LCOV_EXCL_START
+            UNREACHABLE("xrpl::verifySendProof : callers must pre-validate auditor field lengths");
+            return tecINTERNAL;
+            // LCOV_EXCL_STOP
        }
        participants.push_back(toParticipant(*auditor));
    }
    if (participants.size() != recipientCount)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::verifySendProof : participant count must match the requested recipient "
+            "count");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }

    if (mpt_verify_send_proof(
            proof.data(),
@@ -468,7 +528,12 @@ verifyConvertBackProof(
        spendingBalance.size() != kEcGamalEncryptedTotalLength ||
        balanceCommitment.size() != kEcPedersenCommitmentLength)
    {
-        return tecINTERNAL;  // LCOV_EXCL_LINE
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::verifyConvertBackProof : callers must pre-validate proof/public "
+            "key/balance/commitment lengths");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
    }

    if (mpt_verify_convert_back_proof(
--- a/src/libxrpl/protocol/ErrorCodes.cpp
+++ b/src/libxrpl/protocol/ErrorCodes.cpp
@@ -105,10 +105,9 @@ static constexpr ErrorInfo kUnorderedErrorInfos[]{
 };
 // clang-format on

-// Sort and validate unorderedErrorInfos at compile time.  Should be
-// converted to consteval when get to C++20.
+// Sort and validate unorderedErrorInfos at compile time.
 template <int M, int N>
-constexpr auto
+consteval auto
 sortErrorInfos(ErrorInfo const (&unordered)[N]) -> std::array<ErrorInfo, M>
 {
    std::array<ErrorInfo, M> ret = {};
--- a/src/libxrpl/protocol/InnerObjectFormats.cpp
+++ b/src/libxrpl/protocol/InnerObjectFormats.cpp
@@ -137,9 +137,9 @@ InnerObjectFormats::InnerObjectFormats()
            {sfCredentialType, SoeRequired},
        });

-    add(sfPermission.jsonName.cStr(), sfPermission.getCode(), {{sfPermissionValue, SoeRequired}});
+    add(sfPermission.jsonName, sfPermission.getCode(), {{sfPermissionValue, SoeRequired}});

-    add(sfBatchSigner.jsonName.cStr(),
+    add(sfBatchSigner.jsonName,
        sfBatchSigner.getCode(),
        {{sfAccount, SoeRequired},
         {sfSigningPubKey, SoeOptional},
@@ -161,7 +161,7 @@ InnerObjectFormats::InnerObjectFormats()
            {sfSigners, SoeOptional},
        });

-    add(sfSponsorSignature.jsonName.cStr(),
+    add(sfSponsorSignature.jsonName,
        sfSponsorSignature.getCode(),
        {
            {sfSigningPubKey, SoeOptional},
--- a/src/libxrpl/protocol/QualityFunction.cpp
+++ b/src/libxrpl/protocol/QualityFunction.cpp
@@ -38,7 +38,22 @@ QualityFunction::outFromAvgQ(Quality const& quality)
            return std::nullopt;
        return out;
    }
-    return std::nullopt;
+    // The sole caller (StrandFlow::limitOut) only invokes this on a non-const
+    // quality function, so m_ != 0 here, and a real payment/offer never yields
+    // a zero-rate limit quality (it would divide by zero above). This fallback
+    // is therefore unreachable in practice.
+    return std::nullopt;  // LCOV_EXCL_LINE
+}
+
+bool
+QualityFunction::satisfiesAvgQ(Quality const& quality, Number const& out) const
+{
+    // satisfiesAvgQ is only reached from StrandFlow::limitOut *after*
+    // outFromAvgQ returned a value, which requires a non-zero rate. So a
+    // zero-rate quality never reaches here; this guard is defensive.
+    if (quality.rate() == beast::kZero)
+        return false;  // LCOV_EXCL_LINE
+    return m_ * out + b_ >= 1 / quality.rate();
 }

 }  // namespace xrpl
--- a/src/libxrpl/protocol/Rules.cpp
+++ b/src/libxrpl/protocol/Rules.cpp
@@ -193,12 +193,6 @@ Rules::operator==(Rules const& other) const
    return *impl_ == *other.impl_;
 }

-bool
-Rules::operator!=(Rules const& other) const
-{
-    return !(*this == other);
-}
-
 bool
 isFeatureEnabled(uint256 const& feature, bool resultIfNoRules)
 {
--- a/Show More
+++ b/Show More