diff --git a/.clang-tidy b/.clang-tidy
index 5f4187b008..642bcb8a96 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -8,11 +8,14 @@ Checks: "-*,
   bugprone-chained-comparison,
   bugprone-compare-pointer-to-member-virtual-function,
   bugprone-copy-constructor-init,
+  bugprone-crtp-constructor-accessibility,
   bugprone-dangling-handle,
   bugprone-dynamic-static-initializers,
+  bugprone-empty-catch,
   bugprone-fold-init-type,
   bugprone-forward-declaration-namespace,
   bugprone-inaccurate-erase,
+  bugprone-inc-dec-in-conditions,
   bugprone-incorrect-enable-if,
   bugprone-incorrect-roundings,
   bugprone-infinite-loop,
@@ -23,18 +26,24 @@ Checks: "-*,
   bugprone-misplaced-operator-in-strlen-in-alloc,
   bugprone-misplaced-pointer-arithmetic-in-alloc,
   bugprone-misplaced-widening-cast,
+  bugprone-move-forwarding-reference,
   bugprone-multi-level-implicit-pointer-conversion,
   bugprone-multiple-new-in-one-expression,
   bugprone-multiple-statement-macro,
   bugprone-no-escape,
   bugprone-non-zero-enum-to-bool-conversion,
+  bugprone-optional-value-conversion,
   bugprone-parent-virtual-call,
+  bugprone-pointer-arithmetic-on-polymorphic-object,
   bugprone-posix-return,
   bugprone-redundant-branch-condition,
+  bugprone-reserved-identifier,
+  bugprone-return-const-ref-from-parameter,
   bugprone-shared-ptr-array-mismatch,
   bugprone-signal-handler,
   bugprone-signed-char-misuse,
   bugprone-sizeof-container,
+  bugprone-sizeof-expression,
   bugprone-spuriously-wake-up-functions,
   bugprone-standalone-empty,
   bugprone-string-constructor,
@@ -45,19 +54,35 @@ Checks: "-*,
   bugprone-suspicious-include,
   bugprone-suspicious-memory-comparison,
   bugprone-suspicious-memset-usage,
+  bugprone-suspicious-missing-comma,
   bugprone-suspicious-realloc-usage,
   bugprone-suspicious-semicolon,
   bugprone-suspicious-string-compare,
+  bugprone-suspicious-stringview-data-usage,
   bugprone-swapped-arguments,
+  bugprone-switch-missing-default-case,
   bugprone-terminating-continue,
   bugprone-throw-keyword-missing,
+  bugprone-too-small-loop-variable,
+  # bugprone-unchecked-optional-access, # see https://github.com/XRPLF/rippled/pull/6502
   bugprone-undefined-memory-manipulation,
   bugprone-undelegated-constructor,
   bugprone-unhandled-exception-at-new,
+  bugprone-unhandled-self-assignment,
   bugprone-unique-ptr-array-mismatch,
   bugprone-unsafe-functions,
+  bugprone-use-after-move,
+  bugprone-unused-raii,
+  bugprone-unused-return-value,
+  bugprone-unused-local-non-trivial-variable,
   bugprone-virtual-near-miss,
+  cppcoreguidelines-init-variables,
+  cppcoreguidelines-misleading-capture-default-by-value,
   cppcoreguidelines-no-suspend-with-lock,
+  cppcoreguidelines-pro-type-member-init,
+  cppcoreguidelines-pro-type-static-cast-downcast,
+  cppcoreguidelines-rvalue-reference-param-not-moved,
+  cppcoreguidelines-use-default-member-init,
   cppcoreguidelines-virtual-class-destructor,
   hicpp-ignored-remove-result,
   misc-definitions-in-headers,
@@ -67,48 +92,22 @@ Checks: "-*,
   misc-throw-by-value-catch-by-reference,
   misc-unused-alias-decls,
   misc-unused-using-decls,
-  readability-duplicate-include,
-  readability-enum-initial-value,
-  readability-misleading-indentation,
-  readability-non-const-parameter,
-  readability-redundant-declaration,
-  readability-reference-to-constructed-temporary,
   modernize-deprecated-headers,
   modernize-make-shared,
   modernize-make-unique,
   performance-implicit-conversion-in-loop,
   performance-move-constructor-init,
-  performance-trivially-destructible
+  performance-trivially-destructible,
+  readability-duplicate-include,
+  readability-enum-initial-value,
+  readability-misleading-indentation,
+  readability-non-const-parameter,
+  readability-redundant-declaration,
+  readability-reference-to-constructed-temporary
   "
 # ---
 # checks that have some issues that need to be resolved:
 #
-# bugprone-empty-catch,
-# bugprone-crtp-constructor-accessibility,
-# bugprone-inc-dec-in-conditions,
-# bugprone-reserved-identifier,
-# bugprone-move-forwarding-reference,
-# bugprone-unused-local-non-trivial-variable,
-# bugprone-return-const-ref-from-parameter,
-# bugprone-switch-missing-default-case,
-# bugprone-sizeof-expression,
-# bugprone-suspicious-stringview-data-usage,
-# bugprone-suspicious-missing-comma,
-# bugprone-pointer-arithmetic-on-polymorphic-object,
-# bugprone-optional-value-conversion,
-# bugprone-too-small-loop-variable,
-# bugprone-unused-return-value,
-# bugprone-use-after-move,
-# bugprone-unhandled-self-assignment,
-# bugprone-unused-raii,
-#
-# cppcoreguidelines-misleading-capture-default-by-value,
-# cppcoreguidelines-init-variables,
-# cppcoreguidelines-pro-type-member-init,
-# cppcoreguidelines-pro-type-static-cast-downcast,
-# cppcoreguidelines-use-default-member-init,
-# cppcoreguidelines-rvalue-reference-param-not-moved,
-#
 # llvm-namespace-comment,
 # misc-const-correctness,
 # misc-include-cleaner,
@@ -193,7 +192,7 @@ CheckOptions:
   #   readability-identifier-naming.PublicMemberSuffix: ""
   #   readability-identifier-naming.FunctionIgnoredRegexp: ".*tag_invoke.*"
   bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
-#   bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
+  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
 #   misc-include-cleaner.IgnoreHeaders: '.*/(detail|impl)/.*;.*(expected|unexpected).*;.*ranges_lower_bound\.h;time.h;stdlib.h;__chrono/.*;fmt/chrono.h;boost/uuid/uuid_hash.hpp'
 #
 # HeaderFilterRegex: '^.*/(src|tests)/.*\.(h|hpp)$'
diff --git a/.cmake-format.yaml b/.cmake-format.yaml
deleted file mode 100644
index 40c1101208..0000000000
--- a/.cmake-format.yaml
+++ /dev/null
@@ -1,247 +0,0 @@
-_help_parse: Options affecting listfile parsing
-parse:
-  _help_additional_commands:
-    - Specify structure for custom cmake functions
-  additional_commands:
-    target_protobuf_sources:
-      pargs:
-        - target
-        - prefix
-      kwargs:
-        PROTOS: "*"
-        LANGUAGE: cpp
-        IMPORT_DIRS: "*"
-        GENERATE_EXTENSIONS: "*"
-        PLUGIN: "*"
-  _help_override_spec:
-    - Override configurations per-command where available
-  override_spec: {}
-  _help_vartags:
-    - Specify variable tags.
-  vartags: []
-  _help_proptags:
-    - Specify property tags.
-  proptags: []
-_help_format: Options affecting formatting.
-format:
-  _help_disable:
-    - Disable formatting entirely, making cmake-format a no-op
-  disable: false
-  _help_line_width:
-    - How wide to allow formatted cmake files
-  line_width: 100
-  _help_tab_size:
-    - How many spaces to tab for indent
-  tab_size: 4
-  _help_use_tabchars:
-    - If true, lines are indented using tab characters (utf-8
-    - 0x09) instead of <tab_size> space characters (utf-8 0x20).
-    - In cases where the layout would require a fractional tab
-    - character, the behavior of the  fractional indentation is
-    - governed by <fractional_tab_policy>
-  use_tabchars: false
-  _help_fractional_tab_policy:
-    - If <use_tabchars> is True, then the value of this variable
-    - indicates how fractional indentions are handled during
-    - whitespace replacement. If set to 'use-space', fractional
-    - indentation is left as spaces (utf-8 0x20). If set to
-    - "`round-up` fractional indentation is replaced with a single"
-    - tab character (utf-8 0x09) effectively shifting the column
-    - to the next tabstop
-  fractional_tab_policy: use-space
-  _help_max_subgroups_hwrap:
-    - If an argument group contains more than this many sub-groups
-    - (parg or kwarg groups) then force it to a vertical layout.
-  max_subgroups_hwrap: 4
-  _help_max_pargs_hwrap:
-    - If a positional argument group contains more than this many
-    - arguments, then force it to a vertical layout.
-  max_pargs_hwrap: 5
-  _help_max_rows_cmdline:
-    - If a cmdline positional group consumes more than this many
-    - lines without nesting, then invalidate the layout (and nest)
-  max_rows_cmdline: 2
-  _help_separate_ctrl_name_with_space:
-    - If true, separate flow control names from their parentheses
-    - with a space
-  separate_ctrl_name_with_space: true
-  _help_separate_fn_name_with_space:
-    - If true, separate function names from parentheses with a
-    - space
-  separate_fn_name_with_space: false
-  _help_dangle_parens:
-    - If a statement is wrapped to more than one line, than dangle
-    - the closing parenthesis on its own line.
-  dangle_parens: false
-  _help_dangle_align:
-    - If the trailing parenthesis must be 'dangled' on its on
-    - "line, then align it to this reference: `prefix`: the start"
-    - "of the statement, `prefix-indent`: the start of the"
-    - "statement, plus one indentation level, `child`: align to"
-    - the column of the arguments
-  dangle_align: prefix
-  _help_min_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is smaller than this amount, then force reject
-    - nested layouts.
-  min_prefix_chars: 18
-  _help_max_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is larger than the tab width by more than this
-    - amount, then force reject un-nested layouts.
-  max_prefix_chars: 10
-  _help_max_lines_hwrap:
-    - If a candidate layout is wrapped horizontally but it exceeds
-    - this many lines, then reject the layout.
-  max_lines_hwrap: 2
-  _help_line_ending:
-    - What style line endings to use in the output.
-  line_ending: unix
-  _help_command_case:
-    - Format command names consistently as 'lower' or 'upper' case
-  command_case: canonical
-  _help_keyword_case:
-    - Format keywords consistently as 'lower' or 'upper' case
-  keyword_case: unchanged
-  _help_always_wrap:
-    - A list of command names which should always be wrapped
-  always_wrap: []
-  _help_enable_sort:
-    - If true, the argument lists which are known to be sortable
-    - will be sorted lexicographicall
-  enable_sort: true
-  _help_autosort:
-    - If true, the parsers may infer whether or not an argument
-    - list is sortable (without annotation).
-  autosort: true
-  _help_require_valid_layout:
-    - By default, if cmake-format cannot successfully fit
-    - everything into the desired linewidth it will apply the
-    - last, most aggressive attempt that it made. If this flag is
-    - True, however, cmake-format will print error, exit with non-
-    - zero status code, and write-out nothing
-  require_valid_layout: false
-  _help_layout_passes:
-    - A dictionary mapping layout nodes to a list of wrap
-    - decisions. See the documentation for more information.
-  layout_passes: {}
-_help_markup: Options affecting comment reflow and formatting.
-markup:
-  _help_bullet_char:
-    - What character to use for bulleted lists
-  bullet_char: "-"
-  _help_enum_char:
-    - What character to use as punctuation after numerals in an
-    - enumerated list
-  enum_char: .
-  _help_first_comment_is_literal:
-    - If comment markup is enabled, don't reflow the first comment
-    - block in each listfile. Use this to preserve formatting of
-    - your copyright/license statements.
-  first_comment_is_literal: false
-  _help_literal_comment_pattern:
-    - If comment markup is enabled, don't reflow any comment block
-    - which matches this (regex) pattern. Default is `None`
-    - (disabled).
-  literal_comment_pattern: null
-  _help_fence_pattern:
-    - Regular expression to match preformat fences in comments
-    - default= ``r'^\s*([`~]{3}[`~]*)(.*)$'``
-  fence_pattern: ^\s*([`~]{3}[`~]*)(.*)$
-  _help_ruler_pattern:
-    - Regular expression to match rulers in comments default=
-    - '``r''^\s*[^\w\s]{3}.*[^\w\s]{3}$''``'
-  ruler_pattern: ^\s*[^\w\s]{3}.*[^\w\s]{3}$
-  _help_explicit_trailing_pattern:
-    - If a comment line matches starts with this pattern then it
-    - is explicitly a trailing comment for the preceding
-    - argument. Default is '#<'
-  explicit_trailing_pattern: "#<"
-  _help_hashruler_min_length:
-    - If a comment line starts with at least this many consecutive
-    - hash characters, then don't lstrip() them off. This allows
-    - for lazy hash rulers where the first hash char is not
-    - separated by space
-  hashruler_min_length: 10
-  _help_canonicalize_hashrulers:
-    - If true, then insert a space between the first hash char and
-    - remaining hash chars in a hash ruler, and normalize its
-    - length to fill the column
-  canonicalize_hashrulers: true
-  _help_enable_markup:
-    - enable comment markup parsing and reflow
-  enable_markup: false
-_help_lint: Options affecting the linter
-lint:
-  _help_disabled_codes:
-    - a list of lint codes to disable
-  disabled_codes: []
-  _help_function_pattern:
-    - regular expression pattern describing valid function names
-  function_pattern: "[0-9a-z_]+"
-  _help_macro_pattern:
-    - regular expression pattern describing valid macro names
-  macro_pattern: "[0-9A-Z_]+"
-  _help_global_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global (cache) scope
-  global_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_internal_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global scope (but internal semantic)
-  internal_var_pattern: _[A-Z][0-9A-Z_]+
-  _help_local_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with local scope
-  local_var_pattern: "[a-z][a-z0-9_]+"
-  _help_private_var_pattern:
-    - regular expression pattern describing valid names for
-    - privatedirectory variables
-  private_var_pattern: _[0-9a-z_]+
-  _help_public_var_pattern:
-    - regular expression pattern describing valid names for public
-    - directory variables
-  public_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_argument_var_pattern:
-    - regular expression pattern describing valid names for
-    - function/macro arguments and loop variables.
-  argument_var_pattern: "[a-z][a-z0-9_]+"
-  _help_keyword_pattern:
-    - regular expression pattern describing valid names for
-    - keywords used in functions or macros
-  keyword_pattern: "[A-Z][0-9A-Z_]+"
-  _help_max_conditionals_custom_parser:
-    - In the heuristic for C0201, how many conditionals to match
-    - within a loop in before considering the loop a parser.
-  max_conditionals_custom_parser: 2
-  _help_min_statement_spacing:
-    - Require at least this many newlines between statements
-  min_statement_spacing: 1
-  _help_max_statement_spacing:
-    - Require no more than this many newlines between statements
-  max_statement_spacing: 2
-  max_returns: 6
-  max_branches: 12
-  max_arguments: 5
-  max_localvars: 15
-  max_statements: 50
-_help_encode: Options affecting file encoding
-encode:
-  _help_emit_byteorder_mark:
-    - If true, emit the unicode byte-order mark (BOM) at the start
-    - of the file
-  emit_byteorder_mark: false
-  _help_input_encoding:
-    - Specify the encoding of the input file. Defaults to utf-8
-  input_encoding: utf-8
-  _help_output_encoding:
-    - Specify the encoding of the output file. Defaults to utf-8.
-    - Note that cmake only claims to support utf-8 so be careful
-    - when using anything else
-  output_encoding: utf-8
-_help_misc: Miscellaneous configurations options.
-misc:
-  _help_per_command:
-    - A dictionary containing any per-command configuration
-    - overrides. Currently only `command_case` is supported.
-  per_command: {}
diff --git a/.gersemi/definitions.cmake b/.gersemi/definitions.cmake
new file mode 100644
index 0000000000..13061629a4
--- /dev/null
+++ b/.gersemi/definitions.cmake
@@ -0,0 +1,98 @@
+# Custom CMake command definitions for gersemi formatting.
+# These stubs teach gersemi the signatures of project-specific commands
+# so it can format their invocations correctly.
+
+function(git_branch branch_val)
+endfunction()
+
+function(isolate_headers target A B scope)
+endfunction()
+
+function(create_symbolic_link target link)
+endfunction()
+
+function(xrpl_add_test name)
+endfunction()
+
+macro(exclude_from_default target_)
+endmacro()
+
+macro(exclude_if_included target_)
+endmacro()
+
+function(target_protobuf_sources target prefix)
+    set(options APPEND_PATH DESCRIPTORS)
+    set(oneValueArgs
+        LANGUAGE
+        OUT_VAR
+        EXPORT_MACRO
+        TARGET
+        PROTOC_OUT_DIR
+        PLUGIN
+        PLUGIN_OPTIONS
+        PROTOC_EXE
+    )
+    set(multiValueArgs
+        PROTOS
+        IMPORT_DIRS
+        GENERATE_EXTENSIONS
+        PROTOC_OPTIONS
+        DEPENDENCIES
+    )
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_module parent name)
+endfunction()
+
+function(target_link_modules parent scope)
+endfunction()
+
+function(setup_target_for_coverage_gcovr)
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_code_coverage_to_target name scope)
+endfunction()
+
+function(verbose_find_path variable name)
+    set(options
+        NO_CACHE
+        REQUIRED
+        OPTIONAL
+        NO_DEFAULT_PATH
+        NO_PACKAGE_ROOT_PATH
+        NO_CMAKE_PATH
+        NO_CMAKE_ENVIRONMENT_PATH
+        NO_SYSTEM_ENVIRONMENT_PATH
+        NO_CMAKE_SYSTEM_PATH
+        NO_CMAKE_INSTALL_PREFIX
+        CMAKE_FIND_ROOT_PATH_BOTH
+        ONLY_CMAKE_FIND_ROOT_PATH
+        NO_CMAKE_FIND_ROOT_PATH
+    )
+    set(oneValueArgs REGISTRY_VIEW VALIDATOR DOC)
+    set(multiValueArgs NAMES HINTS PATHS PATH_SUFFIXES)
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
diff --git a/.gersemirc b/.gersemirc
new file mode 100644
index 0000000000..5abd52ffd5
--- /dev/null
+++ b/.gersemirc
@@ -0,0 +1 @@
+definitions: [.gersemi]
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 3ab3a38807..f1f7aa18f7 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -29,22 +29,6 @@ If a refactor, how is this better than the previous implementation?
 If there is a spec or design document for this feature, please link it here.
 -->
 
-### Type of Change
-
-<!--
-Please check [x] relevant options, delete irrelevant ones.
--->
-
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] Refactor (non-breaking change that only restructures code)
-- [ ] Performance (increase or change in throughput and/or latency)
-- [ ] Tests (you added tests for code that already exists, or your new feature included in this PR)
-- [ ] Documentation update
-- [ ] Chore (no impact to binary, e.g. `.gitignore`, formatting, dropping support for older tooling)
-- [ ] Release
-
 ### API Impact
 
 <!--
diff --git a/.github/scripts/levelization/README.md b/.github/scripts/levelization/README.md
index c3e6ffa4a8..25eb52f079 100644
--- a/.github/scripts/levelization/README.md
+++ b/.github/scripts/levelization/README.md
@@ -70,7 +70,7 @@ that `test` code should _never_ be included in `xrpl` or `xrpld` code.)
 
 ## Validation
 
-The [levelization](generate.sh) script takes no parameters,
+The [levelization](generate.py) script takes no parameters,
 reads no environment variables, and can be run from any directory,
 as long as it is in the expected location in the rippled repo.
 It can be run at any time from within a checked out repo, and will
@@ -104,7 +104,7 @@ It generates many files of [results](results):
   Github Actions workflow to test that levelization loops haven't
   changed. Unfortunately, if changes are detected, it can't tell if
   they are improvements or not, so if you have resolved any issues or
-  done anything else to improve levelization, run `levelization.sh`,
+  done anything else to improve levelization, run `generate.py`,
   and commit the updated results.
 
 The `loops.txt` and `ordering.txt` files relate the modules
@@ -128,7 +128,7 @@ The committed files hide the detailed values intentionally, to
 prevent false alarms and merging issues, and because it's easy to
 get those details locally.
 
-1. Run `levelization.sh`
+1. Run `generate.py`
 2. Grep the modules in `paths.txt`.
    - For example, if a cycle is found `A ~= B`, simply `grep -w
 A .github/scripts/levelization/results/paths.txt | grep -w B`
diff --git a/.github/scripts/levelization/generate.py b/.github/scripts/levelization/generate.py
new file mode 100644
index 0000000000..635b344d56
--- /dev/null
+++ b/.github/scripts/levelization/generate.py
@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+
+"""
+Usage: generate.py
+This script takes no parameters, and can be called from any directory in the file system.
+"""
+
+import os
+import re
+import subprocess
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Tuple, Set, Optional
+
+# Compile regex patterns once at module level
+INCLUDE_PATTERN = re.compile(r"^\s*#include.*/.*\.h")
+INCLUDE_PATH_PATTERN = re.compile(r'[<"]([^>"]+)[>"]')
+
+
+def dictionary_sort_key(s: str) -> str:
+    """
+    Create a sort key that mimics 'sort -d' (dictionary order).
+    Dictionary order only considers blanks and alphanumeric characters.
+    This means punctuation like '.' is ignored during sorting.
+    """
+    # Keep only alphanumeric characters and spaces
+    return "".join(c for c in s if c.isalnum() or c.isspace())
+
+
+def get_level(file_path: str) -> str:
+    """
+    Extract the level from a file path (second and third directory components).
+    Equivalent to bash: cut -d/ -f 2,3
+
+    Examples:
+        src/xrpld/app/main.cpp -> xrpld.app
+        src/libxrpl/protocol/STObject.cpp -> libxrpl.protocol
+        include/xrpl/basics/base_uint.h -> xrpl.basics
+    """
+    parts = file_path.split("/")
+
+    # Get fields 2 and 3 (indices 1 and 2 in 0-based indexing)
+    if len(parts) >= 3:
+        level = f"{parts[1]}/{parts[2]}"
+    elif len(parts) >= 2:
+        level = f"{parts[1]}/toplevel"
+    else:
+        level = file_path
+
+    # If the "level" indicates a file, cut off the filename
+    if "." in level.split("/")[-1]:  # Avoid Path object creation
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        level = level.rsplit("/", 1)[0] + "/toplevel"
+
+    return level.replace("/", ".")
+
+
+def extract_include_level(include_line: str) -> Optional[str]:
+    """
+    Extract the include path from an #include directive.
+    Gets the first two directory components from the include path.
+    Equivalent to bash: cut -d/ -f 1,2
+
+    Examples:
+        #include <xrpl/basics/base_uint.h> -> xrpl.basics
+        #include "xrpld/app/main/Application.h" -> xrpld.app
+    """
+    # Remove everything before the quote or angle bracket
+    match = INCLUDE_PATH_PATTERN.search(include_line)
+    if not match:
+        return None
+
+    include_path = match.group(1)
+    parts = include_path.split("/")
+
+    # Get first two fields (indices 0 and 1)
+    if len(parts) >= 2:
+        include_level = f"{parts[0]}/{parts[1]}"
+    else:
+        include_level = include_path
+
+    # If the "includelevel" indicates a file, cut off the filename
+    if "." in include_level.split("/")[-1]:  # Avoid Path object creation
+        include_level = include_level.rsplit("/", 1)[0] + "/toplevel"
+
+    return include_level.replace("/", ".")
+
+
+def find_repository_directories(
+    start_path: Path, depth_limit: int = 10
+) -> Tuple[Path, List[Path]]:
+    """
+    Find the repository root by looking for src or include folders.
+    Walks up the directory tree from the start path.
+    """
+    current = start_path.resolve()
+
+    # Walk up the directory tree
+    for _ in range(depth_limit):  # Limit search depth to prevent infinite loops
+        src_path = current / "src"
+        include_path = current / "include"
+        # Check if this directory has src or include folders
+        has_src = src_path.exists()
+        has_include = include_path.exists()
+
+        if has_src or has_include:
+            return current, [src_path, include_path]
+
+        # Move up one level
+        parent = current.parent
+        if parent == current:  # Reached filesystem root
+            break
+        current = parent
+
+    # If we couldn't find it, raise an error
+    raise RuntimeError(
+        "Could not find repository root. "
+        "Expected to find a directory containing 'src' and/or 'include' folders."
+    )
+
+
+def main():
+    # Change to the script's directory
+    script_dir = Path(__file__).parent.resolve()
+    os.chdir(script_dir)
+
+    # Clean up and create results directory.
+    results_dir = script_dir / "results"
+    if results_dir.exists():
+        import shutil
+
+        shutil.rmtree(results_dir)
+    results_dir.mkdir()
+
+    # Find the repository root by searching for src and include directories.
+    try:
+        repo_root, scan_dirs = find_repository_directories(script_dir)
+
+        print(f"Found repository root: {repo_root}")
+        print(f"Scanning directories:")
+        for scan_dir in scan_dirs:
+            print(f"  - {scan_dir.relative_to(repo_root)}")
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("\nScanning for raw includes...")
+    # Find all #include directives
+    raw_includes: List[Tuple[str, str]] = []
+    rawincludes_file = results_dir / "rawincludes.txt"
+
+    # Write to file as we go to avoid storing everything in memory.
+    with open(rawincludes_file, "w", buffering=8192) as raw_f:
+        for dir_path in scan_dirs:
+            print(f"  Scanning {dir_path.relative_to(repo_root)}...")
+
+            for file_path in dir_path.rglob("*"):
+                if not file_path.is_file():
+                    continue
+
+                try:
+                    rel_path_str = str(file_path.relative_to(repo_root))
+
+                    # Read file with a large buffer for performance.
+                    with open(
+                        file_path,
+                        "r",
+                        encoding="utf-8",
+                        errors="ignore",
+                        buffering=8192,
+                    ) as f:
+                        for line in f:
+                            # Quick check before regex
+                            if "#include" not in line or "boost" in line:
+                                continue
+
+                            if INCLUDE_PATTERN.match(line):
+                                line_stripped = line.strip()
+                                entry = f"{rel_path_str}:{line_stripped}\n"
+                                print(entry, end="")
+                                raw_f.write(entry)
+                                raw_includes.append((rel_path_str, line_stripped))
+                except Exception as e:
+                    print(f"Error reading {file_path}: {e}", file=sys.stderr)
+
+    # Build levelization paths and count directly (no need to sort first).
+    print("Build levelization paths")
+    path_counts: Dict[Tuple[str, str], int] = defaultdict(int)
+
+    for file_path, include_line in raw_includes:
+        include_level = extract_include_level(include_line)
+        if not include_level:
+            continue
+
+        level = get_level(file_path)
+        if level != include_level:
+            path_counts[(level, include_level)] += 1
+
+    # Sort and deduplicate paths (using dictionary order like bash 'sort -d').
+    print("Sort and deduplicate paths")
+
+    paths_file = results_dir / "paths.txt"
+    with open(paths_file, "w") as f:
+        # Sort using dictionary order: only alphanumeric and spaces matter
+        sorted_items = sorted(
+            path_counts.items(),
+            key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
+        )
+        for (level, include_level), count in sorted_items:
+            line = f"{count:7} {level} {include_level}\n"
+            print(line.rstrip())
+            f.write(line)
+
+    # Split into flat-file database
+    print("Split into flat-file database")
+    includes_dir = results_dir / "includes"
+    included_by_dir = results_dir / "included_by"
+    includes_dir.mkdir()
+    included_by_dir.mkdir()
+
+    # Batch writes by grouping data first to avoid repeated file opens.
+    includes_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
+    included_by_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
+
+    # Process in sorted order to match bash script behaviour (dictionary order).
+    sorted_items = sorted(
+        path_counts.items(),
+        key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
+    )
+    for (level, include_level), count in sorted_items:
+        includes_data[level].append((include_level, count))
+        included_by_data[include_level].append((level, count))
+
+    # Write all includes files in sorted order (dictionary order).
+    for level in sorted(includes_data.keys(), key=dictionary_sort_key):
+        entries = includes_data[level]
+        with open(includes_dir / level, "w") as f:
+            for include_level, count in entries:
+                line = f"{include_level} {count}\n"
+                print(line.rstrip())
+                f.write(line)
+
+    # Write all included_by files in sorted order (dictionary order).
+    for include_level in sorted(included_by_data.keys(), key=dictionary_sort_key):
+        entries = included_by_data[include_level]
+        with open(included_by_dir / include_level, "w") as f:
+            for level, count in entries:
+                line = f"{level} {count}\n"
+                print(line.rstrip())
+                f.write(line)
+
+    # Search for loops
+    print("Search for loops")
+    loops_file = results_dir / "loops.txt"
+    ordering_file = results_dir / "ordering.txt"
+
+    loops_found: Set[Tuple[str, str]] = set()
+
+    # Pre-load all include files into memory to avoid repeated I/O.
+    # This is the biggest optimisation - we were reading files repeatedly in nested loops.
+    # Use list of tuples to preserve file order.
+    includes_cache: Dict[str, List[Tuple[str, int]]] = {}
+    includes_lookup: Dict[str, Dict[str, int]] = {}  # For fast lookup
+
+    # Note: bash script uses 'for source in *' which uses standard glob sorting,
+    # NOT dictionary order. So we use standard sorted() here, not dictionary_sort_key.
+    for include_file in sorted(includes_dir.iterdir(), key=lambda p: p.name):
+        if not include_file.is_file():
+            continue
+
+        includes_cache[include_file.name] = []
+        includes_lookup[include_file.name] = {}
+        with open(include_file, "r") as f:
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) >= 2:
+                    include_name = parts[0]
+                    include_count = int(parts[1])
+                    includes_cache[include_file.name].append(
+                        (include_name, include_count)
+                    )
+                    includes_lookup[include_file.name][include_name] = include_count
+
+    with open(loops_file, "w", buffering=8192) as loops_f, open(
+        ordering_file, "w", buffering=8192
+    ) as ordering_f:
+
+        # Use standard sorting to match bash glob expansion 'for source in *'.
+        for source in sorted(includes_cache.keys()):
+            source_includes = includes_cache[source]
+
+            for include, include_freq in source_includes:
+                # Check if include file exists and references source
+                if include not in includes_lookup:
+                    continue
+
+                source_freq = includes_lookup[include].get(source)
+
+                if source_freq is not None:
+                    # Found a loop
+                    loop_key = tuple(sorted([source, include]))
+                    if loop_key in loops_found:
+                        continue
+                    loops_found.add(loop_key)
+
+                    loops_f.write(f"Loop: {source} {include}\n")
+
+                    # If the counts are close, indicate that the two modules are
+                    # on the same level, though they shouldn't be.
+                    diff = include_freq - source_freq
+                    if diff > 3:
+                        loops_f.write(f"  {source} > {include}\n\n")
+                    elif diff < -3:
+                        loops_f.write(f"  {include} > {source}\n\n")
+                    elif source_freq == include_freq:
+                        loops_f.write(f"  {include} == {source}\n\n")
+                    else:
+                        loops_f.write(f"  {include} ~= {source}\n\n")
+                else:
+                    ordering_f.write(f"{source} > {include}\n")
+
+    # Print results
+    print("\nOrdering:")
+    with open(ordering_file, "r") as f:
+        print(f.read(), end="")
+
+    print("\nLoops:")
+    with open(loops_file, "r") as f:
+        print(f.read(), end="")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/levelization/generate.sh b/.github/scripts/levelization/generate.sh
deleted file mode 100755
index d700c7a206..0000000000
--- a/.github/scripts/levelization/generate.sh
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/bin/bash
-
-# Usage: generate.sh
-# This script takes no parameters, reads no environment variables,
-# and can be run from any directory, as long as it is in the expected
-# location in the repo.
-
-pushd $( dirname $0 )
-
-if [ -v PS1 ]
-then
-  # if the shell is interactive, clean up any flotsam before analyzing
-  git clean -ix
-fi
-
-# Ensure all sorting is ASCII-order consistently across platforms.
-export LANG=C
-
-rm -rfv results
-mkdir results
-includes="$( pwd )/results/rawincludes.txt"
-pushd ../../..
-echo Raw includes:
-grep -r '^[ ]*#include.*/.*\.h' include src | \
-    grep -v boost | tee ${includes}
-popd
-pushd results
-
-oldifs=${IFS}
-IFS=:
-mkdir includes
-mkdir included_by
-echo Build levelization paths
-exec 3< ${includes} # open rawincludes.txt for input
-while read -r -u 3 file include
-do
-    level=$( echo ${file} | cut -d/ -f 2,3 )
-    # If the "level" indicates a file, cut off the filename
-    if [[ "${level##*.}" != "${level}" ]]
-    then
-        # Use the "toplevel" label as a workaround for `sort`
-        # inconsistencies between different utility versions
-        level="$( dirname ${level} )/toplevel"
-    fi
-    level=$( echo ${level} | tr '/' '.' )
-
-    includelevel=$( echo ${include} | sed 's/.*["<]//; s/[">].*//' | \
-        cut -d/ -f 1,2 )
-    if [[ "${includelevel##*.}" != "${includelevel}" ]]
-    then
-        # Use the "toplevel" label as a workaround for `sort`
-        # inconsistencies between different utility versions
-        includelevel="$( dirname ${includelevel} )/toplevel"
-    fi
-    includelevel=$( echo ${includelevel} | tr '/' '.' )
-
-    if [[ "$level" != "$includelevel" ]]
-    then
-        echo $level $includelevel | tee -a paths.txt
-    fi
-done
-echo Sort and deduplicate paths
-sort -ds paths.txt | uniq -c | tee sortedpaths.txt
-mv sortedpaths.txt paths.txt
-exec 3>&- #close fd 3
-IFS=${oldifs}
-unset oldifs
-
-echo Split into flat-file database
-exec 4<paths.txt # open paths.txt for input
-while read -r -u 4 count level include
-do
-    echo ${include} ${count} | tee -a includes/${level}
-    echo ${level} ${count} | tee -a included_by/${include}
-done
-exec 4>&- #close fd 4
-
-loops="$( pwd )/loops.txt"
-ordering="$( pwd )/ordering.txt"
-pushd includes
-echo Search for loops
-# Redirect stdout to a file
-exec 4>&1
-exec 1>"${loops}"
-for source in *
-do
-  if [[ -f "$source" ]]
-  then
-    exec 5<"${source}" # open for input
-    while read -r -u 5 include includefreq
-    do
-      if [[ -f $include ]]
-      then
-        if grep -q -w $source $include
-        then
-          if grep -q -w "Loop: $include $source" "${loops}"
-          then
-            continue
-          fi
-          sourcefreq=$( grep -w $source $include | cut -d\  -f2 )
-          echo "Loop: $source $include"
-          # If the counts are close, indicate that the two modules are
-          # on the same level, though they shouldn't be
-          if [[ $(( $includefreq - $sourcefreq )) -gt 3 ]]
-          then
-              echo -e "  $source > $include\n"
-          elif [[ $(( $sourcefreq - $includefreq )) -gt 3 ]]
-          then
-              echo -e "  $include > $source\n"
-          elif [[ $sourcefreq -eq $includefreq ]]
-          then
-              echo -e "  $include == $source\n"
-          else
-              echo -e "  $include ~= $source\n"
-          fi
-        else
-          echo "$source > $include" >> "${ordering}"
-        fi
-      fi
-    done
-    exec 5>&- #close fd 5
-  fi
-done
-exec 1>&4 #close fd 1
-exec 4>&- #close fd 4
-cat "${ordering}"
-cat "${loops}"
-popd
-popd
-popd
diff --git a/.github/scripts/levelization/results/ordering.txt b/.github/scripts/levelization/results/ordering.txt
index d4d07eee94..747ea8b6a6 100644
--- a/.github/scripts/levelization/results/ordering.txt
+++ b/.github/scripts/levelization/results/ordering.txt
@@ -134,6 +134,7 @@ test.peerfinder > xrpld.core
 test.peerfinder > xrpld.peerfinder
 test.peerfinder > xrpl.protocol
 test.protocol > test.toplevel
+test.protocol > test.unit_test
 test.protocol > xrpl.basics
 test.protocol > xrpl.json
 test.protocol > xrpl.protocol
@@ -171,6 +172,7 @@ test.shamap > xrpl.shamap
 test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
+test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
 tests.libxrpl > xrpl.json
 tests.libxrpl > xrpl.net
diff --git a/.github/scripts/strategy-matrix/generate.py b/.github/scripts/strategy-matrix/generate.py
index 27eb60c005..532bf2ed57 100755
--- a/.github/scripts/strategy-matrix/generate.py
+++ b/.github/scripts/strategy-matrix/generate.py
@@ -55,7 +55,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
             #   fee to 500.
             # - Bookworm using GCC 15: Debug on linux/amd64, enable code
             #   coverage (which will be done below).
-            # - Bookworm using Clang 16: Debug on linux/arm64, enable voidstar.
+            # - Bookworm using Clang 16: Debug on linux/amd64, enable voidstar.
             # - Bookworm using Clang 17: Release on linux/amd64, set the
             #   reference fee to 1000.
             # - Bookworm using Clang 20: Debug on linux/amd64.
@@ -78,7 +78,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                     if (
                         f"{os['compiler_name']}-{os['compiler_version']}" == "clang-16"
                         and build_type == "Debug"
-                        and architecture["platform"] == "linux/arm64"
+                        and architecture["platform"] == "linux/amd64"
                     ):
                         cmake_args = f"-Dvoidstar=ON {cmake_args}"
                         skip = False
diff --git a/.github/workflows/check-pr-title.yml b/.github/workflows/check-pr-title.yml
new file mode 100644
index 0000000000..a524d759b5
--- /dev/null
+++ b/.github/workflows/check-pr-title.yml
@@ -0,0 +1,13 @@
+name: Check PR title
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types: [opened, edited, reopened, synchronize]
+    branches: [develop]
+
+jobs:
+  check_title:
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@c6311685db43aa07971c4a6764320fecbc2acdcd
diff --git a/.github/workflows/on-pr.yml b/.github/workflows/on-pr.yml
index be6a92eea2..66893d19d3 100644
--- a/.github/workflows/on-pr.yml
+++ b/.github/workflows/on-pr.yml
@@ -46,7 +46,7 @@ jobs:
         # that Github considers any skipped jobs to have passed, and in
         # turn the required checks as well.
         id: changes
-        uses: tj-actions/changed-files@7dee1b0c1557f278e5c7dc244927139d78c0e22a # v47.0.4
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
         with:
           files: |
             # These paths are unique to `on-pr.yml`.
@@ -141,9 +141,8 @@ jobs:
     needs:
       - should-run
       - build-test
-    # Only run when committing to a PR that targets a release branch in the
-    # XRPLF repository.
-    if: ${{ github.repository_owner == 'XRPLF' && needs.should-run.outputs.go == 'true' && startsWith(github.ref, 'refs/heads/release') }}
+    # Only run when committing to a PR that targets a release branch.
+    if: ${{ github.repository == 'XRPLF/rippled' && needs.should-run.outputs.go == 'true' && github.event_name == 'pull_request' && startsWith(github.event.pull_request.base.ref, 'release') }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
       remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
diff --git a/.github/workflows/on-tag.yml b/.github/workflows/on-tag.yml
index c6361b4016..af3ea4309e 100644
--- a/.github/workflows/on-tag.yml
+++ b/.github/workflows/on-tag.yml
@@ -17,8 +17,7 @@ defaults:
 
 jobs:
   upload-recipe:
-    # Only run when a tag is pushed to the XRPLF repository.
-    if: ${{ github.repository_owner == 'XRPLF' }}
+    if: ${{ github.repository == 'XRPLF/rippled' }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
       remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
diff --git a/.github/workflows/on-trigger.yml b/.github/workflows/on-trigger.yml
index c7e0e8c3aa..5856c67bd3 100644
--- a/.github/workflows/on-trigger.yml
+++ b/.github/workflows/on-trigger.yml
@@ -92,8 +92,8 @@ jobs:
 
   upload-recipe:
     needs: build-test
-    # Only run when pushing to the develop branch in the XRPLF repository.
-    if: ${{ github.repository_owner == 'XRPLF' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+    # Only run when pushing to the develop branch.
+    if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
       remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 7793d1e3ab..8600429a6b 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -1,6 +1,9 @@
 name: Run pre-commit hooks
 
 on:
+  merge_group:
+    types:
+      - checks_requested
   pull_request:
   push:
     branches:
@@ -11,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@320be44621ca2a080f05aeb15817c44b84518108
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@44856eb0d6ecb7d376370244324ab3dc8b863bad
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'
diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml
index acde57fd91..d4abd74363 100644
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -40,15 +40,18 @@ env:
   NPROC_SUBTRACT: ${{ github.event.repository.private && '1' || '2' }}
 
 jobs:
-  publish:
+  build:
     runs-on: ubuntu-latest
     container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
-    permissions:
-      contents: write
     steps:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
+
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
         id: nproc
@@ -78,9 +81,23 @@ jobs:
           cmake -Donly_docs=ON ..
           cmake --build . --target docs --parallel ${BUILD_NPROC}
 
-      - name: Publish documentation
+      - name: Create documentation artifact
         if: ${{ github.event_name == 'push' }}
-        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ${{ env.BUILD_DIR }}/docs/html
+          path: ${{ env.BUILD_DIR }}/docs/html
+
+  deploy:
+    if: ${{ github.event_name == 'push' }}
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deploy
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5
diff --git a/.github/workflows/reusable-build-test-config.yml b/.github/workflows/reusable-build-test-config.yml
index 6060a208fe..efec2afe0a 100644
--- a/.github/workflows/reusable-build-test-config.yml
+++ b/.github/workflows/reusable-build-test-config.yml
@@ -76,7 +76,7 @@ jobs:
     name: ${{ inputs.config_name }}
     runs-on: ${{ fromJSON(inputs.runs_on) }}
     container: ${{ inputs.image != '' && inputs.image || null }}
-    timeout-minutes: 60
+    timeout-minutes: ${{ inputs.sanitizers != '' && 360 || 60 }}
     env:
       # Use a namespace to keep the objects separate for each configuration.
       CCACHE_NAMESPACE: ${{ inputs.config_name }}
@@ -176,8 +176,8 @@ jobs:
           fi
 
       - name: Upload the binary (Linux)
-        if: ${{ github.repository_owner == 'XRPLF' && runner.os == 'Linux' }}
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        if: ${{ github.repository == 'XRPLF/rippled' && runner.os == 'Linux' }}
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: xrpld-${{ inputs.config_name }}
           path: ${{ env.BUILD_DIR }}/xrpld
@@ -204,11 +204,17 @@ jobs:
 
       - name: Set sanitizer options
         if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
+        env:
+          CONFIG_NAME: ${{ inputs.config_name }}
         run: |
-          echo "ASAN_OPTIONS=print_stacktrace=1:detect_container_overflow=0:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp" >> ${GITHUB_ENV}
-          echo "TSAN_OPTIONS=second_deadlock_stack=1:halt_on_error=0:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
-          echo "UBSAN_OPTIONS=suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
-          echo "LSAN_OPTIONS=suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
+          ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
+          if [[ "${CONFIG_NAME}" == *gcc* ]]; then
+            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
+          fi
+          echo "ASAN_OPTIONS=${ASAN_OPTS}" >> ${GITHUB_ENV}
+          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
 
       - name: Run the separate tests
         if: ${{ !inputs.build_only }}
@@ -229,8 +235,23 @@ jobs:
         env:
           BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
         run: |
-          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}"
+          set -o pipefail
+          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
+          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$(( BUILD_NPROC - 2 ))
+          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
 
+      - name: Show test failure summary
+        if: ${{ failure() && !inputs.build_only }}
+        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        run: |
+          if [ ! -f unittest.log ]; then
+            echo "unittest.log not found; embedded tests may not have run."
+            exit 0
+          fi
+
+          if ! grep -E "failed" unittest.log; then
+            echo "Log present but no failure lines found in unittest.log."
+          fi
       - name: Debug failure (Linux)
         if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}
         run: |
@@ -253,7 +274,7 @@ jobs:
             --target coverage
 
       - name: Upload coverage report
-        if: ${{ github.repository_owner == 'XRPLF' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
+        if: ${{ github.repository == 'XRPLF/rippled' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
         uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
           disable_search: true
diff --git a/.github/workflows/reusable-check-levelization.yml b/.github/workflows/reusable-check-levelization.yml
index ae3eed0f16..4efe3e1138 100644
--- a/.github/workflows/reusable-check-levelization.yml
+++ b/.github/workflows/reusable-check-levelization.yml
@@ -20,7 +20,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check levelization
-        run: .github/scripts/levelization/generate.sh
+        run: python .github/scripts/levelization/generate.py
       - name: Check for differences
         env:
           MESSAGE: |
@@ -32,7 +32,7 @@ jobs:
             removed from loops.txt, it's probably an improvement, while if
             something was added, it's probably a regression.
 
-            Run '.github/scripts/levelization/generate.sh' in your repo, commit
+            Run '.github/scripts/levelization/generate.py' in your repo, commit
             and push the changes. See .github/scripts/levelization/README.md for
             more info.
         run: |
diff --git a/.github/workflows/reusable-clang-tidy-files.yml b/.github/workflows/reusable-clang-tidy-files.yml
index d36dea747c..129726ec8f 100644
--- a/.github/workflows/reusable-clang-tidy-files.yml
+++ b/.github/workflows/reusable-clang-tidy-files.yml
@@ -84,7 +84,7 @@ jobs:
 
       - name: Upload clang-tidy output
         if: steps.run_clang_tidy.outcome != 'success'
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: clang-tidy-results
           path: clang-tidy-output.txt
diff --git a/.github/workflows/reusable-clang-tidy.yml b/.github/workflows/reusable-clang-tidy.yml
index 7050d3509f..3d4bc3b2e3 100644
--- a/.github/workflows/reusable-clang-tidy.yml
+++ b/.github/workflows/reusable-clang-tidy.yml
@@ -31,7 +31,7 @@ jobs:
 
       - name: Get changed C++ files
         id: changed_files
-        uses: tj-actions/changed-files@7dee1b0c1557f278e5c7dc244927139d78c0e22a # v47.0.4
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
         with:
           files: |
             **/*.cpp
@@ -41,7 +41,7 @@ jobs:
 
       - name: Get changed clang-tidy configuration
         id: changed_clang_tidy
-        uses: tj-actions/changed-files@7dee1b0c1557f278e5c7dc244927139d78c0e22a # v47.0.4
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
         with:
           files: |
             .clang-tidy
@@ -51,5 +51,5 @@ jobs:
     if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.any_cpp_changed == 'true' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }}
     uses: ./.github/workflows/reusable-clang-tidy-files.yml
     with:
-      files: ${{ (needs.determine-files.outputs.clang_tidy_config_changed == 'true' && '') || (inputs.check_only_changed && needs.determine-files.outputs.all_changed_files || '') }}
+      files: ${{ needs.determine-files.outputs.clang_tidy_config_changed == 'true' && '' || (inputs.check_only_changed && needs.determine-files.outputs.all_changed_files || '') }}
       create_issue_on_failure: ${{ inputs.create_issue_on_failure }}
diff --git a/.github/workflows/reusable-upload-recipe.yml b/.github/workflows/reusable-upload-recipe.yml
index 6245fd06e1..178dd65b8e 100644
--- a/.github/workflows/reusable-upload-recipe.yml
+++ b/.github/workflows/reusable-upload-recipe.yml
@@ -69,22 +69,28 @@ jobs:
           conan export . --version=${{ steps.version.outputs.version }}
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.version.outputs.version }}
 
+      # When this workflow is triggered by a push event, it will always be when merging into the
+      # 'develop' branch, see on-trigger.yml.
       - name: Upload Conan recipe (develop)
-        if: ${{ github.ref == 'refs/heads/develop' }}
+        if: ${{ github.event_name == 'push' }}
         env:
           REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=develop
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/develop
 
+      # When this workflow is triggered by a pull request event, it will always be when merging into
+      # one of the 'release' branches, see on-pr.yml.
       - name: Upload Conan recipe (rc)
-        if: ${{ startsWith(github.ref, 'refs/heads/release') }}
+        if: ${{ github.event_name == 'pull_request' }}
         env:
           REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=rc
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/rc
 
+      # When this workflow is triggered by a tag event, it will always be when tagging a final
+      # release, see on-tag.yml.
       - name: Upload Conan recipe (release)
         if: ${{ github.event_name == 'tag' }}
         env:
diff --git a/.github/workflows/upload-conan-deps.yml b/.github/workflows/upload-conan-deps.yml
index df8aa43a18..d0fea4b8ae 100644
--- a/.github/workflows/upload-conan-deps.yml
+++ b/.github/workflows/upload-conan-deps.yml
@@ -103,11 +103,11 @@ jobs:
           sanitizers: ${{ matrix.sanitizers }}
 
       - name: Log into Conan remote
-        if: ${{ github.repository_owner == 'XRPLF' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
+        if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
         run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.CONAN_REMOTE_USERNAME }}" --password "${{ secrets.CONAN_REMOTE_PASSWORD }}"
 
       - name: Upload Conan packages
-        if: ${{ github.repository_owner == 'XRPLF' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
+        if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
         env:
           FORCE_OPTION: ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
         run: conan upload "*" --remote="${CONAN_REMOTE_NAME}" --confirm ${FORCE_OPTION}
diff --git a/.gitignore b/.gitignore
index 60e8fef56c..643f0d25dc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -75,6 +75,9 @@ DerivedData
 /.claude
 /CLAUDE.md
 
+# Python
+__pycache__
+
 # Direnv's directory
 /.direnv
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6e04c752e9..586cfe860c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -20,30 +20,29 @@ repos:
         args: [--assume-in-merge]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: 75ca4ad908dc4a99f57921f29b7e6c1521e10b26 # frozen: v21.1.8
+    rev: cd481d7b0bfb5c7b3090c21846317f9a8262e891 # frozen: v22.1.0
     hooks:
       - id: clang-format
         args: [--style=file]
         "types_or": [c++, c, proto]
 
-  - repo: https://github.com/cheshirekow/cmake-format-precommit
-    rev: e2c2116d86a80e72e7146a06e68b7c228afc6319 # frozen: v0.6.13
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.26.0
     hooks:
-      - id: cmake-format
-        additional_dependencies: [PyYAML]
+      - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 5ba47274f9b181bce26a5150a725577f3c336011 # frozen: v3.6.2
+    rev: c2bc67fe8f8f549cc489e00ba8b45aa18ee713b1 # frozen: v3.8.1
     hooks:
       - id: prettier
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 831207fd435b47aeffdf6af853097e64322b4d44 # frozen: v25.12.0
+    rev: ea488cebbfd88a5f50b8bd95d5c829d0bb76feb8 # frozen: 26.1.0
     hooks:
       - id: black
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: 1cfa010f078c354f3ffb8413616280cc28f5ba21 # frozen: v9.4.0
+    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
     hooks:
       - id: cspell # Spell check changed files
         exclude: .config/cspell.config.yaml
@@ -61,7 +60,15 @@ repos:
     hooks:
       - id: nix-fmt
         name: Format Nix files
-        entry: nix --extra-experimental-features 'nix-command flakes' fmt
+        entry: |
+          bash -c '
+            if command -v nix &> /dev/null || [ "$GITHUB_ACTIONS" = "true" ]; then
+              nix --extra-experimental-features "nix-command flakes" fmt "$@"
+            else
+              echo "Skipping nix-fmt: nix not installed and not in GitHub Actions"
+              exit 0
+            fi
+          ' --
         language: system
         types:
           - nix
diff --git a/API-CHANGELOG.md b/API-CHANGELOG.md
index c7a31d27fa..64b61c2024 100644
--- a/API-CHANGELOG.md
+++ b/API-CHANGELOG.md
@@ -22,6 +22,23 @@ API version 2 is available in `rippled` version 2.0.0 and later. See [API-VERSIO
 
 This version is supported by all `rippled` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
 
+## Unreleased
+
+This section contains changes targeting a future version.
+
+### Additions
+
+- `server_definitions`: Added the following new sections to the response ([#6321](https://github.com/XRPLF/rippled/pull/6321)):
+  - `TRANSACTION_FORMATS`: Describes the fields and their optionality for each transaction type, including common fields shared across all transactions.
+  - `LEDGER_ENTRY_FORMATS`: Describes the fields and their optionality for each ledger entry type, including common fields shared across all ledger entries.
+  - `TRANSACTION_FLAGS`: Maps transaction type names to their supported flags and flag values.
+  - `LEDGER_ENTRY_FLAGS`: Maps ledger entry type names to their flags and flag values.
+  - `ACCOUNT_SET_FLAGS`: Maps AccountSet flag names (asf flags) to their numeric values.
+
+### Bugfixes
+
+- Peer Crawler: The `port` field in `overlay.active[]` now consistently returns an integer instead of a string for outbound peers. [#6318](https://github.com/XRPLF/rippled/pull/6318)
+
 ## XRP Ledger server version 3.1.0
 
 [Version 3.1.0](https://github.com/XRPLF/rippled/releases/tag/3.1.0) was released on Jan 27, 2026.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 764e917498..33f68451c5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,16 +1,16 @@
 cmake_minimum_required(VERSION 3.16)
 
-if (POLICY CMP0074)
+if(POLICY CMP0074)
     cmake_policy(SET CMP0074 NEW)
-endif ()
-if (POLICY CMP0077)
+endif()
+if(POLICY CMP0077)
     cmake_policy(SET CMP0077 NEW)
-endif ()
+endif()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-if (DEFINED CMAKE_MODULE_PATH)
+if(DEFINED CMAKE_MODULE_PATH)
     file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
-endif ()
+endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
@@ -21,77 +21,64 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include(CompilationEnv)
 
-if (is_gcc)
+if(is_gcc)
     # GCC-specific fixes
     add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
     # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif (is_clang)
+elseif(is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif (is_msvc)
+elseif(is_msvc)
     # MSVC-specific fixes
     add_compile_options(/wd4068) # Ignore unknown pragmas
-endif ()
+endif()
 
 # Enable ccache to speed up builds.
 include(Ccache)
 
-# make GIT_COMMIT_HASH define available to all sources
-find_package(Git)
-if (Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
-                            HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
-    if (gch)
-        set(GIT_COMMIT_HASH "${gch}")
-        message(STATUS gch: ${GIT_COMMIT_HASH})
-        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
-    endif ()
-
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
-                            --abbrev-ref HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
-    if (gb)
-        set(GIT_BRANCH "${gb}")
-        message(STATUS gb: ${GIT_BRANCH})
-        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
-    endif ()
-endif () # git
-
-if (thread_safety_analysis)
-    add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
-                        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS)
+if(thread_safety_analysis)
+    add_compile_options(
+        -Wthread-safety
+        -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS
+    )
     add_compile_options("-stdlib=libc++")
     add_link_options("-stdlib=libc++")
-endif ()
+endif()
 
 include(CheckCXXCompilerFlag)
 include(FetchContent)
 include(ExternalProject)
 include(CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
-if (target)
-    message(FATAL_ERROR "The target option has been removed - use native cmake options to control build"
+if(target)
+    message(
+        FATAL_ERROR
+        "The target option has been removed - use native cmake options to control build"
     )
-endif ()
+endif()
 
 include(XrplSanity)
 include(XrplVersion)
 include(XrplSettings)
 # this check has to remain in the top-level cmake because of the early return statement
-if (packages_only)
-    if (NOT TARGET rpm)
-        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?"
+if(packages_only)
+    if(NOT TARGET rpm)
+        message(
+            FATAL_ERROR
+            "packages_only requested, but targets were not created - is docker installed?"
         )
-    endif ()
+    endif()
     return()
-endif ()
+endif()
 include(XrplCompiler)
 include(XrplSanitizers)
 include(XrplInterface)
 
 option(only_docs "Include only the docs target?" FALSE)
 include(XrplDocs)
-if (only_docs)
+if(only_docs)
     return()
-endif ()
+endif()
 
 include(deps/Boost)
 
@@ -110,42 +97,45 @@ find_package(xxHash REQUIRED)
 
 target_link_libraries(
     xrpl_libs
-    INTERFACE ed25519::ed25519
-              lz4::lz4
-              OpenSSL::Crypto
-              OpenSSL::SSL
-              secp256k1::secp256k1
-              soci::soci
-              SQLite::SQLite3)
+    INTERFACE
+        ed25519::ed25519
+        lz4::lz4
+        OpenSSL::Crypto
+        OpenSSL::SSL
+        secp256k1::secp256k1
+        soci::soci
+        SQLite::SQLite3
+)
 
 option(rocksdb "Enable RocksDB" ON)
-if (rocksdb)
+if(rocksdb)
     find_package(RocksDB REQUIRED)
-    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS
-                                                      XRPL_ROCKSDB_AVAILABLE=1)
+    set_target_properties(
+        RocksDB::rocksdb
+        PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
+    )
     target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif ()
+endif()
 
 # Work around changes to Conan recipe for now.
-if (TARGET nudb::core)
+if(TARGET nudb::core)
     set(nudb nudb::core)
-elseif (TARGET NuDB::nudb)
+elseif(TARGET NuDB::nudb)
     set(nudb NuDB::nudb)
-else ()
+else()
     message(FATAL_ERROR "unknown nudb target")
-endif ()
+endif()
 target_link_libraries(xrpl_libs INTERFACE ${nudb})
 
-if (coverage)
+if(coverage)
     include(XrplCov)
-endif ()
+endif()
 
-set(PROJECT_EXPORT_SET XrplExports)
 include(XrplCore)
 include(XrplInstall)
 include(XrplValidatorKeys)
 
-if (tests)
+if(tests)
     include(CTest)
     add_subdirectory(src/tests/libxrpl)
-endif ()
+endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4bb1db8689..86bef765a5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -127,26 +127,6 @@ tl;dr
 > 6. Wrap the body at 72 characters.
 > 7. Use the body to explain what and why vs. how.
 
-In addition to those guidelines, please add one of the following
-prefixes to the subject line if appropriate.
-
-- `fix:` - The primary purpose is to fix an existing bug.
-- `perf:` - The primary purpose is performance improvements.
-- `refactor:` - The changes refactor code without affecting
-  functionality.
-- `test:` - The changes _only_ affect unit tests.
-- `docs:` - The changes _only_ affect documentation. This can
-  include code comments in addition to `.md` files like this one.
-- `build:` - The changes _only_ affect the build process,
-  including CMake and/or Conan settings.
-- `chore:` - Other tasks that don't affect the binary, but don't fit
-  any of the other cases. e.g. formatting, git settings, updating
-  Github Actions jobs.
-
-Whenever possible, when updating commits after the PR is open, please
-add the PR number to the end of the subject line. e.g. `test: Add
-unit tests for Feature X (#1234)`.
-
 ## Pull requests
 
 In general, pull requests use `develop` as the base branch.
@@ -180,6 +160,23 @@ credibility of the existing approvals is insufficient.
 Pull requests must be merged by [squash-and-merge][squash]
 to preserve a linear history for the `develop` branch.
 
+### Type of Change
+
+In addition to those guidelines, please start your PR title with one of the following:
+
+- `build:` - The changes _only_ affect the build process, including CMake and/or Conan settings.
+- `feat`: New feature (change which adds functionality).
+- `fix:` - The primary purpose is to fix an existing bug.
+- `docs:` - The changes _only_ affect documentation.
+- `test:` - The changes _only_ affect unit tests.
+- `ci`: Continuous Integration (changes to our CI configuration files and scripts).
+- `style`: Code style (formatting).
+- `refactor:` - The changes refactor code without affecting functionality.
+- `perf:` - The primary purpose is performance improvements.
+- `chore:` - Other tasks that don't affect the binary, but don't fit any of the other cases. e.g. `git` settings, `clang-tidy`, removing dead code, dropping support for older tooling.
+
+First letter after the type prefix should be capitalized, and the type prefix should be followed by a colon and a space. e.g. `feat: Add support for Borrowing Protocol`.
+
 ### "Ready to merge"
 
 A pull request should only have the "Ready to merge" label added when it
diff --git a/cmake/CMakeFuncs.cmake b/cmake/CMakeFuncs.cmake
index ec2d9db330..391ed3364c 100644
--- a/cmake/CMakeFuncs.cmake
+++ b/cmake/CMakeFuncs.cmake
@@ -1,29 +1,32 @@
-macro (exclude_from_default target_)
+macro(exclude_from_default target_)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
-endmacro ()
+endmacro()
 
-macro (exclude_if_included target_)
+macro(exclude_if_included target_)
     get_directory_property(has_parent PARENT_DIRECTORY)
-    if (has_parent)
+    if(has_parent)
         exclude_from_default(${target_})
-    endif ()
-endmacro ()
+    endif()
+endmacro()
 
 find_package(Git)
 
-function (git_branch branch_val)
-    if (NOT GIT_FOUND)
+function(git_branch branch_val)
+    if(NOT GIT_FOUND)
         return()
-    endif ()
+    endif()
     set(_branch "")
-    execute_process(COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                    RESULT_VARIABLE _git_exit_code
-                    OUTPUT_VARIABLE _temp_branch
-                    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
-    if (_git_exit_code EQUAL 0)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        RESULT_VARIABLE _git_exit_code
+        OUTPUT_VARIABLE _temp_branch
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(_git_exit_code EQUAL 0)
         set(_branch ${_temp_branch})
-    endif ()
+    endif()
     set(${branch_val} "${_branch}" PARENT_SCOPE)
-endfunction ()
+endfunction()
diff --git a/cmake/Ccache.cmake b/cmake/Ccache.cmake
index e34627ad8a..f8972dbb30 100644
--- a/cmake/Ccache.cmake
+++ b/cmake/Ccache.cmake
@@ -1,50 +1,62 @@
 find_program(CCACHE_PATH "ccache")
-if (NOT CCACHE_PATH)
+if(NOT CCACHE_PATH)
     return()
-endif ()
+endif()
 
 # For Linux and macOS we can use the ccache binary directly.
-if (NOT MSVC)
+if(NOT MSVC)
     set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PATH}")
     set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PATH}")
     message(STATUS "Found ccache: ${CCACHE_PATH}")
     return()
-endif ()
+endif()
 
 # For Windows more effort is required. The code below is a modified version of
 # https://github.com/ccache/ccache/wiki/MS-Visual-Studio#usage-with-cmake.
-if ("${CCACHE_PATH}" MATCHES "chocolatey")
+if("${CCACHE_PATH}" MATCHES "chocolatey")
     message(DEBUG "Ccache path: ${CCACHE_PATH}")
     # Chocolatey uses a shim executable that we cannot use directly, in which case we have to find the executable it
     # points to. If we cannot find the target executable then we cannot use ccache.
     find_program(BASH_PATH "bash")
-    if (NOT BASH_PATH)
+    if(NOT BASH_PATH)
         message(WARNING "Could not find bash.")
         return()
-    endif ()
+    endif()
 
-    execute_process(COMMAND bash -c
-                            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
-                    OUTPUT_VARIABLE CCACHE_PATH)
+    execute_process(
+        COMMAND
+            bash -c
+            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
+        OUTPUT_VARIABLE CCACHE_PATH
+    )
 
-    if (NOT CCACHE_PATH)
+    if(NOT CCACHE_PATH)
         message(WARNING "Could not find ccache target.")
         return()
-    endif ()
+    endif()
     file(TO_CMAKE_PATH "${CCACHE_PATH}" CCACHE_PATH)
-endif ()
+endif()
 message(STATUS "Found ccache: ${CCACHE_PATH}")
 
 # Tell cmake to use ccache for compiling with Visual Studio.
 file(COPY_FILE ${CCACHE_PATH} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "TrackFileAccess=false"
-                     "UseMultiToolTask=true")
+set(CMAKE_VS_GLOBALS
+    "CLToolExe=cl.exe"
+    "CLToolPath=${CMAKE_BINARY_DIR}"
+    "TrackFileAccess=false"
+    "UseMultiToolTask=true"
+)
 
 # By default Visual Studio generators will use /Zi to capture debug information, which is not compatible with ccache, so
 # tell it to use /Z7 instead.
-if (MSVC)
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
-                  CMAKE_CXX_FLAGS_RELEASE)
+if(MSVC)
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         string(REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()
diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake
index 74796718c1..5681f76640 100644
--- a/cmake/CodeCoverage.cmake
+++ b/cmake/CodeCoverage.cmake
@@ -174,37 +174,45 @@ option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
 # Check prereqs
 find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
 
-if (DEFINED CODE_COVERAGE_GCOV_TOOL)
+if(DEFINED CODE_COVERAGE_GCOV_TOOL)
     set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
-elseif (DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
+elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
     set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-    if (APPLE)
-        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH
-                        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if(APPLE)
+        execute_process(
+            COMMAND xcrun -f llvm-cov
+            OUTPUT_VARIABLE LLVMCOV_PATH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    else()
         find_program(LLVMCOV_PATH llvm-cov)
-    endif ()
-    if (LLVMCOV_PATH)
+    endif()
+    if(LLVMCOV_PATH)
         set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
-    endif ()
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    endif()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
     find_program(GCOV_PATH gcov)
     set(GCOV_TOOL "${GCOV_PATH}")
-endif ()
+endif()
 
 # Check supported compiler (Clang, GNU and Flang)
 get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach (LANG ${LANGUAGES})
-    if ("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-        if ("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
-            message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
-        endif ()
-    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}"
-                                                                 MATCHES "(LLVM)?[Ff]lang")
+foreach(LANG ${LANGUAGES})
+    if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+        if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+            message(
+                FATAL_ERROR
+                "Clang version must be 3.0.0 or greater! Aborting..."
+            )
+        endif()
+    elseif(
+        NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
+        AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang"
+    )
         message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
-    endif ()
-endforeach ()
+    endif()
+endforeach()
 
 set(COVERAGE_COMPILER_FLAGS "-g --coverage" CACHE INTERNAL "")
 
@@ -213,7 +221,7 @@ set(COVERAGE_C_COMPILER_FLAGS "")
 set(COVERAGE_CXX_LINKER_FLAGS "")
 set(COVERAGE_C_LINKER_FLAGS "")
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
     include(CheckCCompilerFlag)
     include(CheckLinkerFlag)
@@ -224,51 +232,77 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     set(COVERAGE_C_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
 
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
-    if (HAVE_cxx_fprofile_abs_path)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
-    if (HAVE_c_fprofile_abs_path)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(CXX -fprofile-abs-path HAVE_cxx_linker_fprofile_abs_path)
-    if (HAVE_cxx_linker_fprofile_abs_path)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_linker_fprofile_abs_path)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-abs-path HAVE_c_linker_fprofile_abs_path)
-    if (HAVE_c_linker_fprofile_abs_path)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_linker_fprofile_abs_path)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_cxx_compiler_flag(-fprofile-update=atomic HAVE_cxx_fprofile_update)
-    if (HAVE_cxx_fprofile_update)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic")
-    endif ()
+    if(HAVE_cxx_fprofile_update)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-update=atomic HAVE_c_fprofile_update)
-    if (HAVE_c_fprofile_update)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_fprofile_update)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
-    check_linker_flag(CXX -fprofile-update=atomic HAVE_cxx_linker_fprofile_update)
-    if (HAVE_cxx_linker_fprofile_update)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    check_linker_flag(
+        CXX
+        -fprofile-update=atomic
+        HAVE_cxx_linker_fprofile_update
+    )
+    if(HAVE_cxx_linker_fprofile_update)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-update=atomic HAVE_c_linker_fprofile_update)
-    if (HAVE_c_linker_fprofile_update)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_linker_fprofile_update)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
+endif()
 
-endif ()
-
-get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if (NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
-    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
-endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+get_property(
+    GENERATOR_IS_MULTI_CONFIG
+    GLOBAL
+    PROPERTY GENERATOR_IS_MULTI_CONFIG
+)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(
+        WARNING
+        "Code coverage results with an optimised (non-Debug) build may be misleading"
+    )
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
@@ -292,125 +326,167 @@ endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
-function (setup_target_for_coverage_gcovr)
+function(setup_target_for_coverage_gcovr)
     set(options NONE)
     set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
     set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
-    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    cmake_parse_arguments(
+        Coverage
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
 
-    if (NOT GCOV_TOOL)
+    if(NOT GCOV_TOOL)
         message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
-    endif ()
+    endif()
 
-    if (NOT GCOVR_PATH)
+    if(NOT GCOVR_PATH)
         message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
-    endif ()
+    endif()
 
     # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
-    if (DEFINED Coverage_BASE_DIRECTORY)
+    if(DEFINED Coverage_BASE_DIRECTORY)
         get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
-    else ()
+    else()
         set(BASEDIR ${PROJECT_SOURCE_DIR})
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_FORMAT)
+    if(NOT DEFINED Coverage_FORMAT)
         set(Coverage_FORMAT xml)
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
-        message(FATAL_ERROR "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set")
-    endif ()
-
-    if ("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
-        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+    if(NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
+        message(
+            FATAL_ERROR
+            "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set"
         )
-    else ()
-        if ((Coverage_FORMAT STREQUAL "html-details") OR (Coverage_FORMAT STREQUAL "html-nested"))
-            set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
-            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
-        elseif (Coverage_FORMAT STREQUAL "html-single")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL
-                                                              "json-details")
-                OR (Coverage_FORMAT STREQUAL "coveralls"))
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
-        elseif (Coverage_FORMAT STREQUAL "txt")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
-        elseif (Coverage_FORMAT STREQUAL "csv")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        elseif (Coverage_FORMAT STREQUAL "lcov")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
-        else ()
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
-        endif ()
-    endif ()
+    endif()
 
-    if ((Coverage_FORMAT STREQUAL "cobertura") OR (Coverage_FORMAT STREQUAL "xml"))
+    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
+        message(
+            FATAL_ERROR
+            "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+        )
+    else()
+        if(
+            (Coverage_FORMAT STREQUAL "html-details")
+            OR (Coverage_FORMAT STREQUAL "html-nested")
+        )
+            set(GCOVR_OUTPUT_FILE
+                ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html
+            )
+            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
+        elseif(Coverage_FORMAT STREQUAL "html-single")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
+        elseif(
+            (Coverage_FORMAT STREQUAL "json-summary")
+            OR (Coverage_FORMAT STREQUAL "json-details")
+            OR (Coverage_FORMAT STREQUAL "coveralls")
+        )
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
+        elseif(Coverage_FORMAT STREQUAL "txt")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
+        elseif(Coverage_FORMAT STREQUAL "csv")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
+        else()
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
+        endif()
+    endif()
+
+    if(
+        (Coverage_FORMAT STREQUAL "cobertura")
+        OR (Coverage_FORMAT STREQUAL "xml")
+    )
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty)
         set(Coverage_FORMAT cobertura) # overwrite xml
-    elseif (Coverage_FORMAT STREQUAL "sonarqube")
+    elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "jacoco")
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty)
-    elseif (Coverage_FORMAT STREQUAL "clover")
+    elseif(Coverage_FORMAT STREQUAL "clover")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty)
-    elseif (Coverage_FORMAT STREQUAL "lcov")
+    elseif(Coverage_FORMAT STREQUAL "lcov")
         list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "json-summary")
+    elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
-    elseif (Coverage_FORMAT STREQUAL "json-details")
+    elseif(Coverage_FORMAT STREQUAL "json-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
-    elseif (Coverage_FORMAT STREQUAL "coveralls")
+    elseif(Coverage_FORMAT STREQUAL "coveralls")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
-    elseif (Coverage_FORMAT STREQUAL "csv")
+    elseif(Coverage_FORMAT STREQUAL "csv")
         list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "txt")
+    elseif(Coverage_FORMAT STREQUAL "txt")
         list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-single")
+    elseif(Coverage_FORMAT STREQUAL "html-single")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
-    elseif (Coverage_FORMAT STREQUAL "html-nested")
+    elseif(Coverage_FORMAT STREQUAL "html-nested")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-details")
+    elseif(Coverage_FORMAT STREQUAL "html-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}")
-    else ()
-        message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
-    endif ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported output style ${Coverage_FORMAT}! Aborting..."
+        )
+    endif()
 
     # Collect excludes (CMake 3.4+: Also compute absolute paths)
     set(GCOVR_EXCLUDES "")
-    foreach (EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
-        if (CMAKE_VERSION VERSION_GREATER 3.4)
-            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
-        endif ()
+    foreach(
+        EXCLUDE
+        ${Coverage_EXCLUDE}
+        ${COVERAGE_EXCLUDES}
+        ${COVERAGE_GCOVR_EXCLUDES}
+    )
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(
+                EXCLUDE
+                ${EXCLUDE}
+                ABSOLUTE
+                BASE_DIR ${BASEDIR}
+            )
+        endif()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
-    endforeach ()
+    endforeach()
     list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
 
     # Combine excludes to several -e arguments
     set(GCOVR_EXCLUDE_ARGS "")
-    foreach (EXCLUDE ${GCOVR_EXCLUDES})
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
         list(APPEND GCOVR_EXCLUDE_ARGS "-e")
         list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
-    endforeach ()
+    endforeach()
 
     # Set up commands which will be run to generate coverage data
     # If EXECUTABLE is not set, the user is expected to run the tests manually
     # before running the coverage target NAME
-    if (DEFINED Coverage_EXECUTABLE)
-        set(GCOVR_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
-    endif ()
+    if(DEFINED Coverage_EXECUTABLE)
+        set(GCOVR_EXEC_TESTS_CMD
+            ${Coverage_EXECUTABLE}
+            ${Coverage_EXECUTABLE_ARGS}
+        )
+    endif()
 
     # Create folder
-    if (DEFINED GCOVR_CREATE_FOLDER)
-        set(GCOVR_FOLDER_CMD ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
-    endif ()
+    if(DEFINED GCOVR_CREATE_FOLDER)
+        set(GCOVR_FOLDER_CMD
+            ${CMAKE_COMMAND}
+            -E
+            make_directory
+            ${GCOVR_CREATE_FOLDER}
+        )
+    endif()
 
     # Running gcovr
     set(GCOVR_CMD
@@ -422,56 +498,95 @@ function (setup_target_for_coverage_gcovr)
         ${BASEDIR}
         ${GCOVR_ADDITIONAL_ARGS}
         ${GCOVR_EXCLUDE_ARGS}
-        --object-directory=${PROJECT_BINARY_DIR})
+        --object-directory=${PROJECT_BINARY_DIR}
+    )
 
-    if (CODE_COVERAGE_VERBOSE)
+    if(CODE_COVERAGE_VERBOSE)
         message(STATUS "Executed command report")
 
-        if (NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
             message(STATUS "Command to run tests: ")
-            string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_EXEC_TESTS_CMD_SPACED
+                "${GCOVR_EXEC_TESTS_CMD}"
+            )
             message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
-        endif ()
+        endif()
 
-        if (NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
             message(STATUS "Command to create a folder: ")
-            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_FOLDER_CMD_SPACED
+                "${GCOVR_FOLDER_CMD}"
+            )
             message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
-        endif ()
+        endif()
 
         message(STATUS "Command to generate gcovr coverage data: ")
         string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
         message(STATUS "${GCOVR_CMD_SPACED}")
-    endif ()
+    endif()
 
-    add_custom_target(${Coverage_NAME}
-                      COMMAND ${GCOVR_EXEC_TESTS_CMD}
-                      COMMAND ${GCOVR_FOLDER_CMD}
-                      COMMAND ${GCOVR_CMD}
-                      BYPRODUCTS ${GCOVR_OUTPUT_FILE}
-                      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-                      DEPENDS ${Coverage_DEPENDENCIES}
-                      VERBATIM # Protect arguments to commands
-                      COMMENT "Running gcovr to produce code coverage report.")
+    add_custom_target(
+        ${Coverage_NAME}
+        COMMAND ${GCOVR_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_FOLDER_CMD}
+        COMMAND ${GCOVR_CMD}
+        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce code coverage report."
+    )
 
     # Show info where to find the report
     add_custom_command(
-        TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
-        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+        TARGET ${Coverage_NAME}
+        POST_BUILD
+        COMMAND echo
+        COMMENT
+            "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
     )
-endfunction () # setup_target_for_coverage_gcovr
+endfunction() # setup_target_for_coverage_gcovr
 
-function (add_code_coverage_to_target name scope)
-    separate_arguments(COVERAGE_CXX_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_C_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_C_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_CXX_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_LINKER_FLAGS}")
-    separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
+function(add_code_coverage_to_target name scope)
+    separate_arguments(
+        COVERAGE_CXX_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_CXX_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_LINKER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_LINKER_FLAGS}"
+    )
 
     # Add compiler options to the target
     target_compile_options(
-        ${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
-        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
+        ${name}
+        ${scope}
+        $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>
+    )
 
-    target_link_libraries(${name} ${scope} $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
-                          $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>)
-endfunction () # add_code_coverage_to_target
+    target_link_libraries(
+        ${name}
+        ${scope}
+        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
+        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>
+    )
+endfunction() # add_code_coverage_to_target
diff --git a/cmake/CompilationEnv.cmake b/cmake/CompilationEnv.cmake
index 59b903c13a..0d44f90974 100644
--- a/cmake/CompilationEnv.cmake
+++ b/cmake/CompilationEnv.cmake
@@ -14,20 +14,20 @@ set(is_gcc FALSE)
 set(is_msvc FALSE)
 set(is_xcode FALSE)
 
-if (CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
     set(is_clang TRUE)
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(is_gcc TRUE)
-elseif (MSVC)
+elseif(MSVC)
     set(is_msvc TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
-endif ()
+endif()
 
 # Xcode generator detection
-if (CMAKE_GENERATOR STREQUAL "Xcode")
+if(CMAKE_GENERATOR STREQUAL "Xcode")
     set(is_xcode TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Operating system detection
@@ -36,23 +36,23 @@ set(is_linux FALSE)
 set(is_windows FALSE)
 set(is_macos FALSE)
 
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(is_linux TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     set(is_windows TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     set(is_macos TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Architecture
 # --------------------------------------------------------------------
 set(is_amd64 FALSE)
 set(is_arm64 FALSE)
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
     set(is_amd64 TRUE)
-elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
     set(is_arm64 TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
-endif ()
+endif()
diff --git a/cmake/GitInfo.cmake b/cmake/GitInfo.cmake
new file mode 100644
index 0000000000..788efe624a
--- /dev/null
+++ b/cmake/GitInfo.cmake
@@ -0,0 +1,28 @@
+include_guard()
+
+set(GIT_BUILD_BRANCH "")
+set(GIT_COMMIT_HASH "")
+
+find_package(Git)
+if(NOT Git_FOUND)
+    message(WARNING "Git not found. Git branch and commit hash will be empty.")
+    return()
+endif()
+
+set(GIT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+
+execute_process(
+    COMMAND
+        ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse --abbrev-ref HEAD
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE GIT_BUILD_BRANCH
+)
+
+execute_process(
+    COMMAND ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse HEAD
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE GIT_COMMIT_HASH
+)
+
+message(STATUS "Git branch: ${GIT_BUILD_BRANCH}")
+message(STATUS "Git commit hash: ${GIT_COMMIT_HASH}")
diff --git a/cmake/XrplAddTest.cmake b/cmake/XrplAddTest.cmake
index 35189e203f..2f1209e03c 100644
--- a/cmake/XrplAddTest.cmake
+++ b/cmake/XrplAddTest.cmake
@@ -1,13 +1,22 @@
 include(isolate_headers)
 
-function (xrpl_add_test name)
+function(xrpl_add_test name)
     set(target ${PROJECT_NAME}.test.${name})
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-         "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+    )
     add_executable(${target} ${ARGN} ${sources})
 
-    isolate_headers(${target} "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests/${name}" PRIVATE)
+    isolate_headers(
+        ${target}
+        "${CMAKE_SOURCE_DIR}"
+        "${CMAKE_SOURCE_DIR}/tests/${name}"
+        PRIVATE
+    )
 
     add_test(NAME ${target} COMMAND ${target})
-endfunction ()
+endfunction()
diff --git a/cmake/XrplCompiler.cmake b/cmake/XrplCompiler.cmake
index 8093004b2e..9db754eb1d 100644
--- a/cmake/XrplCompiler.cmake
+++ b/cmake/XrplCompiler.cmake
@@ -14,33 +14,42 @@ include(XrplSanitizers)
 # add a single global dependency on this interface lib
 link_libraries(Xrpl::common)
 # Respect CMAKE_POSITION_INDEPENDENT_CODE setting (may be set by Conan toolchain)
-if (NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
-set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE
-                                        ${CMAKE_POSITION_INDEPENDENT_CODE})
+endif()
+set_target_properties(
+    common
+    PROPERTIES
+        INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE}
+)
 set(CMAKE_CXX_EXTENSIONS OFF)
 target_compile_definitions(
     common
-    INTERFACE $<$<CONFIG:Debug>:DEBUG
-              _DEBUG>
-              #[===[
+    INTERFACE
+        $<$<CONFIG:Debug>:DEBUG
+        _DEBUG>
+        #[===[
     NOTE: CMAKE release builds already have NDEBUG defined, so no need to add it
     explicitly except for the special case of (profile ON) and (assert OFF).
     Presumably this is because we don't want profile builds asserting unless
     asserts were specifically requested.
     ]===]
-              $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
-              # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
-              OPENSSL_SUPPRESS_DEPRECATED)
+        $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
+        # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
+        OPENSSL_SUPPRESS_DEPRECATED
+)
 
-if (MSVC)
+if(MSVC)
     # remove existing exception flag since we set it to -EHa
     string(REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
-                  CMAKE_CXX_FLAGS_RELEASE)
-
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         # also remove dynamic runtime
         string(REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
 
@@ -48,120 +57,143 @@ if (MSVC)
         string(REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
 
         # omit debug info completely under CI (not needed)
-        if (is_ci)
+        if(is_ci)
             string(REPLACE "/Zi" " " ${var_} "${${var_}}")
             string(REPLACE "/Z7" " " ${var_} "${${var_}}")
-        endif ()
-    endforeach ()
+        endif()
+    endforeach()
 
     target_compile_options(
         common
         INTERFACE # Increase object file max size
-                  -bigobj
-                  # Floating point behavior
-                  -fp:precise
-                  # __cdecl calling convention
-                  -Gd
-                  # Minimal rebuild: disabled
-                  -Gm-
-                  # Function level linking: disabled
-                  -Gy-
-                  # Multiprocessor compilation
-                  -MP
-                  # pragma omp: disabled
-                  -openmp-
-                  # No error reporting to Internet
-                  -errorReport:none
-                  # Suppress login banner
-                  -nologo
-                  # Disable signed/unsigned comparison warnings
-                  -wd4018
-                  # Disable float to int possible loss of data warnings
-                  -wd4244
-                  # Disable size_t to T possible loss of data warnings
-                  -wd4267
-                  # Disable C4800(int to bool performance)
-                  -wd4800
-                  # Decorated name length exceeded, name was truncated
-                  -wd4503
-                  $<$<COMPILE_LANGUAGE:CXX>:
-                  -EHa
-                  -GR
-                  >
-                  $<$<CONFIG:Release>:-Ox>
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
-                  -GS
-                  -Zc:forScope
-                  >
-                  # static runtime
-                  $<$<CONFIG:Debug>:-MTd>
-                  $<$<NOT:$<CONFIG:Debug>>:-MT>
-                  $<$<BOOL:${werr}>:-WX>)
+            -bigobj
+            # Floating point behavior
+            -fp:precise
+            # __cdecl calling convention
+            -Gd
+            # Minimal rebuild: disabled
+            -Gm-
+            # Function level linking: disabled
+            -Gy-
+            # Multiprocessor compilation
+            -MP
+            # pragma omp: disabled
+            -openmp-
+            # No error reporting to Internet
+            -errorReport:none
+            # Suppress login banner
+            -nologo
+            # Disable signed/unsigned comparison warnings
+            -wd4018
+            # Disable float to int possible loss of data warnings
+            -wd4244
+            # Disable size_t to T possible loss of data warnings
+            -wd4267
+            # Disable C4800(int to bool performance)
+            -wd4800
+            # Decorated name length exceeded, name was truncated
+            -wd4503
+            $<$<COMPILE_LANGUAGE:CXX>:
+            -EHa
+            -GR
+            >
+            $<$<CONFIG:Release>:-Ox>
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
+            -GS
+            -Zc:forScope
+            >
+            # static runtime
+            $<$<CONFIG:Debug>:-MTd>
+            $<$<NOT:$<CONFIG:Debug>>:-MT>
+            $<$<BOOL:${werr}>:-WX>
+    )
     target_compile_definitions(
         common
-        INTERFACE _WIN32_WINNT=0x6000
-                  _SCL_SECURE_NO_WARNINGS
-                  _CRT_SECURE_NO_WARNINGS
-                  WIN32_CONSOLE
-                  WIN32_LEAN_AND_MEAN
-                  NOMINMAX
-                  # TODO: Resolve these warnings, don't just silence them
-                  _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+        INTERFACE
+            _WIN32_WINNT=0x6000
+            _SCL_SECURE_NO_WARNINGS
+            _CRT_SECURE_NO_WARNINGS
+            WIN32_CONSOLE
+            WIN32_LEAN_AND_MEAN
+            NOMINMAX
+            # TODO: Resolve these warnings, don't just silence them
+            _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>,$<NOT:$<BOOL:${is_ci}>>>:_CRTDBG_MAP_ALLOC>
+    )
     target_link_libraries(common INTERFACE -errorreport:none -machine:X64)
-else ()
+else()
     target_compile_options(
         common
-        INTERFACE -Wall
-                  -Wdeprecated
-                  $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
-                  $<$<BOOL:${wextra}>:-Wextra
-                  -Wno-unused-parameter>
-                  $<$<BOOL:${werr}>:-Werror>
-                  -fstack-protector
-                  -Wno-sign-compare
-                  -Wno-unused-but-set-variable
-                  $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
-                  # tweak gcc optimization for debug
-                  $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
-                  # Add debug symbols to release config
-                  $<$<CONFIG:Release>:-g>)
+        INTERFACE
+            -Wall
+            -Wdeprecated
+            $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
+            $<$<BOOL:${wextra}>:-Wextra
+            -Wno-unused-parameter>
+            $<$<BOOL:${werr}>:-Werror>
+            -fstack-protector
+            -Wno-sign-compare
+            -Wno-unused-but-set-variable
+            $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
+            # tweak gcc optimization for debug
+            $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
+            # Add debug symbols to release config
+            $<$<CONFIG:Release>:-g>
+    )
     target_link_libraries(
         common
-        INTERFACE -rdynamic
-                  $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
-                  # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
-                  # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
-                  $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
-                  -static-libstdc++
-                  -static-libgcc
-                  >)
-endif ()
+        INTERFACE
+            -rdynamic
+            $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
+            # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
+            # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
+            $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
+            -static-libstdc++
+            -static-libgcc
+            >
+    )
+endif()
 
 # Antithesis instrumentation will only be built and deployed using machines running Linux.
-if (voidstar)
-    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-        message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
-    elseif (NOT is_linux)
-        message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
-    elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
-        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+if(voidstar)
+    if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Debug build type, aborting..."
         )
-    endif ()
-endif ()
+    elseif(NOT is_linux)
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Linux, aborting..."
+        )
+    elseif(
+        NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+    )
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+        )
+    endif()
+endif()
 
-if (use_mold)
+if(use_mold)
     # use mold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "mold")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "mold")
         target_link_libraries(common INTERFACE -fuse-ld=mold)
-    endif ()
+    endif()
     unset(LD_VERSION)
-elseif (use_gold AND is_gcc)
+elseif(use_gold AND is_gcc)
     # use gold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
     #[=========================================================[
        NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
        default instead of DT_RPATH, so you might have slightly
@@ -175,32 +207,37 @@ elseif (use_gold AND is_gcc)
        disabling would be to figure out all the settings
        required to make gold play nicely with jemalloc.
     #]=========================================================]
-    if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
+    if(("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
         target_link_libraries(
             common
-            INTERFACE -fuse-ld=gold
-                      -Wl,--no-as-needed
-                      #[=========================================================[
+            INTERFACE
+                -fuse-ld=gold
+                -Wl,--no-as-needed
+                #[=========================================================[
            see https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1253638/comments/5
            DT_RUNPATH does not work great for transitive
            dependencies (of which boost has a few) - so just
            switch to DT_RPATH if doing dynamic linking with gold
         #]=========================================================]
-                      $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
-    endif ()
+                $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>
+        )
+    endif()
     unset(LD_VERSION)
-elseif (use_lld)
+elseif(use_lld)
     # use lld linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "LLD")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "LLD")
         target_link_libraries(common INTERFACE -fuse-ld=lld)
-    endif ()
+    endif()
     unset(LD_VERSION)
-endif ()
+endif()
 
-if (assert)
-    foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
+if(assert)
+    foreach(var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
         string(REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()
diff --git a/cmake/XrplConfig.cmake b/cmake/XrplConfig.cmake
deleted file mode 100644
index bf6aa475ba..0000000000
--- a/cmake/XrplConfig.cmake
+++ /dev/null
@@ -1,52 +0,0 @@
-include(CMakeFindDependencyMacro)
-# need to represent system dependencies of the lib here
-#[=========================================================[
-  Boost
-#]=========================================================]
-if (static OR APPLE OR MSVC)
-    set(Boost_USE_STATIC_LIBS ON)
-endif ()
-set(Boost_USE_MULTITHREADED ON)
-if (static OR MSVC)
-    set(Boost_USE_STATIC_RUNTIME ON)
-else ()
-    set(Boost_USE_STATIC_RUNTIME OFF)
-endif ()
-find_dependency(Boost
-                COMPONENTS
-                chrono
-                container
-                context
-                coroutine
-                date_time
-                filesystem
-                program_options
-                regex
-                system
-                thread)
-#[=========================================================[
-  OpenSSL
-#]=========================================================]
-if (NOT DEFINED OPENSSL_ROOT_DIR)
-    if (DEFINED ENV{OPENSSL_ROOT})
-        set(OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
-    elseif (APPLE)
-        find_program(homebrew brew)
-        if (homebrew)
-            execute_process(COMMAND ${homebrew} --prefix openssl OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-                            OUTPUT_STRIP_TRAILING_WHITESPACE)
-        endif ()
-    endif ()
-    file(TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
-endif ()
-
-if (static OR APPLE OR MSVC)
-    set(OPENSSL_USE_STATIC_LIBS ON)
-endif ()
-set(OPENSSL_MSVC_STATIC_RT ON)
-find_dependency(OpenSSL REQUIRED)
-find_dependency(ZLIB)
-find_dependency(date)
-if (TARGET ZLIB::ZLIB)
-    set_target_properties(OpenSSL::Crypto PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
-endif ()
diff --git a/cmake/XrplCore.cmake b/cmake/XrplCore.cmake
index e54dd09953..580c4155eb 100644
--- a/cmake/XrplCore.cmake
+++ b/cmake/XrplCore.cmake
@@ -10,25 +10,44 @@ include(target_protobuf_sources)
 # so we just build them as a separate library.
 add_library(xrpl.libpb)
 set_target_properties(xrpl.libpb PROPERTIES UNITY_BUILD OFF)
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-                        PROTOS include/xrpl/proto/xrpl.proto)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS include/xrpl/proto/xrpl.proto
+)
 
 file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-                        PROTOS "${protos}")
 target_protobuf_sources(
-    xrpl.libpb xrpl/proto
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS "${protos}"
+)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
     LANGUAGE grpc
     IMPORT_DIRS include/xrpl/proto
     PROTOS "${protos}"
     PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc)
+    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
+)
 
 target_compile_options(
     xrpl.libpb
-    PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>:
-           --system-header-prefix="google/protobuf" -Wno-deprecated-dynamic-exception-spec >
-    PRIVATE $<$<BOOL:${is_msvc}>:-wd4065> $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>)
+    PUBLIC
+        $<$<BOOL:${is_msvc}>:-wd4996>
+        $<$<BOOL:${is_xcode}>:
+        --system-header-prefix="google/protobuf"
+        -Wno-deprecated-dynamic-exception-spec
+        >
+    PRIVATE
+        $<$<BOOL:${is_msvc}>:-wd4065>
+        $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>
+)
 
 target_link_libraries(xrpl.libpb PUBLIC protobuf::libprotobuf gRPC::grpc++)
 
@@ -37,19 +56,21 @@ add_library(xrpl.imports.main INTERFACE)
 
 target_link_libraries(
     xrpl.imports.main
-    INTERFACE absl::random_random
-              date::date
-              ed25519::ed25519
-              LibArchive::LibArchive
-              OpenSSL::Crypto
-              Xrpl::boost
-              Xrpl::libs
-              Xrpl::opts
-              Xrpl::syslibs
-              secp256k1::secp256k1
-              xrpl.libpb
-              xxHash::xxhash
-              $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>)
+    INTERFACE
+        absl::random_random
+        date::date
+        ed25519::ed25519
+        LibArchive::LibArchive
+        OpenSSL::Crypto
+        Xrpl::boost
+        Xrpl::libs
+        Xrpl::opts
+        Xrpl::syslibs
+        secp256k1::secp256k1
+        xrpl.libpb
+        xxHash::xxhash
+        $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+)
 
 include(add_module)
 include(target_link_modules)
@@ -58,6 +79,16 @@ include(target_link_modules)
 add_module(xrpl beast)
 target_link_libraries(xrpl.libxrpl.beast PUBLIC xrpl.imports.main)
 
+include(GitInfo)
+add_module(xrpl git)
+target_compile_definitions(
+    xrpl.libxrpl.git
+    PRIVATE
+        GIT_COMMIT_HASH="${GIT_COMMIT_HASH}"
+        GIT_BUILD_BRANCH="${GIT_BUILD_BRANCH}"
+)
+target_link_libraries(xrpl.libxrpl.git PUBLIC xrpl.imports.main)
+
 # Level 02
 add_module(xrpl basics)
 target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
@@ -71,12 +102,17 @@ target_link_libraries(xrpl.libxrpl.crypto PUBLIC xrpl.libxrpl.basics)
 
 # Level 04
 add_module(xrpl protocol)
-target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.json)
+target_link_libraries(
+    xrpl.libxrpl.protocol
+    PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.git xrpl.libxrpl.json
+)
 
 # Level 05
 add_module(xrpl core)
-target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
-                                               xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.core
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+)
 
 # Level 06
 add_module(xrpl resource)
@@ -84,23 +120,46 @@ target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
 
 # Level 07
 add_module(xrpl net)
-target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
-                                              xrpl.libxrpl.protocol xrpl.libxrpl.resource)
+target_link_libraries(
+    xrpl.libxrpl.net
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.resource
+)
 
 add_module(xrpl nodestore)
-target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
-                                                    xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.nodestore
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+)
 
 add_module(xrpl shamap)
-target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto
-                                                 xrpl.libxrpl.protocol xrpl.libxrpl.nodestore)
+target_link_libraries(
+    xrpl.libxrpl.shamap
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.crypto
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.nodestore
+)
 
 add_module(xrpl rdb)
-target_link_libraries(xrpl.libxrpl.rdb PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core)
+target_link_libraries(
+    xrpl.libxrpl.rdb
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core
+)
 
 add_module(xrpl server)
-target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol xrpl.libxrpl.core
-                                                 xrpl.libxrpl.rdb xrpl.libxrpl.resource)
+target_link_libraries(
+    xrpl.libxrpl.server
+    PUBLIC
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.core
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.resource
+)
 
 add_module(xrpl conditions)
 target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)
@@ -108,13 +167,15 @@ target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)
 add_module(xrpl ledger)
 target_link_libraries(
     xrpl.libxrpl.ledger
-    PUBLIC xrpl.libxrpl.basics
-           xrpl.libxrpl.json
-           xrpl.libxrpl.protocol
-           xrpl.libxrpl.rdb
-           xrpl.libxrpl.server
-           xrpl.libxrpl.shamap
-           xrpl.libxrpl.conditions)
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.server
+        xrpl.libxrpl.shamap
+        xrpl.libxrpl.conditions
+)
 
 add_module(xrpl tx)
 target_link_libraries(xrpl.libxrpl.tx PUBLIC xrpl.libxrpl.ledger)
@@ -124,7 +185,11 @@ set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
 
 add_library(xrpl::libxrpl ALIAS xrpl.libxrpl)
 
-file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp")
+file(
+    GLOB_RECURSE sources
+    CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp"
+)
 target_sources(xrpl.libxrpl PRIVATE ${sources})
 
 target_link_modules(
@@ -135,6 +200,7 @@ target_link_modules(
     conditions
     core
     crypto
+    git
     json
     ledger
     net
@@ -144,7 +210,8 @@ target_link_modules(
     resource
     server
     shamap
-    tx)
+    tx
+)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.
@@ -155,34 +222,51 @@ target_link_modules(
 #     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 #     $<INSTALL_INTERFACE:include>)
 
-if (xrpld)
+if(xrpld)
     add_executable(xrpld)
-    if (tests)
+    if(tests)
         target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
-        target_compile_definitions(xrpld PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE})
-    endif ()
-    target_include_directories(xrpld PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
+        target_compile_definitions(
+            xrpld
+            PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
+        )
+    endif()
+    target_include_directories(
+        xrpld
+        PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    )
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp"
+    )
     target_sources(xrpld PRIVATE ${sources})
 
-    if (tests)
-        file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp")
+    if(tests)
+        file(
+            GLOB_RECURSE sources
+            CONFIGURE_DEPENDS
+            "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
+        )
         target_sources(xrpld PRIVATE ${sources})
-    endif ()
+    endif()
 
     target_link_libraries(xrpld Xrpl::boost Xrpl::opts Xrpl::libs xrpl.libxrpl)
     exclude_if_included(xrpld)
     # define a macro for tests that might need to
     # be excluded or run differently in CI environment
-    if (is_ci)
+    if(is_ci)
         target_compile_definitions(xrpld PRIVATE XRPL_RUNNING_IN_CI)
-    endif ()
+    endif()
 
-    if (voidstar)
+    if(voidstar)
         target_compile_options(xrpld PRIVATE -fsanitize-coverage=trace-pc-guard)
         # xrpld requires access to antithesis-sdk-cpp implementation file
         # antithesis_instrumentation.h, which is not exported as INTERFACE
-        target_include_directories(xrpld PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk)
-    endif ()
-endif ()
+        target_include_directories(
+            xrpld
+            PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
+        )
+    endif()
+endif()
diff --git a/cmake/XrplCov.cmake b/cmake/XrplCov.cmake
index 62c40407f2..d81d7e689f 100644
--- a/cmake/XrplCov.cmake
+++ b/cmake/XrplCov.cmake
@@ -2,14 +2,17 @@
    coverage report target
 #]===================================================================]
 
-if (NOT coverage)
+if(NOT coverage)
     message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif ()
+endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    message(
+        WARNING
+        "Code coverage on Windows is not supported, ignoring 'coverage' flag"
+    )
     return()
-endif ()
+endif()
 
 include(ProcessorCount)
 ProcessorCount(PROCESSOR_COUNT)
@@ -21,32 +24,30 @@ include(CodeCoverage)
 # `CodeCoverage.cmake`)
 
 set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if (NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
     separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif ()
+endif()
 
-list(APPEND
-     GCOVR_ADDITIONAL_ARGS
-     --exclude-throw-branches
-     --exclude-noncode-lines
-     --exclude-unreachable-branches
-     -s
-     -j
-     ${PROCESSOR_COUNT})
+list(
+    APPEND GCOVR_ADDITIONAL_ARGS
+    --exclude-throw-branches
+    --exclude-noncode-lines
+    --exclude-unreachable-branches
+    -s
+    -j
+    ${PROCESSOR_COUNT}
+)
 
 setup_target_for_coverage_gcovr(
-    NAME
-    coverage
-    FORMAT
-    ${coverage_format}
+    NAME coverage
+    FORMAT ${coverage_format}
     EXCLUDE
-    "src/test"
-    "src/tests"
-    "include/xrpl/beast/test"
-    "include/xrpl/beast/unit_test"
-    "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
-    DEPENDENCIES
-    xrpld
-    xrpl.tests)
+        "src/test"
+        "src/tests"
+        "include/xrpl/beast/test"
+        "include/xrpl/beast/unit_test"
+        "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES xrpld xrpl.tests
+)
 
 add_code_coverage_to_target(opts INTERFACE)
diff --git a/cmake/XrplDocs.cmake b/cmake/XrplDocs.cmake
index 4892e390ce..7b3e9b3b30 100644
--- a/cmake/XrplDocs.cmake
+++ b/cmake/XrplDocs.cmake
@@ -2,71 +2,90 @@
    docs target (optional)
 #]===================================================================]
 
-if (NOT only_docs)
+if(NOT only_docs)
     return()
-endif ()
+endif()
 
 find_package(Doxygen)
-if (NOT TARGET Doxygen::doxygen)
+if(NOT TARGET Doxygen::doxygen)
     message(STATUS "doxygen executable not found -- skipping docs target")
     return()
-endif ()
+endif()
 
 set(doxygen_output_directory "${CMAKE_BINARY_DIR}/docs")
 set(doxygen_include_path "${CMAKE_CURRENT_SOURCE_DIR}/src")
 set(doxygen_index_file "${doxygen_output_directory}/html/index.html")
 set(doxyfile "${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile")
 
-file(GLOB_RECURSE
-     doxygen_input
-     docs/*.md
-     include/*.h
-     include/*.cpp
-     include/*.md
-     src/*.h
-     src/*.cpp
-     src/*.md
-     Builds/*.md
-     *.md)
+file(
+    GLOB_RECURSE doxygen_input
+    docs/*.md
+    include/*.h
+    include/*.cpp
+    include/*.md
+    src/*.h
+    src/*.cpp
+    src/*.md
+    Builds/*.md
+    *.md
+)
 list(APPEND doxygen_input external/README.md)
 set(dependencies "${doxygen_input}" "${doxyfile}")
 
-function (verbose_find_path variable name)
+function(verbose_find_path variable name)
     # find_path sets a CACHE variable, so don't try using a "local" variable.
     find_path(${variable} "${name}" ${ARGN})
-    if (NOT ${variable})
+    if(NOT ${variable})
         message(NOTICE "could not find ${name}")
-    else ()
+    else()
         message(STATUS "found ${name}: ${${variable}}/${name}")
-    endif ()
-endfunction ()
+    endif()
+endfunction()
 
-verbose_find_path(doxygen_plantuml_jar_path plantuml.jar PATH_SUFFIXES share/plantuml)
+verbose_find_path(
+    doxygen_plantuml_jar_path
+    plantuml.jar
+    PATH_SUFFIXES share/plantuml
+)
 verbose_find_path(doxygen_dot_path dot)
 
 # https://en.cppreference.com/w/Cppreference:Archives
 # https://stackoverflow.com/questions/60822559/how-to-move-a-file-download-from-configure-step-to-build-step
 set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
-file(WRITE "${download_script}"
-     "file(DOWNLOAD \
+file(
+    WRITE "${download_script}"
+    "file(DOWNLOAD \
     https://github.com/PeterFeicht/cppreference-doc/releases/download/v20250209/html-book-20250209.zip \
     ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
     EXPECTED_HASH MD5=bda585f72fbca4b817b29a3d5746567b \
   )\n \
   execute_process( \
     COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \
-  )\n")
+  )\n"
+)
 set(tagfile "${CMAKE_BINARY_DIR}/docs/cppreference-doxygen-web.tag.xml")
-add_custom_command(OUTPUT "${tagfile}" COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
-                   WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs")
+add_custom_command(
+    OUTPUT "${tagfile}"
+    COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs"
+)
 set(doxygen_tagfiles "${tagfile}=http://en.cppreference.com/w/")
 
 add_custom_command(
     OUTPUT "${doxygen_index_file}"
-    COMMAND "${CMAKE_COMMAND}" -E env "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
-            "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}" "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
-            "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
-            "DOXYGEN_DOT_PATH=${doxygen_dot_path}" "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
+    COMMAND
+        "${CMAKE_COMMAND}" -E env
+        "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
+        "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}"
+        "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
+        "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
+        "DOXYGEN_DOT_PATH=${doxygen_dot_path}" "${DOXYGEN_EXECUTABLE}"
+        "${doxyfile}"
     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    DEPENDS "${dependencies}" "${tagfile}")
-add_custom_target(docs DEPENDS "${doxygen_index_file}" SOURCES "${dependencies}")
+    DEPENDS "${dependencies}" "${tagfile}"
+)
+add_custom_target(
+    docs
+    DEPENDS "${doxygen_index_file}"
+    SOURCES "${dependencies}"
+)
diff --git a/cmake/XrplInstall.cmake b/cmake/XrplInstall.cmake
index 4cbf381f87..339cdb51ec 100644
--- a/cmake/XrplInstall.cmake
+++ b/cmake/XrplInstall.cmake
@@ -2,77 +2,38 @@
    install stuff
 #]===================================================================]
 
-include(create_symbolic_link)
+include(GNUInstallDirs)
 
-# If no suffix is defined for executables (e.g. Windows uses .exe but Linux
-# and macOS use none), then explicitly set it to the empty string.
-if (NOT DEFINED suffix)
-    set(suffix "")
-endif ()
+if(is_root_project AND TARGET xrpld)
+    install(
+        TARGETS xrpld
+        RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT runtime
+    )
 
-install(TARGETS common
-                opts
-                xrpl_boost
-                xrpl_libs
-                xrpl_syslibs
-                xrpl.imports.main
-                xrpl.libpb
-                xrpl.libxrpl
-                xrpl.libxrpl.basics
-                xrpl.libxrpl.beast
-                xrpl.libxrpl.conditions
-                xrpl.libxrpl.core
-                xrpl.libxrpl.crypto
-                xrpl.libxrpl.json
-                xrpl.libxrpl.rdb
-                xrpl.libxrpl.ledger
-                xrpl.libxrpl.net
-                xrpl.libxrpl.nodestore
-                xrpl.libxrpl.protocol
-                xrpl.libxrpl.resource
-                xrpl.libxrpl.server
-                xrpl.libxrpl.shamap
-                xrpl.libxrpl.tx
-                antithesis-sdk-cpp
-        EXPORT XrplExports
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib
-        RUNTIME DESTINATION bin
-        INCLUDES
-        DESTINATION include)
+    install(
+        FILES "${CMAKE_CURRENT_SOURCE_DIR}/cfg/xrpld-example.cfg"
+        DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/xrpld"
+        RENAME xrpld.cfg
+        COMPONENT runtime
+    )
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+    install(
+        FILES "${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt"
+        DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/xrpld"
+        RENAME validators.txt
+        COMPONENT runtime
+    )
+endif()
 
-install(EXPORT XrplExports FILE XrplTargets.cmake NAMESPACE Xrpl:: DESTINATION lib/cmake/xrpl)
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version}
-                                 COMPATIBILITY SameMajorVersion)
+install(
+    TARGETS xrpl.libpb xrpl.libxrpl
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT development
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT development
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT development
+)
 
-if (is_root_project AND TARGET xrpld)
-    install(TARGETS xrpld RUNTIME DESTINATION bin)
-    set_target_properties(xrpld PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
-    # sample configs should not overwrite existing files
-    # install if-not-exists workaround as suggested by
-    # https://cmake.org/Bug/view.php?id=12646
-    install(CODE "
-    macro (copy_if_not_exists SRC DEST NEWNAME)
-      if (NOT EXISTS \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
-        file (INSTALL FILE_PERMISSIONS OWNER_READ OWNER_WRITE DESTINATION \"\${CMAKE_INSTALL_PREFIX}/\${DEST}\" FILES \"\${SRC}\" RENAME \"\${NEWNAME}\")
-      else ()
-        message (\"-- Skipping : \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
-      endif ()
-    endmacro()
-    copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/xrpld-example.cfg\" etc xrpld.cfg)
-    copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt\" etc validators.txt)
-  ")
-    install(CODE "
-    set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
-    include(create_symbolic_link)
-    create_symbolic_link(xrpld${suffix} \
-       \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/rippled${suffix})
-  ")
-endif ()
-
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
-              ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake DESTINATION lib/cmake/xrpl)
+install(
+    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT development
+)
diff --git a/cmake/XrplInterface.cmake b/cmake/XrplInterface.cmake
index dbf907c7b4..7add613f5a 100644
--- a/cmake/XrplInterface.cmake
+++ b/cmake/XrplInterface.cmake
@@ -5,47 +5,55 @@
 include(CompilationEnv)
 
 # Set defaults for optional variables to avoid uninitialized variable warnings
-if (NOT DEFINED voidstar)
+if(NOT DEFINED voidstar)
     set(voidstar OFF)
-endif ()
+endif()
 
 add_library(opts INTERFACE)
 add_library(Xrpl::opts ALIAS opts)
 target_compile_definitions(
     opts
-    INTERFACE BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
-              BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
-              BOOST_CONTAINER_FWD_BAD_DEQUE
-              HAS_UNCAUGHT_EXCEPTIONS=1
-              $<$<BOOL:${boost_show_deprecated}>:
-              BOOST_ASIO_NO_DEPRECATED
-              BOOST_FILESYSTEM_NO_DEPRECATED
-              >
-              $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
-              BOOST_COROUTINES_NO_DEPRECATION_WARNING
-              BOOST_BEAST_ALLOW_DEPRECATED
-              BOOST_FILESYSTEM_DEPRECATED
-              >
-              $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
-              $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
-              $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
-              $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
+    INTERFACE
+        BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
+        BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+        BOOST_CONTAINER_FWD_BAD_DEQUE
+        HAS_UNCAUGHT_EXCEPTIONS=1
+        $<$<BOOL:${boost_show_deprecated}>:
+        BOOST_ASIO_NO_DEPRECATED
+        BOOST_FILESYSTEM_NO_DEPRECATED
+        >
+        $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+        BOOST_COROUTINES2_NO_DEPRECATION_WARNING
+        BOOST_BEAST_ALLOW_DEPRECATED
+        BOOST_FILESYSTEM_DEPRECATED
+        >
+        $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
+        $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
+        $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
+        $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>
+)
 target_compile_options(
     opts
-    INTERFACE $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
-              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
-              $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-              $<$<BOOL:${profile}>:-pg>
-              $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+    INTERFACE
+        $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+        $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
+        $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg>
-                                     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+target_link_libraries(
+    opts
+    INTERFACE
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-if (jemalloc)
+if(jemalloc)
     find_package(jemalloc REQUIRED)
     target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
     target_link_libraries(opts INTERFACE jemalloc::jemalloc)
-endif ()
+endif()
 
 #[===================================================================[
    xrpld transitive library deps via an interface library
@@ -55,31 +63,33 @@ add_library(xrpl_syslibs INTERFACE)
 add_library(Xrpl::syslibs ALIAS xrpl_syslibs)
 target_link_libraries(
     xrpl_syslibs
-    INTERFACE $<$<BOOL:${is_msvc}>:
-              legacy_stdio_definitions.lib
-              Shlwapi
-              kernel32
-              user32
-              gdi32
-              winspool
-              comdlg32
-              advapi32
-              shell32
-              ole32
-              oleaut32
-              uuid
-              odbc32
-              odbccp32
-              crypt32
-              >
-              $<$<NOT:$<BOOL:${is_msvc}>>:dl>
-              $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>)
+    INTERFACE
+        $<$<BOOL:${is_msvc}>:
+        legacy_stdio_definitions.lib
+        Shlwapi
+        kernel32
+        user32
+        gdi32
+        winspool
+        comdlg32
+        advapi32
+        shell32
+        ole32
+        oleaut32
+        uuid
+        odbc32
+        odbccp32
+        crypt32
+        >
+        $<$<NOT:$<BOOL:${is_msvc}>>:dl>
+        $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>
+)
 
-if (NOT is_msvc)
+if(NOT is_msvc)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads)
     target_link_libraries(xrpl_syslibs INTERFACE Threads::Threads)
-endif ()
+endif()
 
 add_library(xrpl_libs INTERFACE)
 add_library(Xrpl::libs ALIAS xrpl_libs)
diff --git a/cmake/XrplSanitizers.cmake b/cmake/XrplSanitizers.cmake
index 6ddc0b7e7d..f9630f6856 100644
--- a/cmake/XrplSanitizers.cmake
+++ b/cmake/XrplSanitizers.cmake
@@ -44,23 +44,26 @@ include(CompilationEnv)
 
 # Read environment variable
 set(SANITIZERS "")
-if (DEFINED ENV{SANITIZERS})
+if(DEFINED ENV{SANITIZERS})
     set(SANITIZERS "$ENV{SANITIZERS}")
-endif ()
+endif()
 
 # Set SANITIZERS_ENABLED flag for use in other modules
-if (SANITIZERS MATCHES "address|thread|undefinedbehavior")
+if(SANITIZERS MATCHES "address|thread|undefinedbehavior")
     set(SANITIZERS_ENABLED TRUE)
-else ()
+else()
     set(SANITIZERS_ENABLED FALSE)
     return()
-endif ()
+endif()
 
 # Sanitizers are not supported on Windows/MSVC
-if (is_msvc)
-    message(FATAL_ERROR "Sanitizers are not supported on Windows/MSVC. "
-                        "Please unset the SANITIZERS environment variable.")
-endif ()
+if(is_msvc)
+    message(
+        FATAL_ERROR
+        "Sanitizers are not supported on Windows/MSVC. "
+        "Please unset the SANITIZERS environment variable."
+    )
+endif()
 
 message(STATUS "Configuring sanitizers: ${SANITIZERS}")
 
@@ -74,24 +77,30 @@ set(san_list "${SANITIZERS}")
 string(REPLACE "," ";" san_list "${san_list}")
 separate_arguments(san_list)
 
-foreach (san IN LISTS san_list)
-    if (san STREQUAL "address")
+foreach(san IN LISTS san_list)
+    if(san STREQUAL "address")
         set(enable_asan TRUE)
-    elseif (san STREQUAL "thread")
+    elseif(san STREQUAL "thread")
         set(enable_tsan TRUE)
-    elseif (san STREQUAL "undefinedbehavior")
+    elseif(san STREQUAL "undefinedbehavior")
         set(enable_ubsan TRUE)
-    else ()
-        message(FATAL_ERROR "Unsupported sanitizer type: ${san}"
-                            "Supported: address, thread, undefinedbehavior and their combinations.")
-    endif ()
-endforeach ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported sanitizer type: ${san}"
+            "Supported: address, thread, undefinedbehavior and their combinations."
+        )
+    endif()
+endforeach()
 
 # Validate sanitizer compatibility
-if (enable_asan AND enable_tsan)
-    message(FATAL_ERROR "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
-                        "Use 'address' or 'thread', optionally with 'undefinedbehavior'.")
-endif ()
+if(enable_asan AND enable_tsan)
+    message(
+        FATAL_ERROR
+        "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
+        "Use 'address' or 'thread', optionally with 'undefinedbehavior'."
+    )
+endif()
 
 # Frame pointer is required for meaningful stack traces. Sanitizers recommend minimum of -O1 for reasonable performance
 set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
@@ -99,66 +108,79 @@ set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
 # Build the sanitizer flags list
 set(SANITIZER_TYPES)
 
-if (enable_asan)
+if(enable_asan)
     list(APPEND SANITIZER_TYPES "address")
-elseif (enable_tsan)
+elseif(enable_tsan)
     list(APPEND SANITIZER_TYPES "thread")
-endif ()
+endif()
 
-if (enable_ubsan)
+if(enable_ubsan)
     # UB sanitizer flags
     list(APPEND SANITIZER_TYPES "undefined" "float-divide-by-zero")
-    if (is_clang)
+    if(is_clang)
         # Clang supports additional UB checks. More info here
         # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
         list(APPEND SANITIZER_TYPES "unsigned-integer-overflow")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # Configure code model for GCC on amd64 Use large code model for ASAN to avoid relocation errors Use medium code model
 # for TSAN (large is not compatible with TSAN)
 set(SANITIZERS_RELOCATION_FLAGS)
 
 # Compiler-specific configuration
-if (is_gcc)
+if(is_gcc)
     # Disable mold, gold and lld linkers for GCC with sanitizers Use default linker (bfd/ld) which is more lenient with
     # mixed code models This is needed since the size of instrumented binary exceeds the limits set by mold, lld and
     # gold linkers
     set(use_mold OFF CACHE BOOL "Use mold linker" FORCE)
     set(use_gold OFF CACHE BOOL "Use gold linker" FORCE)
     set(use_lld OFF CACHE BOOL "Use lld linker" FORCE)
-    message(STATUS "  Disabled mold, gold, and lld linkers for GCC with sanitizers")
+    message(
+        STATUS
+        "  Disabled mold, gold, and lld linkers for GCC with sanitizers"
+    )
 
     # Suppress false positive warnings in GCC with stringop-overflow
     list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-stringop-overflow")
 
-    if (is_amd64 AND enable_asan)
+    if(is_amd64 AND enable_asan)
         message(STATUS "  Using large code model (-mcmodel=large)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=large")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=large")
-    elseif (enable_tsan)
+    elseif(enable_tsan)
         # GCC doesn't support atomic_thread_fence with tsan. Suppress warnings.
         list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-tsan")
         message(STATUS "  Using medium code model (-mcmodel=medium)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=medium")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=medium")
-    endif ()
+    endif()
 
     # Join sanitizer flags with commas for -fsanitize option
     list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR)
 
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-    set(SANITIZERS_LINK_FLAGS "${SANITIZERS_RELOCATION_FLAGS}" "-fsanitize=${SANITIZER_TYPES_STR}")
-
-elseif (is_clang)
+    set(SANITIZERS_LINK_FLAGS
+        "${SANITIZERS_RELOCATION_FLAGS}"
+        "-fsanitize=${SANITIZER_TYPES_STR}"
+    )
+elseif(is_clang)
     # Add ignorelist for Clang (GCC doesn't support this) Use CMAKE_SOURCE_DIR to get the path to the ignorelist
-    set(IGNORELIST_PATH "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt")
-    if (NOT EXISTS "${IGNORELIST_PATH}")
-        message(FATAL_ERROR "Sanitizer ignorelist not found: ${IGNORELIST_PATH}")
-    endif ()
+    set(IGNORELIST_PATH
+        "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt"
+    )
+    if(NOT EXISTS "${IGNORELIST_PATH}")
+        message(
+            FATAL_ERROR
+            "Sanitizer ignorelist not found: ${IGNORELIST_PATH}"
+        )
+    endif()
 
-    list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize-ignorelist=${IGNORELIST_PATH}")
+    list(
+        APPEND SANITIZERS_COMPILE_FLAGS
+        "-fsanitize-ignorelist=${IGNORELIST_PATH}"
+    )
     message(STATUS "  Using sanitizer ignorelist: ${IGNORELIST_PATH}")
 
     # Join sanitizer flags with commas for -fsanitize option
@@ -167,31 +189,35 @@ elseif (is_clang)
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
     set(SANITIZERS_LINK_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-endif ()
+endif()
 
 message(STATUS "  Compile flags: ${SANITIZERS_COMPILE_FLAGS}")
 message(STATUS "  Link flags: ${SANITIZERS_LINK_FLAGS}")
 
 # Apply the sanitizer flags to the 'common' interface library This is the same library used by XrplCompiler.cmake
-target_compile_options(common INTERFACE $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
-                                        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>)
+target_compile_options(
+    common
+    INTERFACE
+        $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>
+)
 
 # Apply linker flags
 target_link_options(common INTERFACE ${SANITIZERS_LINK_FLAGS})
 
 # Define SANITIZERS macro for BuildInfo.cpp
 set(sanitizers_list)
-if (enable_asan)
+if(enable_asan)
     list(APPEND sanitizers_list "ASAN")
-endif ()
-if (enable_tsan)
+endif()
+if(enable_tsan)
     list(APPEND sanitizers_list "TSAN")
-endif ()
-if (enable_ubsan)
+endif()
+if(enable_ubsan)
     list(APPEND sanitizers_list "UBSAN")
-endif ()
+endif()
 
-if (sanitizers_list)
+if(sanitizers_list)
     list(JOIN sanitizers_list "." sanitizers_str)
     target_compile_definitions(common INTERFACE SANITIZERS=${sanitizers_str})
-endif ()
+endif()
diff --git a/cmake/XrplSanity.cmake b/cmake/XrplSanity.cmake
index 489ad026e1..a35645ad5c 100644
--- a/cmake/XrplSanity.cmake
+++ b/cmake/XrplSanity.cmake
@@ -7,40 +7,56 @@ include(CompilationEnv)
 get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
-if (NOT is_multiconfig)
-    if (NOT CMAKE_BUILD_TYPE)
+if(NOT is_multiconfig)
+    if(NOT CMAKE_BUILD_TYPE)
         message(STATUS "Build type not specified - defaulting to Release")
         set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
-    elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
+    elseif(
+        NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release)
+    )
         # for simplicity, these are the only two config types we care about. Limiting the build types simplifies dealing
         # with external project builds especially
-        message(FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
-    endif ()
-endif ()
+        message(
+            FATAL_ERROR
+            " *** Only Debug or Release build types are currently supported ***"
+        )
+    endif()
+endif()
 
-if (is_clang) # both Clang and AppleClang
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS
-                                                        16.0)
+if(is_clang) # both Clang and AppleClang
+    if(
+        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+        AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0
+    )
         message(FATAL_ERROR "This project requires clang 16 or later")
-    endif ()
-elseif (is_gcc)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+    endif()
+elseif(is_gcc)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
         message(FATAL_ERROR "This project requires GCC 12 or later")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # check for in-source build and fail
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-    message(FATAL_ERROR "Builds (in-source) are not allowed in "
-                        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
-                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
+if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+    message(
+        FATAL_ERROR
+        "Builds (in-source) are not allowed in "
+        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
+        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
     )
-endif ()
+endif()
 
-if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
+if(MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
     message(FATAL_ERROR "Visual Studio 32-bit build is not supported.")
-endif ()
+endif()
 
-if (APPLE AND NOT HOMEBREW)
+if(voidstar AND NOT is_amd64)
+    message(
+        FATAL_ERROR
+        "The voidstar library only supported on amd64/x86_64. Detected archictecture was: ${CMAKE_SYSTEM_PROCESSOR}"
+    )
+endif()
+
+if(APPLE AND NOT HOMEBREW)
     find_program(HOMEBREW brew)
-endif ()
+endif()
diff --git a/cmake/XrplSettings.cmake b/cmake/XrplSettings.cmake
index 5c753fdcda..44a727a994 100644
--- a/cmake/XrplSettings.cmake
+++ b/cmake/XrplSettings.cmake
@@ -5,59 +5,67 @@
 include(CompilationEnv)
 
 set(is_ci FALSE)
-if (DEFINED ENV{CI})
-    if ("$ENV{CI}" STREQUAL "true")
+if(DEFINED ENV{CI})
+    if("$ENV{CI}" STREQUAL "true")
         set(is_ci TRUE)
-    endif ()
-endif ()
+    endif()
+endif()
 
 get_directory_property(has_parent PARENT_DIRECTORY)
-if (has_parent)
+if(has_parent)
     set(is_root_project OFF)
-else ()
+else()
     set(is_root_project ON)
-endif ()
+endif()
 
 option(assert "Enables asserts, even in release builds" OFF)
 
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if (tests)
+if(tests)
     # This setting allows making a separate workflow to test fees other than default 10
-    if (NOT UNIT_TEST_REFERENCE_FEE)
+    if(NOT UNIT_TEST_REFERENCE_FEE)
         set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-    endif ()
-endif ()
+    endif()
+endif()
 
 option(unity "Creates a build using UNITY support in cmake." OFF)
-if (unity)
-    if (NOT is_ci)
+if(unity)
+    if(NOT is_ci)
         set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-    endif ()
+    endif()
     set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
-endif ()
+endif()
 
-if (is_clang AND is_linux)
+if(is_clang AND is_linux)
     option(voidstar "Enable Antithesis instrumentation." OFF)
-endif ()
+endif()
 
-if (is_gcc OR is_clang)
+if(is_gcc OR is_clang)
     include(ProcessorCount)
     ProcessorCount(PROCESSOR_COUNT)
 
     option(coverage "Generates coverage info." OFF)
     option(profile "Add profiling flags" OFF)
-    set(coverage_format "html-details" CACHE STRING "Output format of the coverage report.")
-    set(coverage_extra_args "" CACHE STRING "Additional arguments to pass to gcovr.")
+    set(coverage_format
+        "html-details"
+        CACHE STRING
+        "Output format of the coverage report."
+    )
+    set(coverage_extra_args
+        ""
+        CACHE STRING
+        "Additional arguments to pass to gcovr."
+    )
     option(wextra "compile with extra gcc/clang warnings enabled" ON)
-else ()
+else()
     set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
     set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
     set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif ()
+endif()
 
-if (is_linux AND NOT SANITIZER)
+if(is_linux AND NOT SANITIZER)
     option(BUILD_SHARED_LIBS "build shared xrpl libraries" OFF)
     option(static "link protobuf, openssl, libc++, and boost statically" ON)
     option(perf "Enables flags that assist with perf recording" OFF)
@@ -65,53 +73,83 @@ if (is_linux AND NOT SANITIZER)
     option(use_mold "enables detection of mold (binutils) linker" ON)
     # Set a default value for the log flag based on the build type. This provides a sensible default (on for debug, off
     # for release) while still allowing the user to override it for any build.
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         set(TRUNCATED_LOGS_DEFAULT ON)
-    else ()
+    else()
         set(TRUNCATED_LOGS_DEFAULT OFF)
-    endif ()
-    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux."
-           ${TRUNCATED_LOGS_DEFAULT})
-    if (TRUNCATED_THREAD_NAME_LOGS)
+    endif()
+    option(
+        TRUNCATED_THREAD_NAME_LOGS
+        "Show warnings about truncated thread names on Linux."
+        ${TRUNCATED_LOGS_DEFAULT}
+    )
+    if(TRUNCATED_THREAD_NAME_LOGS)
         add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
-    endif ()
-else ()
+    endif()
+else()
     # we are not ready to allow shared-libs on windows because it would require export declarations. On macos it's more
     # feasible, but static openssl produces odd linker errors, thus we disable shared lib builds for now.
-    set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared xrpl libraries - OFF for win/macos" FORCE)
+    set(BUILD_SHARED_LIBS
+        OFF
+        CACHE BOOL
+        "build shared xrpl libraries - OFF for win/macos"
+        FORCE
+    )
     set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
     set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
     set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
     set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-endif ()
+endif()
 
-if (is_clang)
+if(is_clang)
     option(use_lld "enables detection of lld linker" ON)
-else ()
+else()
     set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif ()
+endif()
 
 option(jemalloc "Enables jemalloc for heap profiling" OFF)
 option(werr "treat warnings as errors" OFF)
-option(local_protobuf
-       "Force a local build of protobuf instead of looking for an installed version." OFF)
-option(local_grpc "Force a local build of gRPC instead of looking for an installed version." OFF)
+option(
+    local_protobuf
+    "Force a local build of protobuf instead of looking for an installed version."
+    OFF
+)
+option(
+    local_grpc
+    "Force a local build of gRPC instead of looking for an installed version."
+    OFF
+)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline
-       "Prevents unit test definitions from being inserted into global table" OFF)
-option(single_io_service_thread "Restricts the number of threads calling io_context::run to one. \
-  This can be useful when debugging." OFF)
-option(boost_show_deprecated "Allow boost to fail on deprecated usage. Only useful if you're trying\
-  to find deprecated calls." OFF)
+option(
+    beast_no_unit_test_inline
+    "Prevents unit test definitions from being inserted into global table"
+    OFF
+)
+option(
+    single_io_service_thread
+    "Restricts the number of threads calling io_context::run to one. \
+  This can be useful when debugging."
+    OFF
+)
+option(
+    boost_show_deprecated
+    "Allow boost to fail on deprecated usage. Only useful if you're trying\
+  to find deprecated calls."
+    OFF
+)
 
-if (WIN32)
-    option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else ()
+if(WIN32)
+    option(
+        beast_disable_autolink
+        "Disables autolinking of system libraries on WIN32"
+        OFF
+    )
+else()
     set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif ()
+endif()
 
-if (coverage)
+if(coverage)
     message(STATUS "coverage build requested - forcing Debug build")
     set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif ()
+endif()
diff --git a/cmake/XrplValidatorKeys.cmake b/cmake/XrplValidatorKeys.cmake
index 58672aada5..0e511b6a88 100644
--- a/cmake/XrplValidatorKeys.cmake
+++ b/cmake/XrplValidatorKeys.cmake
@@ -1,20 +1,26 @@
-option(validator_keys
-       "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
-       OFF)
+option(
+    validator_keys
+    "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
+    OFF
+)
 
-if (validator_keys)
+if(validator_keys)
     git_branch(current_branch)
     # default to tracking VK master branch unless we are on release
-    if (NOT (current_branch STREQUAL "release"))
+    if(NOT (current_branch STREQUAL "release"))
         set(current_branch "master")
-    endif ()
+    endif()
     message(STATUS "Tracking ValidatorKeys branch: ${current_branch}")
 
     FetchContent_Declare(
-        validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-        GIT_TAG "${current_branch}")
+        validator_keys
+        GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+        GIT_TAG "${current_branch}"
+    )
     FetchContent_MakeAvailable(validator_keys)
-    set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+    set_target_properties(
+        validator-keys
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+    )
     install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-endif ()
+endif()
diff --git a/cmake/XrplVersion.cmake b/cmake/XrplVersion.cmake
index 6eeda7b1eb..595b750d69 100644
--- a/cmake/XrplVersion.cmake
+++ b/cmake/XrplVersion.cmake
@@ -3,13 +3,13 @@
 #]===================================================================]
 
 file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
-foreach (line_ ${BUILD_INFO})
-    if (line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
+foreach(line_ ${BUILD_INFO})
+    if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
         set(xrpld_version ${CMAKE_MATCH_1})
-    endif ()
-endforeach ()
-if (xrpld_version)
+    endif()
+endforeach()
+if(xrpld_version)
     message(STATUS "xrpld version: ${xrpld_version}")
-else ()
+else()
     message(FATAL_ERROR "unable to determine xrpld version")
-endif ()
+endif()
diff --git a/cmake/add_module.cmake b/cmake/add_module.cmake
index 73618e8be3..316d6c627b 100644
--- a/cmake/add_module.cmake
+++ b/cmake/add_module.cmake
@@ -12,15 +12,29 @@ include(isolate_headers)
 # add_module(parent a)
 # add_module(parent b)
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
-function (add_module parent name)
+function(add_module parent name)
     set(target ${PROJECT_NAME}.lib${parent}.${name})
     add_library(${target} OBJECT)
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS
-         "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp"
+    )
     target_sources(${target} PRIVATE ${sources})
-    target_include_directories(${target} PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/include"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}" PUBLIC)
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}" PRIVATE)
-endfunction ()
+    target_include_directories(
+        ${target}
+        PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
+        PUBLIC
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/src"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
+        PRIVATE
+    )
+endfunction()
diff --git a/cmake/create_symbolic_link.cmake b/cmake/create_symbolic_link.cmake
index 82ca915f5c..0cd8e1f567 100644
--- a/cmake/create_symbolic_link.cmake
+++ b/cmake/create_symbolic_link.cmake
@@ -1,19 +1,21 @@
 # file(CREATE_SYMLINK) only works on Windows with administrator privileges. https://stackoverflow.com/a/61244115/618906
-function (create_symbolic_link target link)
-    if (WIN32)
-        if (NOT IS_SYMLINK "${link}")
-            if (NOT IS_ABSOLUTE "${target}")
+function(create_symbolic_link target link)
+    if(WIN32)
+        if(NOT IS_SYMLINK "${link}")
+            if(NOT IS_ABSOLUTE "${target}")
                 # Relative links work do not work on Windows.
                 set(target "${link}/../${target}")
-            endif ()
+            endif()
             file(TO_NATIVE_PATH "${target}" target)
             file(TO_NATIVE_PATH "${link}" link)
-            execute_process(COMMAND cmd.exe /c mklink /J "${link}" "${target}")
-        endif ()
-    else ()
+            execute_process(
+                COMMAND cmd.exe /c mklink /J "${link}" "${target}"
+            )
+        endif()
+    else()
         file(CREATE_LINK "${target}" "${link}" SYMBOLIC)
-    endif ()
-    if (NOT IS_SYMLINK "${link}")
+    endif()
+    if(NOT IS_SYMLINK "${link}")
         message(ERROR "failed to create symlink: <${link}>")
-    endif ()
-endfunction ()
+    endif()
+endfunction()
diff --git a/cmake/deps/Boost.cmake b/cmake/deps/Boost.cmake
index a7b145364d..7594ddc806 100644
--- a/cmake/deps/Boost.cmake
+++ b/cmake/deps/Boost.cmake
@@ -1,45 +1,63 @@
 include(CompilationEnv)
 include(XrplSanitizers)
 
-find_package(Boost REQUIRED
-             COMPONENTS chrono
-                        container
-                        coroutine
-                        date_time
-                        filesystem
-                        json
-                        program_options
-                        regex
-                        system
-                        thread)
+find_package(
+    Boost
+    REQUIRED
+    COMPONENTS
+        chrono
+        container
+        context
+        date_time
+        filesystem
+        json
+        program_options
+        regex
+        system
+        thread
+)
 
 add_library(xrpl_boost INTERFACE)
 add_library(Xrpl::boost ALIAS xrpl_boost)
 
 target_link_libraries(
     xrpl_boost
-    INTERFACE Boost::headers
-              Boost::chrono
-              Boost::container
-              Boost::coroutine
-              Boost::date_time
-              Boost::filesystem
-              Boost::json
-              Boost::process
-              Boost::program_options
-              Boost::regex
-              Boost::thread)
-if (Boost_COMPILER)
+    INTERFACE
+        Boost::headers
+        Boost::chrono
+        Boost::container
+        Boost::context
+        Boost::date_time
+        Boost::filesystem
+        Boost::json
+        Boost::process
+        Boost::program_options
+        Boost::regex
+        Boost::thread
+)
+if(Boost_COMPILER)
     target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
-endif ()
-if (SANITIZERS_ENABLED AND is_clang)
-    # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
-    if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
-        get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
-    endif ()
-    message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
-    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
-    target_compile_options(
-        opts INTERFACE # ignore boost headers for sanitizing
-                       -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-endif ()
+endif()
+
+# GCC 14+ has a false positive -Wuninitialized warning in Boost.Coroutine2's
+# state.hpp when compiled with -O3. This is due to GCC's intentional behavior
+# change (Bug #98871, #119388) where warnings from inlined system header code
+# are no longer suppressed by -isystem. The warning occurs in operator|= in
+# boost/coroutine2/detail/state.hpp when inlined from push_control_block::destroy().
+# See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119388
+if(is_gcc AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+    target_compile_options(xrpl_boost INTERFACE -Wno-uninitialized)
+endif()
+
+# Boost.Context's ucontext backend has ASAN fiber-switching annotations
+# (start/finish_switch_fiber) that are compiled in when BOOST_USE_ASAN is defined.
+# This tells ASAN about coroutine stack switches, preventing false positive
+# stack-use-after-scope errors. BOOST_USE_UCONTEXT ensures the ucontext backend
+# is selected (fcontext does not support ASAN annotations).
+# These defines must match what Boost was compiled with (see conan/profiles/sanitizers).
+if(enable_asan)
+    target_compile_definitions(
+        xrpl_boost
+        INTERFACE BOOST_USE_ASAN BOOST_USE_UCONTEXT
+    )
+endif()
diff --git a/cmake/isolate_headers.cmake b/cmake/isolate_headers.cmake
index ef53b3f20a..4053cd6831 100644
--- a/cmake/isolate_headers.cmake
+++ b/cmake/isolate_headers.cmake
@@ -37,7 +37,7 @@ include(create_symbolic_link)
 # `${CMAKE_CURRENT_BINARY_DIR}/include/${target}`.
 #
 # isolate_headers(target A B scope)
-function (isolate_headers target A B scope)
+function(isolate_headers target A B scope)
     file(RELATIVE_PATH C "${A}" "${B}")
     set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
     set(Y "${X}/${C}")
@@ -45,4 +45,4 @@ function (isolate_headers target A B scope)
     file(MAKE_DIRECTORY "${parent}")
     create_symbolic_link("${B}" "${Y}")
     target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
-endfunction ()
+endfunction()
diff --git a/cmake/target_link_modules.cmake b/cmake/target_link_modules.cmake
index bcd80591b0..a923d81c66 100644
--- a/cmake/target_link_modules.cmake
+++ b/cmake/target_link_modules.cmake
@@ -6,9 +6,9 @@
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
 # add_library(project.libparent)
 # target_link_modules(parent PUBLIC a b)
-function (target_link_modules parent scope)
+function(target_link_modules parent scope)
     set(library ${PROJECT_NAME}.lib${parent})
-    foreach (name ${ARGN})
+    foreach(name ${ARGN})
         set(module ${library}.${name})
         get_target_property(sources ${library} SOURCES)
         list(LENGTH sources before)
@@ -17,8 +17,11 @@ function (target_link_modules parent scope)
         list(REMOVE_ITEM sources ${dupes})
         list(LENGTH sources after)
         math(EXPR actual "${before} - ${after}")
-        message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
+        message(
+            STATUS
+            "${module} with ${expected} sources took ${actual} sources from ${library}"
+        )
         set_target_properties(${library} PROPERTIES SOURCES "${sources}")
         target_link_libraries(${library} ${scope} ${module})
-    endforeach ()
-endfunction ()
+    endforeach()
+endfunction()
diff --git a/cmake/target_protobuf_sources.cmake b/cmake/target_protobuf_sources.cmake
index bb5de02b53..2a04de9e11 100644
--- a/cmake/target_protobuf_sources.cmake
+++ b/cmake/target_protobuf_sources.cmake
@@ -35,20 +35,31 @@ find_package(Protobuf REQUIRED)
 #     This prefix should appear at the start of all your consumer includes.
 # ARGN:
 #     A list of .proto files.
-function (target_protobuf_sources target prefix)
+function(target_protobuf_sources target prefix)
     set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
     file(MAKE_DIRECTORY "${dir}/${prefix}")
 
-    protobuf_generate(TARGET ${target} PROTOC_OUT_DIR "${dir}/${prefix}" "${ARGN}")
+    protobuf_generate(
+        TARGET ${target}
+        PROTOC_OUT_DIR "${dir}/${prefix}"
+        "${ARGN}"
+    )
     target_include_directories(
-        ${target} SYSTEM
+        ${target}
+        SYSTEM
         PUBLIC # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<BUILD_INTERFACE:${dir}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<BUILD_INTERFACE:${dir}/${prefix}>
-               # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>)
-    install(DIRECTORY ${dir}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
-endfunction ()
+            $<BUILD_INTERFACE:${dir}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<BUILD_INTERFACE:${dir}/${prefix}>
+            # Allows #include <package/path/to/file.proto> used by consumer files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
+    )
+    install(
+        DIRECTORY ${dir}/
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        FILES_MATCHING
+        PATTERN "*.h"
+    )
+endfunction()
diff --git a/conan/profiles/sanitizers b/conan/profiles/sanitizers
index d7a622359a..6d37425f43 100644
--- a/conan/profiles/sanitizers
+++ b/conan/profiles/sanitizers
@@ -7,16 +7,21 @@ include(default)
     {% if compiler == "gcc" %}
         {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %}
             {% set sanitizer_list = [] %}
+            {% set defines = [] %}
             {% set model_code = "" %}
             {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1", "-Wno-stringop-overflow"] %}
 
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
                 {% set model_code = "-mcmodel=large" %}
+                {% set _ = defines.append("BOOST_USE_ASAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
                 {% set model_code = "-mcmodel=medium" %}
                 {% set _ = extra_cxxflags.append("-Wno-tsan") %}
+                {% set _ = defines.append("BOOST_USE_TSAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
@@ -29,16 +34,22 @@ include(default)
             tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}']
             tools.build:sharedlinkflags+=['{{sanitizer_flags}}']
             tools.build:exelinkflags+=['{{sanitizer_flags}}']
+            tools.build:defines+={{defines}}
         {% endif %}
     {% elif compiler == "apple-clang" or compiler == "clang" %}
         {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %}
             {% set sanitizer_list = [] %}
+            {% set defines = [] %}
             {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1"] %}
 
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
+                {% set _ = defines.append("BOOST_USE_ASAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
+                {% set _ = defines.append("BOOST_USE_TSAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
@@ -52,8 +63,24 @@ include(default)
             tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}']
             tools.build:sharedlinkflags+=['{{sanitizer_flags}}']
             tools.build:exelinkflags+=['{{sanitizer_flags}}']
+            tools.build:defines+={{defines}}
         {% endif %}
     {% endif %}
 {% endif %}
 
-tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags"]
+tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"]
+
+[options]
+{% if sanitizers %}
+    {% if "address" in sanitizers %}
+        # Build Boost.Context with ucontext backend (not fcontext) so that
+        # ASAN fiber-switching annotations (__sanitizer_start/finish_switch_fiber)
+        # are compiled into the library. fcontext (assembly) has no ASAN support.
+        # define=BOOST_USE_ASAN=1 is critical: it must be defined when building
+        # Boost.Context itself so the ucontext backend compiles in the ASAN annotations.
+        boost/*:extra_b2_flags=context-impl=ucontext address-sanitizer=on define=BOOST_USE_ASAN=1
+        boost/*:without_context=False
+        # Boost stacktrace fails to build with some sanitizers
+        boost/*:without_stacktrace=True
+    {% endif %}
+{% endif %}
diff --git a/conanfile.py b/conanfile.py
index 7300b537d9..e16d7eb69e 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,4 +1,5 @@
 import re
+import os
 
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 
@@ -57,6 +58,9 @@ class Xrpl(ConanFile):
         "tests": False,
         "unity": False,
         "xrpld": False,
+        "boost/*:without_context": False,
+        "boost/*:without_coroutine": True,
+        "boost/*:without_coroutine2": False,
         "date/*:header_only": True,
         "ed25519/*:shared": False,
         "grpc/*:shared": False,
@@ -126,6 +130,12 @@ class Xrpl(ConanFile):
         if self.settings.compiler in ["clang", "gcc"]:
             self.options["boost"].without_cobalt = True
 
+        # Check if environment variable exists
+        if "SANITIZERS" in os.environ:
+            sanitizers = os.environ["SANITIZERS"]
+            if "address" in sanitizers.lower():
+                self.default_options["fPIC"] = False
+
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
         transitive_headers_opt = (
@@ -196,7 +206,7 @@ class Xrpl(ConanFile):
             "boost::headers",
             "boost::chrono",
             "boost::container",
-            "boost::coroutine",
+            "boost::context",
             "boost::date_time",
             "boost::filesystem",
             "boost::json",
diff --git a/cspell.config.yaml b/cspell.config.yaml
index e2b20ac098..eeae3d12ff 100644
--- a/cspell.config.yaml
+++ b/cspell.config.yaml
@@ -99,6 +99,7 @@ words:
   - endmacro
   - exceptioned
   - Falco
+  - fcontext
   - finalizers
   - firewalled
   - fmtdur
@@ -111,6 +112,7 @@ words:
   - gpgcheck
   - gpgkey
   - hotwallet
+  - hwaddress
   - hwrap
   - ifndef
   - inequation
@@ -176,6 +178,8 @@ words:
   - nixfmt
   - nixos
   - nixpkgs
+  - NOLINT
+  - NOLINTNEXTLINE
   - nonxrp
   - noripple
   - nudb
diff --git a/docs/build/sanitizers.md b/docs/build/sanitizers.md
index 3f9809ae98..ac3a0cc865 100644
--- a/docs/build/sanitizers.md
+++ b/docs/build/sanitizers.md
@@ -89,8 +89,8 @@ cmake --build . --parallel 4
 **IMPORTANT**: ASAN with Boost produces many false positives. Use these options:
 
 ```bash
-export ASAN_OPTIONS="print_stacktrace=1:detect_container_overflow=0:suppressions=path/to/asan.supp:halt_on_error=0:log_path=asan.log"
-export LSAN_OPTIONS="suppressions=path/to/lsan.supp:halt_on_error=0:log_path=lsan.log"
+export ASAN_OPTIONS="include=sanitizers/suppressions/runtime-asan-options.txt:suppressions=sanitizers/suppressions/asan.supp"
+export LSAN_OPTIONS="include=sanitizers/suppressions/runtime-lsan-options.txt:suppressions=sanitizers/suppressions/lsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5
@@ -108,7 +108,7 @@ export LSAN_OPTIONS="suppressions=path/to/lsan.supp:halt_on_error=0:log_path=lsa
 ### ThreadSanitizer (TSan)
 
 ```bash
-export TSAN_OPTIONS="suppressions=path/to/tsan.supp halt_on_error=0 log_path=tsan.log"
+export TSAN_OPTIONS="include=sanitizers/suppressions/runtime-tsan-options.txt:suppressions=sanitizers/suppressions/tsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5
@@ -129,7 +129,7 @@ More details [here](https://github.com/google/sanitizers/wiki/AddressSanitizerLe
 ### UndefinedBehaviorSanitizer (UBSan)
 
 ```bash
-export UBSAN_OPTIONS="suppressions=path/to/ubsan.supp:print_stacktrace=1:halt_on_error=0:log_path=ubsan.log"
+export UBSAN_OPTIONS="include=sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=sanitizers/suppressions/ubsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5
diff --git a/include/xrpl/basics/Mutex.hpp b/include/xrpl/basics/Mutex.hpp
new file mode 100644
index 0000000000..18c57370b1
--- /dev/null
+++ b/include/xrpl/basics/Mutex.hpp
@@ -0,0 +1,155 @@
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+*/
+
+#pragma once
+
+#include <mutex>
+#include <type_traits>
+
+namespace xrpl {
+
+template <typename ProtectedDataType, typename MutexType>
+class Mutex;
+
+/**
+ * @brief A lock on a mutex that provides access to the protected data.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam LockType type of lock
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, template <typename...> typename LockType, typename MutexType>
+class Lock
+{
+    LockType<MutexType> lock_;
+    ProtectedDataType& data_;
+
+public:
+    /** @cond */
+    ProtectedDataType const&
+    operator*() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    operator*()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const&
+    get() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    get()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const*
+    operator->() const
+    {
+        return &data_;
+    }
+
+    ProtectedDataType*
+    operator->()
+    {
+        return &data_;
+    }
+
+    operator LockType<MutexType>&() &
+    {
+        return lock_;
+    }
+
+    operator LockType<MutexType> const&() const&
+    {
+        return lock_;
+    }
+    /** @endcond */
+
+private:
+    friend class Mutex<std::remove_const_t<ProtectedDataType>, MutexType>;
+
+    Lock(MutexType& mutex, ProtectedDataType& data) : lock_(mutex), data_(data)
+    {
+    }
+};
+
+/**
+ * @brief A container for data that is protected by a mutex. Inspired by Mutex in Rust.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, typename MutexType = std::mutex>
+class Mutex
+{
+    mutable MutexType mutex_;
+    ProtectedDataType data_{};
+
+public:
+    Mutex() = default;
+
+    /**
+     * @brief Construct a new Mutex object with the given data
+     *
+     * @param data The data to protect
+     */
+    explicit Mutex(ProtectedDataType data) : data_(std::move(data))
+    {
+    }
+
+    /**
+     * @brief Make a new Mutex object with the given data
+     *
+     * @tparam Args The types of the arguments to forward to the constructor of the protected data
+     * @param args The arguments to forward to the constructor of the protected data
+     * @return The Mutex object that protects the given data
+     */
+    template <typename... Args>
+    static Mutex
+    make(Args&&... args)
+    {
+        return Mutex{ProtectedDataType{std::forward<Args>(args)...}};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType const, LockType, MutexType>
+    lock() const
+    {
+        return {mutex_, data_};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType, LockType, MutexType>
+    lock()
+    {
+        return {mutex_, data_};
+    }
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/basics/contract.h b/include/xrpl/basics/contract.h
index aba021b726..f41c272b61 100644
--- a/include/xrpl/basics/contract.h
+++ b/include/xrpl/basics/contract.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/sanitizers.h>
 #include <xrpl/beast/type_name.h>
 
 #include <exception>
@@ -23,16 +24,28 @@ LogThrow(std::string const& title);
     When called from within a catch block, it will pass
     control to the next matching exception handler, if any.
     Otherwise, std::terminate will be called.
+
+    ASAN can't handle sudden jumps in control flow very well. This
+    function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
+    triggering false positives, since it throws.
 */
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Rethrow()
 {
     LogThrow("Re-throwing exception");
     throw;
 }
 
+/*
+    Logs and throws an exception of type E.
+
+    ASAN can't handle sudden jumps in control flow very well. This
+    function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
+    triggering false positives, since it throws.
+*/
+
 template <class E, class... Args>
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Throw(Args&&... args)
 {
     static_assert(
diff --git a/include/xrpl/basics/safe_cast.h b/include/xrpl/basics/safe_cast.h
index 8f5826f2a8..1e33b9663a 100644
--- a/include/xrpl/basics/safe_cast.h
+++ b/include/xrpl/basics/safe_cast.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xrpl/beast/utility/instrumentation.h>
+
 #include <type_traits>
 
 namespace xrpl {
@@ -70,4 +72,31 @@ unsafe_cast(Src s) noexcept
     return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
 
+template <class Dest, class Src>
+    requires std::is_pointer_v<Dest>
+inline Dest
+safe_downcast(Src* s) noexcept
+{
+#ifdef NDEBUG
+    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+#else
+    auto* result = dynamic_cast<Dest>(s);
+    XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid");
+    return result;
+#endif
+}
+
+template <class Dest, class Src>
+    requires std::is_lvalue_reference_v<Dest>
+inline Dest
+safe_downcast(Src& s) noexcept
+{
+#ifndef NDEBUG
+    XRPL_ASSERT(
+        dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
+        "xrpl::safe_downcast : reference downcast is valid");
+#endif
+    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+}
+
 }  // namespace xrpl
diff --git a/include/xrpl/basics/sanitizers.h b/include/xrpl/basics/sanitizers.h
new file mode 100644
index 0000000000..b954952848
--- /dev/null
+++ b/include/xrpl/basics/sanitizers.h
@@ -0,0 +1,13 @@
+#pragma once
+
+// Helper to disable ASan/HwASan for specific functions
+/*
+ ASAN flags some false positives with sudden jumps in control flow, like
+ exceptions, or when encountering coroutine stack switches. This macro can be used to disable ASAN
+ intrumentation for specific functions.
+*/
+#if defined(__GNUC__) || defined(__clang__)
+#define XRPL_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address", "hwaddress")))
+#else
+#define XRPL_NO_SANITIZE_ADDRESS
+#endif
diff --git a/include/xrpl/beast/core/List.h b/include/xrpl/beast/core/List.h
index 75c981ea1b..504dec4c4a 100644
--- a/include/xrpl/beast/core/List.h
+++ b/include/xrpl/beast/core/List.h
@@ -43,8 +43,8 @@ private:
     template <typename>
     friend class ListIterator;
 
-    ListNode* m_next;
-    ListNode* m_prev;
+    ListNode* m_next = nullptr;
+    ListNode* m_prev = nullptr;
 };
 
 //------------------------------------------------------------------------------
@@ -567,7 +567,7 @@ private:
     }
 
 private:
-    size_type m_size;
+    size_type m_size = 0u;
     Node m_head;
     Node m_tail;
 };
diff --git a/include/xrpl/beast/core/SemanticVersion.h b/include/xrpl/beast/core/SemanticVersion.h
index 1d3525de25..f839ef8c53 100644
--- a/include/xrpl/beast/core/SemanticVersion.h
+++ b/include/xrpl/beast/core/SemanticVersion.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace beast {
@@ -26,14 +27,14 @@ public:
 
     SemanticVersion();
 
-    SemanticVersion(std::string const& version);
+    SemanticVersion(std::string_view version);
 
     /** Parse a semantic version string.
         The parsing is as strict as possible.
         @return `true` if the string was parsed.
     */
     bool
-    parse(std::string const& input);
+    parse(std::string_view input);
 
     /** Produce a string from semantic version components. */
     std::string
diff --git a/include/xrpl/core/Coro.ipp b/include/xrpl/core/Coro.ipp
index 26d35d3c69..e7c08e65a6 100644
--- a/include/xrpl/core/Coro.ipp
+++ b/include/xrpl/core/Coro.ipp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <xrpl/basics/ByteUtilities.h>
-
 namespace xrpl {
 
 template <class F>
@@ -11,16 +9,18 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
     , name_(name)
     , running_(false)
     , coro_(
+          // Stack size of 1MB wasn't sufficient for deep calls. ASAN tests flagged the issue. Hence
+          // increasing the size to 1.5MB.
+          boost::context::protected_fixedsize_stack(1536 * 1024),
           [this, fn = std::forward<F>(f)](
-              boost::coroutines::asymmetric_coroutine<void>::push_type& do_yield) {
+              boost::coroutines2::asymmetric_coroutine<void>::push_type& do_yield) {
               yield_ = &do_yield;
               yield();
               fn(shared_from_this());
 #ifndef NDEBUG
               finished_ = true;
 #endif
-          },
-          boost::coroutines::attributes(megabytes(1)))
+          })
 {
 }
 
diff --git a/include/xrpl/core/JobQueue.h b/include/xrpl/core/JobQueue.h
index 5fafaea142..f40a892173 100644
--- a/include/xrpl/core/JobQueue.h
+++ b/include/xrpl/core/JobQueue.h
@@ -7,7 +7,8 @@
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
-#include <boost/coroutine/all.hpp>
+#include <boost/context/protected_fixedsize_stack.hpp>
+#include <boost/coroutine2/all.hpp>
 
 #include <set>
 
@@ -48,8 +49,8 @@ public:
         std::mutex mutex_;
         std::mutex mutex_run_;
         std::condition_variable cv_;
-        boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
-        boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
+        boost::coroutines2::coroutine<void>::pull_type coro_;
+        boost::coroutines2::coroutine<void>::push_type* yield_;
 #ifndef NDEBUG
         bool finished_ = false;
 #endif
diff --git a/include/xrpl/git/Git.h b/include/xrpl/git/Git.h
new file mode 100644
index 0000000000..001c09aea7
--- /dev/null
+++ b/include/xrpl/git/Git.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+namespace xrpl::git {
+
+std::string const&
+getCommitHash();
+
+std::string const&
+getBuildBranch();
+
+}  // namespace xrpl::git
diff --git a/include/xrpl/json/json_value.h b/include/xrpl/json/json_value.h
index 5895c94065..fc7625d67a 100644
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -421,7 +421,7 @@ private:
         ObjectValues* map_{nullptr};
     } value_;
     ValueType type_ : 8;
-    int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
+    int allocated_ : 1 {};  // Notes: if declared as bool, bitfield is useless.
 };
 
 inline Value
diff --git a/include/xrpl/json/json_writer.h b/include/xrpl/json/json_writer.h
index e468a5940d..cc3790a7dd 100644
--- a/include/xrpl/json/json_writer.h
+++ b/include/xrpl/json/json_writer.h
@@ -108,7 +108,7 @@ private:
     std::string indentString_;
     int rightMargin_;
     int indentSize_;
-    bool addChildValues_;
+    bool addChildValues_{};
 };
 
 /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
@@ -175,7 +175,7 @@ private:
     std::string indentString_;
     int rightMargin_;
     std::string indentation_;
-    bool addChildValues_;
+    bool addChildValues_{};
 };
 
 std::string
diff --git a/include/xrpl/ledger/CredentialHelpers.h b/include/xrpl/ledger/CredentialHelpers.h
index 3744ff47eb..c60bd6c7fa 100644
--- a/include/xrpl/ledger/CredentialHelpers.h
+++ b/include/xrpl/ledger/CredentialHelpers.h
@@ -49,7 +49,7 @@ validDomain(ReadView const& view, uint256 domainID, AccountID const& subject);
 // This function is only called when we about to return tecNO_PERMISSION
 // because all the checks for the DepositPreauth authorization failed.
 TER
-authorizedDepositPreauth(ApplyView const& view, STVector256 const& ctx, AccountID const& dst);
+authorizedDepositPreauth(ReadView const& view, STVector256 const& ctx, AccountID const& dst);
 
 // Sort credentials array, return empty set if there are duplicates
 std::set<std::pair<AccountID, Slice>>
@@ -74,7 +74,7 @@ verifyDepositPreauth(
     ApplyView& view,
     AccountID const& src,
     AccountID const& dst,
-    std::shared_ptr<SLE> const& sleDst,
+    std::shared_ptr<SLE const> const& sleDst,
     beast::Journal j);
 
 }  // namespace xrpl
diff --git a/include/xrpl/ledger/detail/RawStateTable.h b/include/xrpl/ledger/detail/RawStateTable.h
index 7a3e2077ff..499b9204c6 100644
--- a/include/xrpl/ledger/detail/RawStateTable.h
+++ b/include/xrpl/ledger/detail/RawStateTable.h
@@ -23,13 +23,13 @@ public:
     static constexpr size_t initialBufferSize = kilobytes(256);
 
     RawStateTable()
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{
+              std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{monotonic_resource_.get()} {};
 
     RawStateTable(RawStateTable const& rhs)
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{
+              std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{rhs.items_, monotonic_resource_.get()}
         , dropsDestroyed_{rhs.dropsDestroyed_} {};
 
diff --git a/include/xrpl/net/HTTPClient.h b/include/xrpl/net/HTTPClient.h
index 9ea5f98a37..c176e2d2e8 100644
--- a/include/xrpl/net/HTTPClient.h
+++ b/include/xrpl/net/HTTPClient.h
@@ -29,6 +29,18 @@ public:
         bool sslVerify,
         beast::Journal j);
 
+    /** Destroys the global SSL context created by initializeSSLContext().
+     *
+     *  This releases the underlying boost::asio::ssl::context and any
+     *  associated OpenSSL resources. Must not be called while any
+     *  HTTPClient requests are in flight.
+     *
+     *  @note Currently only called from tests during teardown. In production,
+     *        the SSL context lives for the lifetime of the process.
+     */
+    static void
+    cleanupSSLContext();
+
     static void
     get(bool bSSL,
         boost::asio::io_context& io_context,
diff --git a/include/xrpl/protocol/BuildInfo.h b/include/xrpl/protocol/BuildInfo.h
index 3c42a4323f..cc7633cfe1 100644
--- a/include/xrpl/protocol/BuildInfo.h
+++ b/include/xrpl/protocol/BuildInfo.h
@@ -49,7 +49,7 @@ getFullVersionString();
     @return the encoded version in a 64-bit integer
 */
 std::uint64_t
-encodeSoftwareVersion(char const* const versionStr);
+encodeSoftwareVersion(std::string_view versionStr);
 
 /** Returns this server's version packed in a 64-bit integer. */
 std::uint64_t
diff --git a/include/xrpl/protocol/Feature.h b/include/xrpl/protocol/Feature.h
index 34d78fc50b..0ff02fdac2 100644
--- a/include/xrpl/protocol/Feature.h
+++ b/include/xrpl/protocol/Feature.h
@@ -64,6 +64,49 @@
 
 namespace xrpl {
 
+// Feature names must not exceed this length (in characters, excluding the null terminator).
+static constexpr std::size_t maxFeatureNameSize = 63;
+// Reserve this exact feature-name length (in characters/bytes, excluding the null terminator)
+// so that a 32-byte uint256 (for example, in WASM or other interop contexts) can be used
+// as a compact, fixed-size feature selector without conflicting with human-readable names.
+static constexpr std::size_t reservedFeatureNameSize = 32;
+
+// Both validFeatureNameSize and validFeatureName are consteval functions that can be used in
+// static_asserts to validate feature names at compile time. They are only used inside
+// enforceValidFeatureName in Feature.cpp, but are exposed here for testing. The expected
+// parameter `auto fn` is a constexpr lambda which returns a const char*, making it available
+// for compile-time evaluation. Read more in https://accu.org/journals/overload/30/172/wu/
+consteval auto
+validFeatureNameSize(auto fn) -> bool
+{
+    constexpr char const* n = fn();
+    // Note, std::strlen is not constexpr, we need to implement our own here.
+    constexpr std::size_t N = [](auto n) {
+        std::size_t ret = 0;
+        for (auto ptr = n; *ptr != '\0'; ret++, ++ptr)
+            ;
+        return ret;
+    }(n);
+    return N != reservedFeatureNameSize &&  //
+        N <= maxFeatureNameSize;
+}
+
+consteval auto
+validFeatureName(auto fn) -> bool
+{
+    constexpr char const* n = fn();
+    // Prevent the use of visually confusable characters and enforce that feature names
+    // are always valid ASCII. This is needed because C++ allows Unicode identifiers.
+    // Characters below 0x20 are nonprintable control characters, and characters with the 0x80 bit
+    // set are non-ASCII (e.g. UTF-8 encoding of Unicode), so both are disallowed.
+    for (auto ptr = n; *ptr != '\0'; ++ptr)
+    {
+        if (*ptr & 0x80 || *ptr < 0x20)
+            return false;
+    }
+    return true;
+}
+
 enum class VoteBehavior : int { Obsolete = -1, DefaultNo = 0, DefaultYes };
 enum class AmendmentSupport : int { Retired = -1, Supported = 0, Unsupported };
 
diff --git a/include/xrpl/protocol/KnownFormats.h b/include/xrpl/protocol/KnownFormats.h
index ce14a210ab..c454683e19 100644
--- a/include/xrpl/protocol/KnownFormats.h
+++ b/include/xrpl/protocol/KnownFormats.h
@@ -30,9 +30,11 @@ public:
         Item(
             char const* name,
             KeyType type,
-            std::initializer_list<SOElement> uniqueFields,
-            std::initializer_list<SOElement> commonFields)
-            : soTemplate_(uniqueFields, commonFields), name_(name), type_(type)
+            std::vector<SOElement> uniqueFields,
+            std::vector<SOElement> commonFields)
+            : soTemplate_(std::move(uniqueFields), std::move(commonFields))
+            , name_(name)
+            , type_(type)
         {
             // Verify that KeyType is appropriate.
             static_assert(
@@ -142,16 +144,16 @@ protected:
 
         @param name The name of this format.
         @param type The type of this format.
-        @param uniqueFields An std::initializer_list of unique fields
-        @param commonFields An std::initializer_list of common fields
+        @param uniqueFields A std::vector of unique fields
+        @param commonFields A std::vector of common fields
 
         @return The created format.
     */
     Item const&
     add(char const* name,
         KeyType type,
-        std::initializer_list<SOElement> uniqueFields,
-        std::initializer_list<SOElement> commonFields = {})
+        std::vector<SOElement> uniqueFields,
+        std::vector<SOElement> commonFields = {})
     {
         if (auto const item = findByType(type))
         {
@@ -160,7 +162,7 @@ protected:
                 item->getName());
         }
 
-        formats_.emplace_front(name, type, uniqueFields, commonFields);
+        formats_.emplace_front(name, type, std::move(uniqueFields), std::move(commonFields));
         Item const& item{formats_.front()};
 
         names_[name] = &item;
diff --git a/include/xrpl/protocol/LedgerFormats.h b/include/xrpl/protocol/LedgerFormats.h
index fa39c15843..a43f6a7134 100644
--- a/include/xrpl/protocol/LedgerFormats.h
+++ b/include/xrpl/protocol/LedgerFormats.h
@@ -2,36 +2,34 @@
 
 #include <xrpl/protocol/KnownFormats.h>
 
-namespace xrpl {
+#include <map>
+#include <string>
+#include <vector>
 
+namespace xrpl {
 /** Identifiers for on-ledger objects.
 
-    Each ledger object requires a unique type identifier, which is stored
-    within the object itself; this makes it possible to iterate the entire
-    ledger and determine each object's type and verify that the object you
-    retrieved from a given hash matches the expected type.
+    Each ledger object requires a unique type identifier, which is stored within the object itself;
+   this makes it possible to iterate the entire ledger and determine each object's type and verify
+   that the object you retrieved from a given hash matches the expected type.
 
-    @warning Since these values are stored inside objects stored on the ledger
-             they are part of the protocol. **Changing them should be avoided
-             because without special handling, this will result in a hard
+    @warning Since these values are stored inside objects stored on the ledger they are part of the
+   protocol.
+   **Changing them should be avoided because without special handling, this will result in a hard
    fork.**
 
-    @note Values outside this range may be used internally by the code for
-          various purposes, but attempting to use such values to identify
-          on-ledger objects will results in an invariant failure.
+    @note Values outside this range may be used internally by the code for various purposes, but
+   attempting to use such values to identify on-ledger objects will result in an invariant failure.
 
-    @note When retiring types, the specific values should not be removed but
-          should be marked as [[deprecated]]. This is to avoid accidental
-          reuse of identifiers.
+    @note When retiring types, the specific values should not be removed but should be marked as
+   [[deprecated]]. This is to avoid accidental reuse of identifiers.
 
-    @todo The C++ language does not enable checking for duplicate values
-          here. If it becomes possible then we should do this.
+    @todo The C++ language does not enable checking for duplicate values here.
+          If it becomes possible then we should do this.
 
     @ingroup protocol
 */
-// clang-format off
-enum LedgerEntryType : std::uint16_t
-{
+enum LedgerEntryType : std::uint16_t {
 
 #pragma push_macro("LEDGER_ENTRY")
 #undef LEDGER_ENTRY
@@ -46,12 +44,10 @@ enum LedgerEntryType : std::uint16_t
     //---------------------------------------------------------------------------
     /** A special type, matching any ledger entry type.
 
-        The value does not represent a concrete type, but rather is used in
-        contexts where the specific type of a ledger object is unimportant,
-        unknown or unavailable.
+        The value does not represent a concrete type, but rather is used in contexts where the
+       specific type of a ledger object is unimportant, unknown or unavailable.
 
-        Objects with this special type cannot be created or stored on the
-        ledger.
+        Objects with this special type cannot be created or stored on the ledger.
 
         \sa keylet::unchecked
     */
@@ -59,12 +55,11 @@ enum LedgerEntryType : std::uint16_t
 
     /** A special type, matching any ledger type except directory nodes.
 
-        The value does not represent a concrete type, but rather is used in
-        contexts where the ledger object must not be a directory node but
-        its specific type is otherwise unimportant, unknown or unavailable.
+        The value does not represent a concrete type, but rather is used in contexts where the
+       ledger object must not be a directory node but its specific type is otherwise unimportant,
+       unknown or unavailable.
 
-        Objects with this special type cannot be created or stored on the
-        ledger.
+        Objects with this special type cannot be created or stored on the ledger.
 
         \sa keylet::child
      */
@@ -93,104 +88,188 @@ enum LedgerEntryType : std::uint16_t
                     Support for this type of object was never implemented.
                     No objects of this type were ever created.
      */
-    ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]]  = 0x0067,
+    ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]] =
+        0x0067,
 };
-// clang-format off
 
-/**
+/** Ledger object flags.
+
+    These flags are specified in ledger objects and modify their behavior.
+
+    @warning Ledger object flags form part of the protocol.
+    **Changing them should be avoided because without special handling, this will result in a hard
+   fork.**
+
     @ingroup protocol
 */
-enum LedgerSpecificFlags {
-    // ltACCOUNT_ROOT
-    lsfPasswordSpent = 0x00010000,  // True, if password set fee is spent.
-    lsfRequireDestTag =
-        0x00020000,  // True, to require a DestinationTag for payments.
-    lsfRequireAuth =
-        0x00040000,  // True, to require a authorization to hold IOUs.
-    lsfDisallowXRP = 0x00080000,    // True, to disallow sending XRP.
-    lsfDisableMaster = 0x00100000,  // True, force regular key
-    lsfNoFreeze = 0x00200000,       // True, cannot freeze ripple states
-    lsfGlobalFreeze = 0x00400000,   // True, all assets frozen
-    lsfDefaultRipple =
-        0x00800000,               // True, incoming trust lines allow rippling by default
-    lsfDepositAuth = 0x01000000,  // True, all deposits require authorization
-/*  // reserved for Hooks amendment
-    lsfTshCollect = 0x02000000,     // True, allow TSH collect-calls to acc hooks
-*/
-    lsfDisallowIncomingNFTokenOffer =
-        0x04000000,               // True, reject new incoming NFT offers
-    lsfDisallowIncomingCheck =
-        0x08000000,               // True, reject new checks
-    lsfDisallowIncomingPayChan =
-        0x10000000,               // True, reject new paychans
-    lsfDisallowIncomingTrustline =
-        0x20000000,               // True, reject new trustlines (only if no issued assets)
-    lsfAllowTrustLineLocking =
-        0x40000000,               // True, enable trustline locking
-    lsfAllowTrustLineClawback =
-        0x80000000,               // True, enable clawback
+#pragma push_macro("XMACRO")
+#pragma push_macro("TO_VALUE")
+#pragma push_macro("VALUE_TO_MAP")
+#pragma push_macro("NULL_NAME")
+#pragma push_macro("TO_MAP")
+#pragma push_macro("ALL_LEDGER_FLAGS")
 
-    // ltOFFER
-    lsfPassive = 0x00010000,
-    lsfSell = 0x00020000,  // True, offer was placed as a sell.
-    lsfHybrid = 0x00040000,  // True, offer is hybrid.
+#undef XMACRO
+#undef TO_VALUE
+#undef VALUE_TO_MAP
+#undef NULL_NAME
+#undef TO_MAP
 
-    // ltRIPPLE_STATE
-    lsfLowReserve = 0x00010000,  // True, if entry counts toward reserve.
-    lsfHighReserve = 0x00020000,
-    lsfLowAuth = 0x00040000,
-    lsfHighAuth = 0x00080000,
-    lsfLowNoRipple = 0x00100000,
-    lsfHighNoRipple = 0x00200000,
-    lsfLowFreeze = 0x00400000,      // True, low side has set freeze flag
-    lsfHighFreeze = 0x00800000,     // True, high side has set freeze flag
-    lsfLowDeepFreeze = 0x02000000,  // True, low side has set deep freeze flag
-    lsfHighDeepFreeze = 0x04000000, // True, high side has set deep freeze flag
-    lsfAMMNode = 0x01000000,        // True, trust line to AMM. Used by client
-                                    // apps to identify payments via AMM.
+#undef ALL_LEDGER_FLAGS
 
-    // ltSIGNER_LIST
-    lsfOneOwnerCount = 0x00010000,  // True, uses only one OwnerCount
+// clang-format off
 
-    // ltDIR_NODE
-    lsfNFTokenBuyOffers = 0x00000001,
-    lsfNFTokenSellOffers = 0x00000002,
+#define XMACRO(LEDGER_OBJECT, LSF_FLAG, LSF_FLAG2)                                                                                 \
+    LEDGER_OBJECT(AccountRoot,                                                                                                     \
+        LSF_FLAG(lsfPasswordSpent, 0x00010000)                  /* True, if password set fee is spent. */                          \
+        LSF_FLAG(lsfRequireDestTag, 0x00020000)                 /* True, to require a DestinationTag for payments. */              \
+        LSF_FLAG(lsfRequireAuth, 0x00040000)                    /* True, to require a authorization to hold IOUs. */               \
+        LSF_FLAG(lsfDisallowXRP, 0x00080000)                    /* True, to disallow sending XRP. */                               \
+        LSF_FLAG(lsfDisableMaster, 0x00100000)                  /* True, force regular key */                                      \
+        LSF_FLAG(lsfNoFreeze, 0x00200000)                       /* True, cannot freeze ripple states */                            \
+        LSF_FLAG(lsfGlobalFreeze, 0x00400000)                   /* True, all assets frozen */                                      \
+        LSF_FLAG(lsfDefaultRipple, 0x00800000)                  /* True, incoming trust lines allow rippling by default */         \
+        LSF_FLAG(lsfDepositAuth, 0x01000000)                    /* True, all deposits require authorization */                     \
+        LSF_FLAG(lsfDisallowIncomingNFTokenOffer, 0x04000000)   /* True, reject new incoming NFT offers */                         \
+        LSF_FLAG(lsfDisallowIncomingCheck, 0x08000000)          /* True, reject new checks */                                      \
+        LSF_FLAG(lsfDisallowIncomingPayChan, 0x10000000)        /* True, reject new paychans */                                    \
+        LSF_FLAG(lsfDisallowIncomingTrustline, 0x20000000)      /* True, reject new trustlines (only if no issued assets) */       \
+        LSF_FLAG(lsfAllowTrustLineLocking, 0x40000000)          /* True, enable trustline locking */                               \
+        LSF_FLAG(lsfAllowTrustLineClawback, 0x80000000))        /* True, enable clawback */                                        \
+                                                                                                                                   \
+    LEDGER_OBJECT(Offer,                                                                                                           \
+        LSF_FLAG(lsfPassive, 0x00010000)                                                                                           \
+        LSF_FLAG(lsfSell, 0x00020000)                           /* True, offer was placed as a sell. */                            \
+        LSF_FLAG(lsfHybrid, 0x00040000))                        /* True, offer is hybrid. */                                       \
+                                                                                                                                   \
+    LEDGER_OBJECT(RippleState,                                                                                                     \
+        LSF_FLAG(lsfLowReserve, 0x00010000)                     /* True, if entry counts toward reserve. */                        \
+        LSF_FLAG(lsfHighReserve, 0x00020000)                                                                                       \
+        LSF_FLAG(lsfLowAuth, 0x00040000)                                                                                           \
+        LSF_FLAG(lsfHighAuth, 0x00080000)                                                                                          \
+        LSF_FLAG(lsfLowNoRipple, 0x00100000)                                                                                       \
+        LSF_FLAG(lsfHighNoRipple, 0x00200000)                                                                                      \
+        LSF_FLAG(lsfLowFreeze, 0x00400000)                      /* True, low side has set freeze flag */                           \
+        LSF_FLAG(lsfHighFreeze, 0x00800000)                     /* True, high side has set freeze flag */                          \
+        LSF_FLAG(lsfAMMNode, 0x01000000)                        /* True, trust line to AMM. */                                     \
+                                                                /* Used by client apps to identify payments via AMM. */            \
+        LSF_FLAG(lsfLowDeepFreeze, 0x02000000)                  /* True, low side has set deep freeze flag */                      \
+        LSF_FLAG(lsfHighDeepFreeze, 0x04000000))                /* True, high side has set deep freeze flag */                     \
+                                                                                                                                   \
+    LEDGER_OBJECT(SignerList,                                                                                                      \
+        LSF_FLAG(lsfOneOwnerCount, 0x00010000))                 /* True, uses only one OwnerCount */                               \
+                                                                                                                                   \
+    LEDGER_OBJECT(DirNode,                                                                                                         \
+        LSF_FLAG(lsfNFTokenBuyOffers, 0x00000001)                                                                                  \
+        LSF_FLAG(lsfNFTokenSellOffers, 0x00000002))                                                                                \
+                                                                                                                                   \
+    LEDGER_OBJECT(NFTokenOffer,                                                                                                    \
+        LSF_FLAG(lsfSellNFToken, 0x00000001))                                                                                      \
+                                                                                                                                   \
+    LEDGER_OBJECT(MPTokenIssuance,                                                                                                 \
+        LSF_FLAG(lsfMPTLocked, 0x00000001)                      /* Also used in ltMPTOKEN */                                       \
+        LSF_FLAG(lsfMPTCanLock, 0x00000002)                                                                                        \
+        LSF_FLAG(lsfMPTRequireAuth, 0x00000004)                                                                                    \
+        LSF_FLAG(lsfMPTCanEscrow, 0x00000008)                                                                                      \
+        LSF_FLAG(lsfMPTCanTrade, 0x00000010)                                                                                       \
+        LSF_FLAG(lsfMPTCanTransfer, 0x00000020)                                                                                    \
+        LSF_FLAG(lsfMPTCanClawback, 0x00000040))                                                                                   \
+                                                                                                                                   \
+    LEDGER_OBJECT(MPTokenIssuanceMutable,                                                                                          \
+        LSF_FLAG(lsmfMPTCanMutateCanLock, 0x00000002)                                                                              \
+        LSF_FLAG(lsmfMPTCanMutateRequireAuth, 0x00000004)                                                                          \
+        LSF_FLAG(lsmfMPTCanMutateCanEscrow, 0x00000008)                                                                            \
+        LSF_FLAG(lsmfMPTCanMutateCanTrade, 0x00000010)                                                                             \
+        LSF_FLAG(lsmfMPTCanMutateCanTransfer, 0x00000020)                                                                          \
+        LSF_FLAG(lsmfMPTCanMutateCanClawback, 0x00000040)                                                                          \
+        LSF_FLAG(lsmfMPTCanMutateMetadata, 0x00010000)                                                                             \
+        LSF_FLAG(lsmfMPTCanMutateTransferFee, 0x00020000))                                                                         \
+                                                                                                                                   \
+    LEDGER_OBJECT(MPToken,                                                                                                         \
+        LSF_FLAG2(lsfMPTLocked, 0x00000001)                                                                                        \
+        LSF_FLAG(lsfMPTAuthorized, 0x00000002))                                                                                    \
+                                                                                                                                   \
+    LEDGER_OBJECT(Credential,                                                                                                      \
+        LSF_FLAG(lsfAccepted, 0x00010000))                                                                                         \
+                                                                                                                                   \
+    LEDGER_OBJECT(Vault,                                                                                                           \
+        LSF_FLAG(lsfVaultPrivate, 0x00010000))                                                                                     \
+                                                                                                                                   \
+    LEDGER_OBJECT(Loan,                                                                                                            \
+        LSF_FLAG(lsfLoanDefault, 0x00010000)                                                                                       \
+        LSF_FLAG(lsfLoanImpaired, 0x00020000)                                                                                      \
+        LSF_FLAG(lsfLoanOverpayment, 0x00040000))               /* True, loan allows overpayments */
 
-    // ltNFTOKEN_OFFER
-    lsfSellNFToken = 0x00000001,
+// clang-format on
 
-    // ltMPTOKEN_ISSUANCE
-    lsfMPTLocked = 0x00000001, // Also used in ltMPTOKEN
-    lsfMPTCanLock = 0x00000002,
-    lsfMPTRequireAuth = 0x00000004,
-    lsfMPTCanEscrow = 0x00000008,
-    lsfMPTCanTrade = 0x00000010,
-    lsfMPTCanTransfer = 0x00000020,
-    lsfMPTCanClawback = 0x00000040,
+// Create all the flag values as an enum.
+//
+// example:
+// enum LedgerSpecificFlags {
+//     lsfPasswordSpent = 0x00010000,
+//     lsfRequireDestTag = 0x00020000,
+//     ...
+// };
+#define TO_VALUE(name, value) name = value,
+#define NULL_NAME(name, values) values
+#define NULL_OUTPUT(name, value)
+enum LedgerSpecificFlags : std::uint32_t { XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT) };
 
-    lsmfMPTCanMutateCanLock = 0x00000002,
-    lsmfMPTCanMutateRequireAuth = 0x00000004,
-    lsmfMPTCanMutateCanEscrow = 0x00000008,
-    lsmfMPTCanMutateCanTrade = 0x00000010,
-    lsmfMPTCanMutateCanTransfer = 0x00000020,
-    lsmfMPTCanMutateCanClawback = 0x00000040,
-    lsmfMPTCanMutateMetadata = 0x00010000,
-    lsmfMPTCanMutateTransferFee = 0x00020000,
+// Create getter functions for each set of flags using Meyer's singleton pattern.
+// This avoids static initialization order fiasco while still providing efficient access.
+// This is used below in `getAllLedgerFlags()` to generate the server_definitions RPC output.
+//
+// example:
+// inline LedgerFlagMap const& getAccountRootFlags() {
+//     static LedgerFlagMap const flags = {
+//         {"lsfPasswordSpent", 0x00010000},
+//         {"lsfRequireDestTag", 0x00020000},
+//     ...};
+//     return flags;
+// }
+using LedgerFlagMap = std::map<std::string, std::uint32_t>;
+#define VALUE_TO_MAP(name, value) {#name, value},
+#define TO_MAP(name, values)                         \
+    inline LedgerFlagMap const& get##name##Flags()   \
+    {                                                \
+        static LedgerFlagMap const flags = {values}; \
+        return flags;                                \
+    }
+XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP)
 
-    // ltMPTOKEN
-    lsfMPTAuthorized = 0x00000002,
+// Create a getter function for all ledger flag maps using Meyer's singleton pattern.
+// This is used to generate the server_definitions RPC output.
+//
+// example:
+// inline std::vector<std::pair<std::string, LedgerFlagMap>> const& getAllLedgerFlags() {
+//     static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
+//         {"AccountRoot", getAccountRootFlags()},
+//     ...};
+//     return flags;
+// }
+#define ALL_LEDGER_FLAGS(name, values) {#name, get##name##Flags()},
+inline std::vector<std::pair<std::string, LedgerFlagMap>> const&
+getAllLedgerFlags()
+{
+    static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
+        XMACRO(ALL_LEDGER_FLAGS, NULL_OUTPUT, NULL_OUTPUT)};
+    return flags;
+}
 
-    // ltCREDENTIAL
-    lsfAccepted = 0x00010000,
+#undef XMACRO
+#undef TO_VALUE
+#undef VALUE_TO_MAP
+#undef NULL_NAME
+#undef NULL_OUTPUT
+#undef TO_MAP
+#undef ALL_LEDGER_FLAGS
 
-    // ltVAULT
-    lsfVaultPrivate = 0x00010000,
-
-    // ltLOAN
-    lsfLoanDefault = 0x00010000,
-    lsfLoanImpaired = 0x00020000,
-    lsfLoanOverpayment = 0x00040000, // True, loan allows overpayments
-};
+#pragma pop_macro("XMACRO")
+#pragma pop_macro("TO_VALUE")
+#pragma pop_macro("VALUE_TO_MAP")
+#pragma pop_macro("NULL_NAME")
+#pragma pop_macro("TO_MAP")
+#pragma pop_macro("ALL_LEDGER_FLAGS")
 
 //------------------------------------------------------------------------------
 
@@ -207,6 +286,10 @@ private:
 public:
     static LedgerFormats const&
     getInstance();
+
+    // Fields shared by all ledger entry formats:
+    static std::vector<SOElement> const&
+    getCommonFields();
 };
 
 }  // namespace xrpl
diff --git a/include/xrpl/protocol/Protocol.h b/include/xrpl/protocol/Protocol.h
index 7ddf43d175..0db7b217f0 100644
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -209,7 +209,7 @@ std::size_t constexpr maxDIDDocumentLength = 256;
 std::size_t constexpr maxDIDURILength = 256;
 
 /** The maximum length of an Attestation inside a DID */
-std::size_t constexpr maxDIDAttestationLength = 256;
+std::size_t constexpr maxDIDDataLength = 256;
 
 /** The maximum length of a domain */
 std::size_t constexpr maxDomainLength = 256;
diff --git a/include/xrpl/protocol/PublicKey.h b/include/xrpl/protocol/PublicKey.h
index e806f6ffeb..67e55ca136 100644
--- a/include/xrpl/protocol/PublicKey.h
+++ b/include/xrpl/protocol/PublicKey.h
@@ -44,7 +44,7 @@ protected:
     // All the constructed public keys are valid, non-empty and contain 33
     // bytes of data.
     static constexpr std::size_t size_ = 33;
-    std::uint8_t buf_[size_];  // should be large enough
+    std::uint8_t buf_[size_]{};  // should be large enough
 
 public:
     using const_iterator = std::uint8_t const*;
diff --git a/include/xrpl/protocol/SOTemplate.h b/include/xrpl/protocol/SOTemplate.h
index 576bd8c34a..41cea7936c 100644
--- a/include/xrpl/protocol/SOTemplate.h
+++ b/include/xrpl/protocol/SOTemplate.h
@@ -6,6 +6,7 @@
 #include <functional>
 #include <initializer_list>
 #include <stdexcept>
+#include <vector>
 
 namespace xrpl {
 
@@ -97,8 +98,12 @@ public:
     operator=(SOTemplate&& other) = default;
 
     /** Create a template populated with all fields.
-        After creating the template fields cannot be
-        added, modified, or removed.
+        After creating the template fields cannot be added, modified, or removed.
+    */
+    SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields = {});
+
+    /** Create a template populated with all fields.
+        Note: Defers to the vector constructor above.
     */
     SOTemplate(
         std::initializer_list<SOElement> uniqueFields,
diff --git a/include/xrpl/protocol/STAccount.h b/include/xrpl/protocol/STAccount.h
index 3fdb2e015e..76c8f24b7b 100644
--- a/include/xrpl/protocol/STAccount.h
+++ b/include/xrpl/protocol/STAccount.h
@@ -24,7 +24,7 @@ public:
     STAccount();
 
     STAccount(SField const& n);
-    STAccount(SField const& n, Buffer&& v);
+    STAccount(SField const& n, Buffer const& v);
     STAccount(SerialIter& sit, SField const& name);
     STAccount(SField const& n, AccountID const& v);
 
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index 09eff8c3d2..0eb76a80c1 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -57,7 +57,7 @@ class STObject : public STBase, public CountedObject<STObject>
     using list_type = std::vector<detail::STVar>;
 
     list_type v_;
-    SOTemplate const* mType;
+    SOTemplate const* mType{};
 
 public:
     using iterator = boost::transform_iterator<Transform, STObject::list_type::const_iterator>;
diff --git a/include/xrpl/protocol/STTx.h b/include/xrpl/protocol/STTx.h
index 15978efded..bf784bb0ae 100644
--- a/include/xrpl/protocol/STTx.h
+++ b/include/xrpl/protocol/STTx.h
@@ -15,7 +15,7 @@
 
 namespace xrpl {
 
-enum TxnSql : char {
+enum class TxnSql : char {
     txnSqlNew = 'N',
     txnSqlConflict = 'C',
     txnSqlHeld = 'H',
@@ -83,6 +83,9 @@ public:
     std::uint32_t
     getSeqValue() const;
 
+    AccountID
+    getFeePayer() const;
+
     boost::container::flat_set<AccountID>
     getMentionedAccounts() const;
 
@@ -122,7 +125,7 @@ public:
     getMetaSQL(
         Serializer rawTxn,
         std::uint32_t inLedger,
-        char status,
+        TxnSql status,
         std::string const& escapedMetaData) const;
 
     std::vector<uint256> const&
diff --git a/include/xrpl/protocol/SecretKey.h b/include/xrpl/protocol/SecretKey.h
index a59b1150c1..dd5566915f 100644
--- a/include/xrpl/protocol/SecretKey.h
+++ b/include/xrpl/protocol/SecretKey.h
@@ -16,8 +16,11 @@ namespace xrpl {
 /** A secret key. */
 class SecretKey
 {
+public:
+    static constexpr std::size_t size_ = 32;
+
 private:
-    std::uint8_t buf_[32];
+    std::uint8_t buf_[size_]{};
 
 public:
     using const_iterator = std::uint8_t const*;
@@ -27,9 +30,14 @@ public:
     SecretKey&
     operator=(SecretKey const&) = default;
 
+    bool
+    operator==(SecretKey const&) = delete;
+    bool
+    operator!=(SecretKey const&) = delete;
+
     ~SecretKey();
 
-    SecretKey(std::array<std::uint8_t, 32> const& data);
+    SecretKey(std::array<std::uint8_t, size_> const& data);
     SecretKey(Slice const& slice);
 
     std::uint8_t const*
@@ -78,16 +86,10 @@ public:
 };
 
 inline bool
-operator==(SecretKey const& lhs, SecretKey const& rhs)
-{
-    return lhs.size() == rhs.size() && std::memcmp(lhs.data(), rhs.data(), rhs.size()) == 0;
-}
+operator==(SecretKey const& lhs, SecretKey const& rhs) = delete;
 
 inline bool
-operator!=(SecretKey const& lhs, SecretKey const& rhs)
-{
-    return !(lhs == rhs);
-}
+operator!=(SecretKey const& lhs, SecretKey const& rhs) = delete;
 
 //------------------------------------------------------------------------------
 
diff --git a/include/xrpl/protocol/Seed.h b/include/xrpl/protocol/Seed.h
index 1fad94e2bd..5b490be12e 100644
--- a/include/xrpl/protocol/Seed.h
+++ b/include/xrpl/protocol/Seed.h
@@ -13,7 +13,7 @@ namespace xrpl {
 class Seed
 {
 private:
-    std::array<uint8_t, 16> buf_;
+    std::array<uint8_t, 16> buf_{};
 
 public:
     using const_iterator = std::array<uint8_t, 16>::const_iterator;
diff --git a/include/xrpl/protocol/SystemParameters.h b/include/xrpl/protocol/SystemParameters.h
index 70ab67c56f..b51e011533 100644
--- a/include/xrpl/protocol/SystemParameters.h
+++ b/include/xrpl/protocol/SystemParameters.h
@@ -14,7 +14,7 @@ namespace xrpl {
 static inline std::string const&
 systemName()
 {
-    static std::string const name = "ripple";
+    static std::string const name = "xrpld";
     return name;
 }
 
diff --git a/include/xrpl/protocol/TxFlags.h b/include/xrpl/protocol/TxFlags.h
index 6c6ef5e369..7c2085109f 100644
--- a/include/xrpl/protocol/TxFlags.h
+++ b/include/xrpl/protocol/TxFlags.h
@@ -3,294 +3,444 @@
 #include <xrpl/protocol/LedgerFormats.h>
 
 #include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace xrpl {
 
 /** Transaction flags.
 
-    These flags are specified in a transaction's 'Flags' field and modify the
-    behavior of that transaction.
+    These flags are specified in a transaction's 'Flags' field and modify
+    the behavior of that transaction.
 
     There are two types of flags:
 
-        (1) Universal flags: these are flags which apply to, and are interpreted
-                             the same way by, all transactions, except, perhaps,
-                             to special pseudo-transactions.
+        (1) Universal flags: these are flags which apply to, and are interpreted the same way by,
+            all transactions, except, perhaps, to special pseudo-transactions.
 
-        (2) Tx-Specific flags: these are flags which are interpreted according
-                               to the type of the transaction being executed.
-                               That is, the same numerical flag value may have
-                               different effects, depending on the transaction
-                               being executed.
+        (2) Tx-Specific flags: these are flags which are interpreted according to the type of the
+            transaction being executed. That is, the same numerical flag value may have different
+            effects, depending on the transaction being executed.
 
-    @note The universal transaction flags occupy the high-order 8 bits. The
-          tx-specific flags occupy the remaining 24 bits.
+    @note The universal transaction flags occupy the high-order 8 bits.
+          The tx-specific flags occupy the remaining 24 bits.
 
-    @warning Transaction flags form part of the protocol. **Changing them
-             should be avoided because without special handling, this will
-             result in a hard fork.**
+    @warning Transaction flags form part of the protocol.
+             **Changing them should be avoided because without special handling, this will result in
+             a hard fork.**
 
     @ingroup protocol
 */
 
-// Formatting equals sign aligned 4 spaces after longest prefix, except for
-// wrapped lines
-// clang-format off
+using FlagValue = std::uint32_t;
+
 // Universal Transaction flags:
-constexpr std::uint32_t tfFullyCanonicalSig                = 0x80000000;
-constexpr std::uint32_t tfInnerBatchTxn                    = 0x40000000;
-constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig | tfInnerBatchTxn;
-constexpr std::uint32_t tfUniversalMask                    = ~tfUniversal;
+inline constexpr FlagValue tfFullyCanonicalSig = 0x80000000;
+inline constexpr FlagValue tfInnerBatchTxn = 0x40000000;
+inline constexpr FlagValue tfUniversal = tfFullyCanonicalSig | tfInnerBatchTxn;
+inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
 
-// AccountSet flags:
-constexpr std::uint32_t tfRequireDestTag                   = 0x00010000;
-constexpr std::uint32_t tfOptionalDestTag                  = 0x00020000;
-constexpr std::uint32_t tfRequireAuth                      = 0x00040000;
-constexpr std::uint32_t tfOptionalAuth                     = 0x00080000;
-constexpr std::uint32_t tfDisallowXRP                      = 0x00100000;
-constexpr std::uint32_t tfAllowXRP                         = 0x00200000;
-constexpr std::uint32_t tfAccountSetMask =
-    ~(tfUniversal | tfRequireDestTag | tfOptionalDestTag | tfRequireAuth |
-      tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
+#pragma push_macro("XMACRO")
+#pragma push_macro("TO_VALUE")
+#pragma push_macro("VALUE_TO_MAP")
+#pragma push_macro("NULL_NAME")
+#pragma push_macro("NULL_OUTPUT")
+#pragma push_macro("TO_MAP")
+#pragma push_macro("TO_MASK")
+#pragma push_macro("VALUE_TO_MASK")
+#pragma push_macro("ALL_TX_FLAGS")
+#pragma push_macro("NULL_MASK_ADJ")
+#pragma push_macro("MASK_ADJ_TO_MASK")
 
-// AccountSet SetFlag/ClearFlag values
-constexpr std::uint32_t asfRequireDest                     =  1;
-constexpr std::uint32_t asfRequireAuth                     =  2;
-constexpr std::uint32_t asfDisallowXRP                     =  3;
-constexpr std::uint32_t asfDisableMaster                   =  4;
-constexpr std::uint32_t asfAccountTxnID                    =  5;
-constexpr std::uint32_t asfNoFreeze                        =  6;
-constexpr std::uint32_t asfGlobalFreeze                    =  7;
-constexpr std::uint32_t asfDefaultRipple                   =  8;
-constexpr std::uint32_t asfDepositAuth                     =  9;
-constexpr std::uint32_t asfAuthorizedNFTokenMinter         = 10;
-/*  // reserved for Hooks amendment
-constexpr std::uint32_t asfTshCollect                      = 11;
-*/
-constexpr std::uint32_t asfDisallowIncomingNFTokenOffer    = 12;
-constexpr std::uint32_t asfDisallowIncomingCheck           = 13;
-constexpr std::uint32_t asfDisallowIncomingPayChan         = 14;
-constexpr std::uint32_t asfDisallowIncomingTrustline       = 15;
-constexpr std::uint32_t asfAllowTrustLineClawback          = 16;
-constexpr std::uint32_t asfAllowTrustLineLocking           = 17;
+#undef XMACRO
+#undef TO_VALUE
+#undef VALUE_TO_MAP
+#undef NULL_NAME
+#undef NULL_OUTPUT
+#undef TO_MAP
+#undef TO_MASK
+#undef VALUE_TO_MASK
+#undef NULL_MASK_ADJ
+#undef MASK_ADJ_TO_MASK
 
-// OfferCreate flags:
-constexpr std::uint32_t tfPassive                          = 0x00010000;
-constexpr std::uint32_t tfImmediateOrCancel                = 0x00020000;
-constexpr std::uint32_t tfFillOrKill                       = 0x00040000;
-constexpr std::uint32_t tfSell                             = 0x00080000;
-constexpr std::uint32_t tfHybrid                           = 0x00100000;
-constexpr std::uint32_t tfOfferCreateMask =
-    ~(tfUniversal | tfPassive | tfImmediateOrCancel | tfFillOrKill | tfSell | tfHybrid);
+// clang-format off
+#undef ALL_TX_FLAGS
 
-// Payment flags:
-constexpr std::uint32_t tfNoRippleDirect                   = 0x00010000;
-constexpr std::uint32_t tfPartialPayment                   = 0x00020000;
-constexpr std::uint32_t tfLimitQuality                     = 0x00040000;
-constexpr std::uint32_t tfPaymentMask =
-    ~(tfUniversal | tfPartialPayment | tfLimitQuality | tfNoRippleDirect);
-constexpr std::uint32_t tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
-
-// TrustSet flags:
-constexpr std::uint32_t tfSetfAuth                         = 0x00010000;
-constexpr std::uint32_t tfSetNoRipple                      = 0x00020000;
-constexpr std::uint32_t tfClearNoRipple                    = 0x00040000;
-constexpr std::uint32_t tfSetFreeze                        = 0x00100000;
-constexpr std::uint32_t tfClearFreeze                      = 0x00200000;
-constexpr std::uint32_t tfSetDeepFreeze                    = 0x00400000;
-constexpr std::uint32_t tfClearDeepFreeze                  = 0x00800000;
-constexpr std::uint32_t tfTrustSetMask =
-    ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
-      tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
-constexpr std::uint32_t tfTrustSetPermissionMask = ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
-
-// EnableAmendment flags:
-constexpr std::uint32_t tfGotMajority                      = 0x00010000;
-constexpr std::uint32_t tfLostMajority                     = 0x00020000;
-constexpr std::uint32_t tfChangeMask =
-    ~( tfUniversal | tfGotMajority | tfLostMajority);
-
-// PaymentChannelClaim flags:
-constexpr std::uint32_t tfRenew                            = 0x00010000;
-constexpr std::uint32_t tfClose                            = 0x00020000;
-constexpr std::uint32_t tfPayChanClaimMask = ~(tfUniversal | tfRenew | tfClose);
-
-// NFTokenMint flags:
-constexpr std::uint32_t const tfBurnable                   = 0x00000001;
-constexpr std::uint32_t const tfOnlyXRP                    = 0x00000002;
-constexpr std::uint32_t const tfTrustLine                  = 0x00000004;
-constexpr std::uint32_t const tfTransferable               = 0x00000008;
-constexpr std::uint32_t const tfMutable                    = 0x00000010;
-
-// MPTokenIssuanceCreate flags:
-// Note: tf/lsfMPTLocked is intentionally omitted, since this transaction
-// is not allowed to modify it.
-constexpr std::uint32_t const tfMPTCanLock                 = lsfMPTCanLock;
-constexpr std::uint32_t const tfMPTRequireAuth             = lsfMPTRequireAuth;
-constexpr std::uint32_t const tfMPTCanEscrow               = lsfMPTCanEscrow;
-constexpr std::uint32_t const tfMPTCanTrade                = lsfMPTCanTrade;
-constexpr std::uint32_t const tfMPTCanTransfer             = lsfMPTCanTransfer;
-constexpr std::uint32_t const tfMPTCanClawback             = lsfMPTCanClawback;
-constexpr std::uint32_t const tfMPTokenIssuanceCreateMask  =
-  ~(tfUniversal | tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow | tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback);
-
-// MPTokenIssuanceCreate MutableFlags:
-// Indicating specific fields or flags may be changed after issuance.
-constexpr std::uint32_t const tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
-constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
-constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
-constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
-constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
-constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
-constexpr std::uint32_t const tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
-constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
-constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
-  ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
-    | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
-
-// MPTokenAuthorize flags:
-constexpr std::uint32_t const tfMPTUnauthorize             = 0x00000001;
-constexpr std::uint32_t const tfMPTokenAuthorizeMask  = ~(tfUniversal | tfMPTUnauthorize);
-
-// MPTokenIssuanceSet flags:
-constexpr std::uint32_t const tfMPTLock                   = 0x00000001;
-constexpr std::uint32_t const tfMPTUnlock                 = 0x00000002;
-constexpr std::uint32_t const tfMPTokenIssuanceSetMask  = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
-constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
-
-// MPTokenIssuanceSet MutableFlags:
-// Set or Clear flags.
-constexpr std::uint32_t const tmfMPTSetCanLock             = 0x00000001;
-constexpr std::uint32_t const tmfMPTClearCanLock           = 0x00000002;
-constexpr std::uint32_t const tmfMPTSetRequireAuth         = 0x00000004;
-constexpr std::uint32_t const tmfMPTClearRequireAuth       = 0x00000008;
-constexpr std::uint32_t const tmfMPTSetCanEscrow           = 0x00000010;
-constexpr std::uint32_t const tmfMPTClearCanEscrow         = 0x00000020;
-constexpr std::uint32_t const tmfMPTSetCanTrade            = 0x00000040;
-constexpr std::uint32_t const tmfMPTClearCanTrade          = 0x00000080;
-constexpr std::uint32_t const tmfMPTSetCanTransfer         = 0x00000100;
-constexpr std::uint32_t const tmfMPTClearCanTransfer       = 0x00000200;
-constexpr std::uint32_t const tmfMPTSetCanClawback         = 0x00000400;
-constexpr std::uint32_t const tmfMPTClearCanClawback       = 0x00000800;
-constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
-    tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
-    tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
-    tmfMPTSetCanClawback | tmfMPTClearCanClawback);
-
-// MPTokenIssuanceDestroy flags:
-constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask  = ~tfUniversal;
-
-// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between
-// accounts allowed a TrustLine to be added to the issuer of that token
-// without explicit permission from that issuer.  This was enabled by
-// minting the NFToken with the tfTrustLine flag set.
+// XMACRO parameters:
+// - TRANSACTION: handles the transaction name, its flags, and mask adjustment
+// - TF_FLAG: defines a new flag constant
+// - TF_FLAG2: references an existing flag constant (no new definition)
+// - MASK_ADJ: specifies flags to add back to the mask (making them invalid for this tx type)
 //
-// That capability could be used to attack the NFToken issuer.  It
-// would be possible for two accounts to trade the NFToken back and forth
-// building up any number of TrustLines on the issuer, increasing the
-// issuer's reserve without bound.
+// Note: MASK_ADJ is used when a universal flag should be invalid for a specific transaction.
+// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) because the outer Batch transaction
+// must not have tfInnerBatchTxn set (only inner transactions should have it).
 //
-// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the
-// tfTrustLine flag as a way to prevent the attack.  But until the
-// amendment passes we still need to keep the old behavior available.
-constexpr std::uint32_t const tfNFTokenMintMask =
-    ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
-
-constexpr std::uint32_t const tfNFTokenMintOldMask =
-    ~( ~tfNFTokenMintMask | tfTrustLine);
-
-// if featureDynamicNFT enabled then new flag allowing mutable URI available.
-constexpr std::uint32_t const tfNFTokenMintOldMaskWithMutable =
-    ~( ~tfNFTokenMintOldMask | tfMutable);
-
-constexpr std::uint32_t const tfNFTokenMintMaskWithMutable =
-    ~( ~tfNFTokenMintMask | tfMutable);
-
-// NFTokenCreateOffer flags:
-constexpr std::uint32_t const tfSellNFToken                = 0x00000001;
-constexpr std::uint32_t const tfNFTokenCreateOfferMask =
-    ~(tfUniversal | tfSellNFToken);
-
-// NFTokenCancelOffer flags:
-constexpr std::uint32_t const tfNFTokenCancelOfferMask     = ~tfUniversal;
-
-// NFTokenAcceptOffer flags:
-constexpr std::uint32_t const tfNFTokenAcceptOfferMask     = ~tfUniversal;
-
-// Clawback flags:
-constexpr std::uint32_t const tfClawbackMask               = ~tfUniversal;
-
-// AMM Flags:
-constexpr std::uint32_t tfLPToken                          = 0x00010000;
-constexpr std::uint32_t tfWithdrawAll                      = 0x00020000;
-constexpr std::uint32_t tfOneAssetWithdrawAll              = 0x00040000;
-constexpr std::uint32_t tfSingleAsset                      = 0x00080000;
-constexpr std::uint32_t tfTwoAsset                         = 0x00100000;
-constexpr std::uint32_t tfOneAssetLPToken                  = 0x00200000;
-constexpr std::uint32_t tfLimitLPToken                     = 0x00400000;
-constexpr std::uint32_t tfTwoAssetIfEmpty                  = 0x00800000;
-constexpr std::uint32_t tfWithdrawSubTx =
-    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
-    tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
-constexpr std::uint32_t tfDepositSubTx =
-    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
-    tfLimitLPToken | tfTwoAssetIfEmpty;
-constexpr std::uint32_t tfWithdrawMask = ~(tfUniversal | tfWithdrawSubTx);
-constexpr std::uint32_t tfDepositMask = ~(tfUniversal | tfDepositSubTx);
-
-// AMMClawback flags:
-constexpr std::uint32_t tfClawTwoAssets                = 0x00000001;
-constexpr std::uint32_t tfAMMClawbackMask = ~(tfUniversal | tfClawTwoAssets);
-
-// BridgeModify flags:
-constexpr std::uint32_t tfClearAccountCreateAmount     = 0x00010000;
-constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
-
-// VaultCreate flags:
-constexpr std::uint32_t const tfVaultPrivate               = 0x00010000;
-static_assert(tfVaultPrivate == lsfVaultPrivate);
-constexpr std::uint32_t const tfVaultShareNonTransferable  = 0x00020000;
-constexpr std::uint32_t const tfVaultCreateMask = ~(tfUniversal | tfVaultPrivate | tfVaultShareNonTransferable);
-
-// Batch Flags:
-constexpr std::uint32_t tfAllOrNothing                 = 0x00010000;
-constexpr std::uint32_t tfOnlyOne                      = 0x00020000;
-constexpr std::uint32_t tfUntilFailure                 = 0x00040000;
-constexpr std::uint32_t tfIndependent                  = 0x00080000;
-/**
- * @note If nested Batch transactions are supported in the future, the tfInnerBatchTxn flag
- *  will need to be removed from this mask to allow Batch transaction to be inside
- *  the sfRawTransactions array.
- */
-constexpr std::uint32_t const tfBatchMask =
-    ~(tfUniversal | tfAllOrNothing | tfOnlyOne | tfUntilFailure | tfIndependent) | tfInnerBatchTxn;
-
-// LoanSet and LoanPay flags:
-// LoanSet: True, indicates the loan supports overpayments
-// LoanPay: True, indicates any excess in this payment can be used
-// as an overpayment. False, no overpayments will be taken.
-constexpr std::uint32_t const tfLoanOverpayment = 0x00010000;
-// LoanPay exclusive flags:
-// tfLoanFullPayment: True, indicates that the payment is an early
-// full payment. It must pay the entire loan including close
-// interest and fees, or it will fail. False: Not a full payment.
-constexpr std::uint32_t const tfLoanFullPayment = 0x00020000;
-// tfLoanLatePayment: True, indicates that the payment is late,
-// and includes late interest and fees. If the loan is not late,
-// it will fail. False: not a late payment. If the current payment
-// is overdue, the transaction will fail.
-constexpr std::uint32_t const tfLoanLatePayment = 0x00040000;
-constexpr std::uint32_t const tfLoanSetMask = ~(tfUniversal |
-    tfLoanOverpayment);
-constexpr std::uint32_t const tfLoanPayMask = ~(tfUniversal |
-    tfLoanOverpayment | tfLoanFullPayment | tfLoanLatePayment);
-
-// LoanManage flags:
-constexpr std::uint32_t const tfLoanDefault = 0x00010000;
-constexpr std::uint32_t const tfLoanImpair = 0x00020000;
-constexpr std::uint32_t const tfLoanUnimpair = 0x00040000;
-constexpr std::uint32_t const tfLoanManageMask = ~(tfUniversal | tfLoanDefault | tfLoanImpair | tfLoanUnimpair);
+// TODO: Consider rewriting this using reflection in C++26 or later. Alternatively this could be a DSL processed by a script at build time.
+#define XMACRO(TRANSACTION, TF_FLAG, TF_FLAG2, MASK_ADJ)                                                                                                       \
+    TRANSACTION(AccountSet,                                                                                                                                    \
+        TF_FLAG(tfRequireDestTag, 0x00010000)                                                                                                                  \
+        TF_FLAG(tfOptionalDestTag, 0x00020000)                                                                                                                 \
+        TF_FLAG(tfRequireAuth, 0x00040000)                                                                                                                     \
+        TF_FLAG(tfOptionalAuth, 0x00080000)                                                                                                                    \
+        TF_FLAG(tfDisallowXRP, 0x00100000)                                                                                                                     \
+        TF_FLAG(tfAllowXRP, 0x00200000),                                                                                                                       \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(OfferCreate,                                                                                                                                   \
+        TF_FLAG(tfPassive, 0x00010000)                                                                                                                         \
+        TF_FLAG(tfImmediateOrCancel, 0x00020000)                                                                                                               \
+        TF_FLAG(tfFillOrKill, 0x00040000)                                                                                                                      \
+        TF_FLAG(tfSell, 0x00080000)                                                                                                                            \
+        TF_FLAG(tfHybrid, 0x00100000),                                                                                                                         \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(Payment,                                                                                                                                       \
+        TF_FLAG(tfNoRippleDirect, 0x00010000)                                                                                                                  \
+        TF_FLAG(tfPartialPayment, 0x00020000)                                                                                                                  \
+        TF_FLAG(tfLimitQuality, 0x00040000),                                                                                                                   \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(TrustSet,                                                                                                                                      \
+        TF_FLAG(tfSetfAuth, 0x00010000)                                                                                                                        \
+        TF_FLAG(tfSetNoRipple, 0x00020000)                                                                                                                     \
+        TF_FLAG(tfClearNoRipple, 0x00040000)                                                                                                                   \
+        TF_FLAG(tfSetFreeze, 0x00100000)                                                                                                                       \
+        TF_FLAG(tfClearFreeze, 0x00200000)                                                                                                                     \
+        TF_FLAG(tfSetDeepFreeze, 0x00400000)                                                                                                                   \
+        TF_FLAG(tfClearDeepFreeze, 0x00800000),                                                                                                                \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(EnableAmendment,                                                                                                                               \
+        TF_FLAG(tfGotMajority, 0x00010000)                                                                                                                     \
+        TF_FLAG(tfLostMajority, 0x00020000),                                                                                                                   \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(PaymentChannelClaim,                                                                                                                           \
+        TF_FLAG(tfRenew, 0x00010000)                                                                                                                           \
+        TF_FLAG(tfClose, 0x00020000),                                                                                                                          \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(NFTokenMint,                                                                                                                                   \
+        TF_FLAG(tfBurnable, 0x00000001)                                                                                                                        \
+        TF_FLAG(tfOnlyXRP, 0x00000002)                                                                                                                         \
+        /* deprecated TF_FLAG(tfTrustLine, 0x00000004) */                                                                                                      \
+        TF_FLAG(tfTransferable, 0x00000008)                                                                                                                    \
+        TF_FLAG(tfMutable, 0x00000010),                                                                                                                        \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(MPTokenIssuanceCreate,                                                                                                                         \
+        /* Note: tf/lsfMPTLocked is intentionally omitted since this transaction is not allowed to modify it. */                                               \
+        TF_FLAG(tfMPTCanLock, lsfMPTCanLock)                                                                                                                   \
+        TF_FLAG(tfMPTRequireAuth, lsfMPTRequireAuth)                                                                                                           \
+        TF_FLAG(tfMPTCanEscrow, lsfMPTCanEscrow)                                                                                                               \
+        TF_FLAG(tfMPTCanTrade, lsfMPTCanTrade)                                                                                                                 \
+        TF_FLAG(tfMPTCanTransfer, lsfMPTCanTransfer)                                                                                                           \
+        TF_FLAG(tfMPTCanClawback, lsfMPTCanClawback),                                                                                                          \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(MPTokenAuthorize,                                                                                                                              \
+        TF_FLAG(tfMPTUnauthorize, 0x00000001),                                                                                                                 \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(MPTokenIssuanceSet,                                                                                                                            \
+        TF_FLAG(tfMPTLock, 0x00000001)                                                                                                                         \
+        TF_FLAG(tfMPTUnlock, 0x00000002),                                                                                                                      \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(NFTokenCreateOffer,                                                                                                                            \
+        TF_FLAG(tfSellNFToken, 0x00000001),                                                                                                                    \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(AMMDeposit,                                                                                                                                    \
+        TF_FLAG(tfLPToken, 0x00010000)                                                                                                                         \
+        TF_FLAG(tfSingleAsset, 0x00080000)                                                                                                                     \
+        TF_FLAG(tfTwoAsset, 0x00100000)                                                                                                                        \
+        TF_FLAG(tfOneAssetLPToken, 0x00200000)                                                                                                                 \
+        TF_FLAG(tfLimitLPToken, 0x00400000)                                                                                                                    \
+        TF_FLAG(tfTwoAssetIfEmpty, 0x00800000),                                                                                                                \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(AMMWithdraw,                                                                                                                                   \
+        TF_FLAG2(tfLPToken, 0x00010000)                                                                                                                        \
+        TF_FLAG(tfWithdrawAll, 0x00020000)                                                                                                                     \
+        TF_FLAG(tfOneAssetWithdrawAll, 0x00040000)                                                                                                             \
+        TF_FLAG2(tfSingleAsset, 0x00080000)                                                                                                                    \
+        TF_FLAG2(tfTwoAsset, 0x00100000)                                                                                                                       \
+        TF_FLAG2(tfOneAssetLPToken, 0x00200000)                                                                                                                \
+        TF_FLAG2(tfLimitLPToken, 0x00400000),                                                                                                                  \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(AMMClawback,                                                                                                                                   \
+        TF_FLAG(tfClawTwoAssets, 0x00000001),                                                                                                                  \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(XChainModifyBridge,                                                                                                                            \
+        TF_FLAG(tfClearAccountCreateAmount, 0x00010000),                                                                                                       \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(VaultCreate,                                                                                                                                   \
+        TF_FLAG(tfVaultPrivate, lsfVaultPrivate)                                                                                                               \
+        TF_FLAG(tfVaultShareNonTransferable, 0x00020000),                                                                                                      \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(Batch,                                                                                                                                         \
+        TF_FLAG(tfAllOrNothing, 0x00010000)                                                                                                                    \
+        TF_FLAG(tfOnlyOne, 0x00020000)                                                                                                                         \
+        TF_FLAG(tfUntilFailure, 0x00040000)                                                                                                                    \
+        TF_FLAG(tfIndependent, 0x00080000),                                                                                                                    \
+        MASK_ADJ(tfInnerBatchTxn))                      /* Batch must reject tfInnerBatchTxn - only inner transactions should have this flag */                \
+                                                                                                                                                               \
+    TRANSACTION(LoanSet,                                /* True indicates the loan supports overpayments */                                                    \
+        TF_FLAG(tfLoanOverpayment, 0x00010000),                                                                                                                \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(LoanPay,                                /* True indicates any excess in this payment can be used as an overpayment. */                         \
+                                                        /* False: no overpayments will be taken. */                                                            \
+        TF_FLAG2(tfLoanOverpayment, 0x00010000)                                                                                                                \
+        TF_FLAG(tfLoanFullPayment, 0x00020000)          /* True indicates that the payment is an early full payment. */                                        \
+                                                        /* It must pay the entire loan including close interest and fees, or it will fail. */                  \
+                                                        /* False: Not a full payment. */                                                                       \
+        TF_FLAG(tfLoanLatePayment, 0x00040000),         /* True indicates that the payment is late, and includes late interest and fees. */                    \
+                                                        /* If the loan is not late, it will fail. */                                                           \
+                                                        /* False: not a late payment. If the current payment is overdue, the transaction will fail.*/          \
+        MASK_ADJ(0))                                                                                                                                           \
+                                                                                                                                                               \
+    TRANSACTION(LoanManage,                                                                                                                                    \
+        TF_FLAG(tfLoanDefault, 0x00010000)                                                                                                                     \
+        TF_FLAG(tfLoanImpair, 0x00020000)                                                                                                                      \
+        TF_FLAG(tfLoanUnimpair, 0x00040000),                                                                                                                   \
+        MASK_ADJ(0))
 
 // clang-format on
 
+// Create all the flag values.
+//
+// example:
+// inline constexpr FlagValue tfAccountSetRequireDestTag = 0x00010000;
+#define TO_VALUE(name, value) inline constexpr FlagValue name = value;
+#define NULL_NAME(name, values, maskAdj) values
+#define NULL_OUTPUT(name, value)
+#define NULL_MASK_ADJ(value)
+XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT, NULL_MASK_ADJ)
+
+// Create masks for each transaction type that has flags.
+//
+// example:
+// inline constexpr FlagValue tfAccountSetMask = ~(tfUniversal | tfRequireDestTag |
+//     tfOptionalDestTag | tfRequireAuth | tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
+//
+// The mask adjustment (maskAdj) allows adding flags back to the mask, making them invalid.
+// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) to reject tfInnerBatchTxn on outer Batch.
+#define TO_MASK(name, values, maskAdj) \
+    inline constexpr FlagValue tf##name##Mask = ~(tfUniversal values) | maskAdj;
+#define VALUE_TO_MASK(name, value) | name
+#define MASK_ADJ_TO_MASK(value) value
+XMACRO(TO_MASK, VALUE_TO_MASK, VALUE_TO_MASK, MASK_ADJ_TO_MASK)
+
+// Verify that tfBatchMask correctly rejects tfInnerBatchTxn.
+// The outer Batch transaction must NOT have tfInnerBatchTxn set; only inner transactions should
+// have it.
+static_assert(
+    (tfBatchMask & tfInnerBatchTxn) == tfInnerBatchTxn,
+    "tfBatchMask must include tfInnerBatchTxn to reject it on outer Batch");
+
+// Verify that other transaction masks correctly allow tfInnerBatchTxn.
+// Inner transactions need tfInnerBatchTxn to be valid, so these masks must not reject it.
+static_assert(
+    (tfPaymentMask & tfInnerBatchTxn) == 0,
+    "tfPaymentMask must not reject tfInnerBatchTxn");
+static_assert(
+    (tfAccountSetMask & tfInnerBatchTxn) == 0,
+    "tfAccountSetMask must not reject tfInnerBatchTxn");
+
+// Create getter functions for each set of flags using Meyer's singleton pattern.
+// This avoids static initialization order fiasco while still providing efficient access.
+// This is used below in `getAllTxFlags()` to generate the server_definitions RPC
+// output.
+//
+// example:
+// inline FlagMap const& getAccountSetFlags() {
+//     static FlagMap const flags = {
+//         {"tfRequireDestTag", 0x00010000},
+//         {"tfOptionalDestTag", 0x00020000},
+//     ...};
+//     return flags;
+// }
+using FlagMap = std::map<std::string, FlagValue>;
+#define VALUE_TO_MAP(name, value) {#name, value},
+#define TO_MAP(name, values, maskAdj)          \
+    inline FlagMap const& get##name##Flags()   \
+    {                                          \
+        static FlagMap const flags = {values}; \
+        return flags;                          \
+    }
+XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP, NULL_MASK_ADJ)
+
+inline FlagMap const&
+getUniversalFlags()
+{
+    static FlagMap const flags = {
+        {"tfFullyCanonicalSig", tfFullyCanonicalSig}, {"tfInnerBatchTxn", tfInnerBatchTxn}};
+    return flags;
+}
+
+// Create a getter function for all transaction flag maps using Meyer's singleton pattern.
+// This is used to generate the server_definitions RPC output.
+//
+// example:
+// inline FlagMapPairList const& getAllTxFlags() {
+//     static FlagMapPairList const flags = {
+//         {"AccountSet", getAccountSetFlags()},
+//     ...};
+//     return flags;
+// }
+using FlagMapPairList = std::vector<std::pair<std::string, FlagMap>>;
+#define ALL_TX_FLAGS(name, values, maskAdj) {#name, get##name##Flags()},
+inline FlagMapPairList const&
+getAllTxFlags()
+{
+    static FlagMapPairList const flags = {
+        {"universal", getUniversalFlags()},
+        XMACRO(ALL_TX_FLAGS, NULL_OUTPUT, NULL_OUTPUT, NULL_MASK_ADJ)};
+    return flags;
+}
+
+#undef XMACRO
+#undef TO_VALUE
+#undef VALUE_TO_MAP
+#undef NULL_NAME
+#undef NULL_OUTPUT
+#undef TO_MAP
+#undef TO_MASK
+#undef VALUE_TO_MASK
+#undef ALL_TX_FLAGS
+#undef NULL_MASK_ADJ
+#undef MASK_ADJ_TO_MASK
+
+#pragma pop_macro("XMACRO")
+#pragma pop_macro("TO_VALUE")
+#pragma pop_macro("VALUE_TO_MAP")
+#pragma pop_macro("NULL_NAME")
+#pragma pop_macro("NULL_OUTPUT")
+#pragma pop_macro("TO_MAP")
+#pragma pop_macro("TO_MASK")
+#pragma pop_macro("VALUE_TO_MASK")
+#pragma pop_macro("ALL_TX_FLAGS")
+#pragma pop_macro("NULL_MASK_ADJ")
+#pragma pop_macro("MASK_ADJ_TO_MASK")
+
+// Additional transaction masks and combos
+inline constexpr FlagValue tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
+inline constexpr FlagValue tfTrustSetPermissionMask =
+    ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
+
+// MPTokenIssuanceCreate MutableFlags:
+// Indicating specific fields or flags may be changed after issuance.
+inline constexpr FlagValue tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
+inline constexpr FlagValue tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
+inline constexpr FlagValue tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
+inline constexpr FlagValue tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
+inline constexpr FlagValue tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
+inline constexpr FlagValue tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
+inline constexpr FlagValue tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
+inline constexpr FlagValue tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
+inline constexpr FlagValue tmfMPTokenIssuanceCreateMutableMask =
+    ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow |
+      tmfMPTCanMutateCanTrade | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback |
+      tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
+
+// MPTokenIssuanceSet MutableFlags:
+// Set or Clear flags.
+
+inline constexpr FlagValue tmfMPTSetCanLock = 0x00000001;
+inline constexpr FlagValue tmfMPTClearCanLock = 0x00000002;
+inline constexpr FlagValue tmfMPTSetRequireAuth = 0x00000004;
+inline constexpr FlagValue tmfMPTClearRequireAuth = 0x00000008;
+inline constexpr FlagValue tmfMPTSetCanEscrow = 0x00000010;
+inline constexpr FlagValue tmfMPTClearCanEscrow = 0x00000020;
+inline constexpr FlagValue tmfMPTSetCanTrade = 0x00000040;
+inline constexpr FlagValue tmfMPTClearCanTrade = 0x00000080;
+inline constexpr FlagValue tmfMPTSetCanTransfer = 0x00000100;
+inline constexpr FlagValue tmfMPTClearCanTransfer = 0x00000200;
+inline constexpr FlagValue tmfMPTSetCanClawback = 0x00000400;
+inline constexpr FlagValue tmfMPTClearCanClawback = 0x00000800;
+inline constexpr FlagValue tmfMPTokenIssuanceSetMutableMask = ~(
+    tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTSetRequireAuth | tmfMPTClearRequireAuth |
+    tmfMPTSetCanEscrow | tmfMPTClearCanEscrow | tmfMPTSetCanTrade | tmfMPTClearCanTrade |
+    tmfMPTSetCanTransfer | tmfMPTClearCanTransfer | tmfMPTSetCanClawback | tmfMPTClearCanClawback);
+
+// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between accounts allowed a
+// TrustLine to be added to the issuer of that token without explicit permission from that issuer.
+// This was enabled by minting the NFToken with the tfTrustLine flag set.
+//
+// That capability could be used to attack the NFToken issuer.
+// It would be possible for two accounts to trade the NFToken back and forth building up any number
+// of TrustLines on the issuer, increasing the issuer's reserve without bound.
+//
+// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the tfTrustLine flag as a way
+// to prevent the attack. But until the amendment passes we still need to keep the old behavior
+// available.
+inline constexpr FlagValue tfTrustLine = 0x00000004;  // needed for backwards compatibility
+inline constexpr FlagValue tfNFTokenMintMaskWithoutMutable =
+    ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
+
+inline constexpr FlagValue tfNFTokenMintOldMask = ~(~tfNFTokenMintMaskWithoutMutable | tfTrustLine);
+
+// if featureDynamicNFT enabled then new flag allowing mutable URI available.
+inline constexpr FlagValue tfNFTokenMintOldMaskWithMutable = ~(~tfNFTokenMintOldMask | tfMutable);
+
+inline constexpr FlagValue tfWithdrawSubTx = tfLPToken | tfSingleAsset | tfTwoAsset |
+    tfOneAssetLPToken | tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
+inline constexpr FlagValue tfDepositSubTx =
+    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken | tfLimitLPToken | tfTwoAssetIfEmpty;
+
+#pragma push_macro("ACCOUNTSET_FLAGS")
+#pragma push_macro("ACCOUNTSET_FLAG_TO_VALUE")
+#pragma push_macro("ACCOUNTSET_FLAG_TO_MAP")
+
+// AccountSet SetFlag/ClearFlag values
+#define ACCOUNTSET_FLAGS(ASF_FLAG)                \
+    ASF_FLAG(asfRequireDest, 1)                   \
+    ASF_FLAG(asfRequireAuth, 2)                   \
+    ASF_FLAG(asfDisallowXRP, 3)                   \
+    ASF_FLAG(asfDisableMaster, 4)                 \
+    ASF_FLAG(asfAccountTxnID, 5)                  \
+    ASF_FLAG(asfNoFreeze, 6)                      \
+    ASF_FLAG(asfGlobalFreeze, 7)                  \
+    ASF_FLAG(asfDefaultRipple, 8)                 \
+    ASF_FLAG(asfDepositAuth, 9)                   \
+    ASF_FLAG(asfAuthorizedNFTokenMinter, 10)      \
+    /*  11 is reserved for Hooks amendment */     \
+    /* ASF_FLAG(asfTshCollect, 11) */             \
+    ASF_FLAG(asfDisallowIncomingNFTokenOffer, 12) \
+    ASF_FLAG(asfDisallowIncomingCheck, 13)        \
+    ASF_FLAG(asfDisallowIncomingPayChan, 14)      \
+    ASF_FLAG(asfDisallowIncomingTrustline, 15)    \
+    ASF_FLAG(asfAllowTrustLineClawback, 16)       \
+    ASF_FLAG(asfAllowTrustLineLocking, 17)
+
+#define ACCOUNTSET_FLAG_TO_VALUE(name, value) inline constexpr FlagValue name = value;
+#define ACCOUNTSET_FLAG_TO_MAP(name, value) {#name, value},
+
+ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_VALUE)
+
+inline std::map<std::string, FlagValue> const&
+getAsfFlagMap()
+{
+    static std::map<std::string, FlagValue> const flags = {
+        ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_MAP)};
+    return flags;
+}
+
+#undef ACCOUNTSET_FLAG_TO_VALUE
+#undef ACCOUNTSET_FLAG_TO_MAP
+#undef ACCOUNTSET_FLAGS
+
+#pragma pop_macro("ACCOUNTSET_FLAG_TO_VALUE")
+#pragma pop_macro("ACCOUNTSET_FLAG_TO_MAP")
+#pragma pop_macro("ACCOUNTSET_FLAGS")
+
 }  // namespace xrpl
diff --git a/include/xrpl/protocol/TxFormats.h b/include/xrpl/protocol/TxFormats.h
index b76eef7585..563a28f39f 100644
--- a/include/xrpl/protocol/TxFormats.h
+++ b/include/xrpl/protocol/TxFormats.h
@@ -2,6 +2,8 @@
 
 #include <xrpl/protocol/KnownFormats.h>
 
+#include <vector>
+
 namespace xrpl {
 
 /** Transaction type identifiers.
@@ -73,6 +75,9 @@ private:
 public:
     static TxFormats const&
     getInstance();
+
+    static std::vector<SOElement> const&
+    getCommonFields();
 };
 
 }  // namespace xrpl
diff --git a/include/xrpl/protocol/detail/STVar.h b/include/xrpl/protocol/detail/STVar.h
index b5373d1a4a..bab2c2e024 100644
--- a/include/xrpl/protocol/detail/STVar.h
+++ b/include/xrpl/protocol/detail/STVar.h
@@ -44,7 +44,7 @@ private:
     // The largest "small object" we can accommodate
     static std::size_t constexpr max_size = 72;
 
-    std::aligned_storage<max_size>::type d_;
+    std::aligned_storage<max_size>::type d_ = {};
     STBase* p_ = nullptr;
 
 public:
diff --git a/include/xrpl/protocol/detail/transactions.macro b/include/xrpl/protocol/detail/transactions.macro
index 973a51d912..5063b7abc8 100644
--- a/include/xrpl/protocol/detail/transactions.macro
+++ b/include/xrpl/protocol/detail/transactions.macro
@@ -22,7 +22,7 @@
 
 /** This transaction type executes a payment. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Payment.h>
+#   include <xrpl/tx/transactors/payment/Payment.h>
 #endif
 TRANSACTION(ttPAYMENT, 0, Payment,
     Delegation::delegable,
@@ -42,7 +42,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 
 /** This transaction type creates an escrow object. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Escrow.h>
+#   include <xrpl/tx/transactors/escrow/EscrowCreate.h>
 #endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
     Delegation::delegable,
@@ -58,6 +58,9 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
 }))
 
 /** This transaction type completes an existing escrow. */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/escrow/EscrowFinish.h>
+#endif
 TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
     Delegation::delegable,
     uint256{},
@@ -73,7 +76,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
 
 /** This transaction type adjusts various account settings. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/SetAccount.h>
+#   include <xrpl/tx/transactors/account/SetAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
     Delegation::notDelegable,
@@ -94,7 +97,7 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 
 /** This transaction type cancels an existing escrow. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Escrow.h>
+#   include <xrpl/tx/transactors/escrow/EscrowCancel.h>
 #endif
 TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
     Delegation::delegable,
@@ -107,7 +110,7 @@ TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
 
 /** This transaction type sets or clears an account's "regular key". */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/SetRegularKey.h>
+#   include <xrpl/tx/transactors/account/SetRegularKey.h>
 #endif
 TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
     Delegation::notDelegable,
@@ -121,7 +124,7 @@ TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
 
 /** This transaction type creates an offer to trade one asset for another. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Offer/CreateOffer.h>
+#   include <xrpl/tx/transactors/dex/CreateOffer.h>
 #endif
 TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
     Delegation::delegable,
@@ -137,7 +140,7 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
 
 /** This transaction type cancels existing offers to trade one asset for another. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Offer/CancelOffer.h>
+#   include <xrpl/tx/transactors/dex/CancelOffer.h>
 #endif
 TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
     Delegation::delegable,
@@ -151,7 +154,7 @@ TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
 
 /** This transaction type creates a new set of tickets. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/CreateTicket.h>
+#   include <xrpl/tx/transactors/system/CreateTicket.h>
 #endif
 TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
     Delegation::delegable,
@@ -167,7 +170,7 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
 // The SignerEntries are optional because a SignerList is deleted by
 // setting the SignerQuorum to zero and omitting SignerEntries.
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/SetSignerList.h>
+#   include <xrpl/tx/transactors/account/SetSignerList.h>
 #endif
 TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
     Delegation::notDelegable,
@@ -180,7 +183,7 @@ TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/PayChan.h>
+#   include <xrpl/tx/transactors/payment_channel/PayChanCreate.h>
 #endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
     Delegation::delegable,
@@ -196,6 +199,9 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 }))
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/payment_channel/PayChanFund.h>
+#endif
 TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
     Delegation::delegable,
     uint256{},
@@ -207,6 +213,9 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
 }))
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/payment_channel/PayChanClaim.h>
+#endif
 TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
     Delegation::delegable,
     uint256{},
@@ -222,7 +231,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
 
 /** This transaction type creates a new check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Check/CreateCheck.h>
+#   include <xrpl/tx/transactors/check/CreateCheck.h>
 #endif
 TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
     Delegation::delegable,
@@ -238,7 +247,7 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
 
 /** This transaction type cashes an existing check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Check/CashCheck.h>
+#   include <xrpl/tx/transactors/check/CashCheck.h>
 #endif
 TRANSACTION(ttCHECK_CASH, 17, CheckCash,
     Delegation::delegable,
@@ -252,7 +261,7 @@ TRANSACTION(ttCHECK_CASH, 17, CheckCash,
 
 /** This transaction type cancels an existing check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Check/CancelCheck.h>
+#   include <xrpl/tx/transactors/check/CancelCheck.h>
 #endif
 TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
     Delegation::delegable,
@@ -264,7 +273,7 @@ TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
 
 /** This transaction type grants or revokes authorization to transfer funds. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/DepositPreauth.h>
+#   include <xrpl/tx/transactors/payment/DepositPreauth.h>
 #endif
 TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
     Delegation::delegable,
@@ -279,7 +288,7 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
 
 /** This transaction type modifies a trustline between two accounts. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/SetTrust.h>
+#   include <xrpl/tx/transactors/token/SetTrust.h>
 #endif
 TRANSACTION(ttTRUST_SET, 20, TrustSet,
     Delegation::delegable,
@@ -293,7 +302,7 @@ TRANSACTION(ttTRUST_SET, 20, TrustSet,
 
 /** This transaction type deletes an existing account. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/DeleteAccount.h>
+#   include <xrpl/tx/transactors/account/DeleteAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
     Delegation::notDelegable,
@@ -309,7 +318,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
 
 /** This transaction mints a new NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenMint.h>
+#   include <xrpl/tx/transactors/nft/NFTokenMint.h>
 #endif
 TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
     Delegation::delegable,
@@ -327,7 +336,7 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
 
 /** This transaction burns (i.e. destroys) an existing NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenBurn.h>
+#   include <xrpl/tx/transactors/nft/NFTokenBurn.h>
 #endif
 TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
     Delegation::delegable,
@@ -340,7 +349,7 @@ TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
 
 /** This transaction creates a new offer to buy or sell an NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenCreateOffer.h>
+#   include <xrpl/tx/transactors/nft/NFTokenCreateOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
     Delegation::delegable,
@@ -356,7 +365,7 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
 
 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenCancelOffer.h>
+#   include <xrpl/tx/transactors/nft/NFTokenCancelOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
     Delegation::delegable,
@@ -368,7 +377,7 @@ TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
 
 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h>
+#   include <xrpl/tx/transactors/nft/NFTokenAcceptOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
     Delegation::delegable,
@@ -382,7 +391,7 @@ TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
 
 /** This transaction claws back issued tokens. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Clawback.h>
+#   include <xrpl/tx/transactors/token/Clawback.h>
 #endif
 TRANSACTION(ttCLAWBACK, 30, Clawback,
     Delegation::delegable,
@@ -395,7 +404,7 @@ TRANSACTION(ttCLAWBACK, 30, Clawback,
 
 /** This transaction claws back tokens from an AMM pool. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMClawback.h>
+#   include <xrpl/tx/transactors/dex/AMMClawback.h>
 #endif
 TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
     Delegation::delegable,
@@ -410,7 +419,7 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
 
 /** This transaction type creates an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMCreate.h>
+#   include <xrpl/tx/transactors/dex/AMMCreate.h>
 #endif
 TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
     Delegation::delegable,
@@ -424,7 +433,7 @@ TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
 
 /** This transaction type deposits into an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMDeposit.h>
+#   include <xrpl/tx/transactors/dex/AMMDeposit.h>
 #endif
 TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
     Delegation::delegable,
@@ -442,7 +451,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
 
 /** This transaction type withdraws from an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
+#   include <xrpl/tx/transactors/dex/AMMWithdraw.h>
 #endif
 TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
     Delegation::delegable,
@@ -459,7 +468,7 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
 
 /** This transaction type votes for the trading fee */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMVote.h>
+#   include <xrpl/tx/transactors/dex/AMMVote.h>
 #endif
 TRANSACTION(ttAMM_VOTE, 38, AMMVote,
     Delegation::delegable,
@@ -473,7 +482,7 @@ TRANSACTION(ttAMM_VOTE, 38, AMMVote,
 
 /** This transaction type bids for the auction slot */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMBid.h>
+#   include <xrpl/tx/transactors/dex/AMMBid.h>
 #endif
 TRANSACTION(ttAMM_BID, 39, AMMBid,
     Delegation::delegable,
@@ -489,7 +498,7 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
 
 /** This transaction type deletes AMM in the empty state */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/AMM/AMMDelete.h>
+#   include <xrpl/tx/transactors/dex/AMMDelete.h>
 #endif
 TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
     Delegation::delegable,
@@ -502,7 +511,7 @@ TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
 
 /** This transactions creates a crosschain sequence number */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/XChainBridge.h>
+#   include <xrpl/tx/transactors/bridge/XChainBridge.h>
 #endif
 TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
     Delegation::delegable,
@@ -617,7 +626,7 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
 
 /** This transaction type creates or updates a DID */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/DID.h>
+#   include <xrpl/tx/transactors/did/DIDSet.h>
 #endif
 TRANSACTION(ttDID_SET, 49, DIDSet,
     Delegation::delegable,
@@ -630,6 +639,9 @@ TRANSACTION(ttDID_SET, 49, DIDSet,
 }))
 
 /** This transaction type deletes a DID */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/did/DIDDelete.h>
+#endif
 TRANSACTION(ttDID_DELETE, 50, DIDDelete,
     Delegation::delegable,
     featureDID,
@@ -638,7 +650,7 @@ TRANSACTION(ttDID_DELETE, 50, DIDDelete,
 
 /** This transaction type creates an Oracle instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/SetOracle.h>
+#   include <xrpl/tx/transactors/oracle/SetOracle.h>
 #endif
 TRANSACTION(ttORACLE_SET, 51, OracleSet,
     Delegation::delegable,
@@ -655,7 +667,7 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
 
 /** This transaction type deletes an Oracle instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/DeleteOracle.h>
+#   include <xrpl/tx/transactors/oracle/DeleteOracle.h>
 #endif
 TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
     Delegation::delegable,
@@ -667,7 +679,7 @@ TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
 
 /** This transaction type fixes a problem in the ledger state */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/LedgerStateFix.h>
+#   include <xrpl/tx/transactors/system/LedgerStateFix.h>
 #endif
 TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
     Delegation::delegable,
@@ -680,7 +692,7 @@ TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
 
 /** This transaction type creates a MPTokensIssuance instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h>
+#   include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
     Delegation::delegable,
@@ -697,7 +709,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
 
 /** This transaction type destroys a MPTokensIssuance instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h>
+#   include <xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
     Delegation::delegable,
@@ -709,7 +721,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
 
 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h>
+#   include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
     Delegation::delegable,
@@ -726,7 +738,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
 
 /** This transaction type authorizes a MPToken instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
+#   include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
 #endif
 TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
     Delegation::delegable,
@@ -739,7 +751,7 @@ TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
 
 /** This transaction type create an Credential instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Credentials.h>
+#   include <xrpl/tx/transactors/credentials/CredentialCreate.h>
 #endif
 TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
     Delegation::delegable,
@@ -753,6 +765,9 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
 }))
 
 /** This transaction type accept an Credential object */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/credentials/CredentialAccept.h>
+#endif
 TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
     Delegation::delegable,
     featureCredentials,
@@ -763,6 +778,9 @@ TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
 }))
 
 /** This transaction type delete an Credential object */
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/credentials/CredentialDelete.h>
+#endif
 TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
     Delegation::delegable,
     featureCredentials,
@@ -775,7 +793,7 @@ TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
 
 /** This transaction type modify a NFToken */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/NFT/NFTokenModify.h>
+#   include <xrpl/tx/transactors/nft/NFTokenModify.h>
 #endif
 TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
     Delegation::delegable,
@@ -789,7 +807,7 @@ TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
 
 /** This transaction type creates or modifies a Permissioned Domain */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
+#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
     Delegation::delegable,
@@ -802,7 +820,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
 
 /** This transaction type deletes a Permissioned Domain */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h>
+#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
     Delegation::delegable,
@@ -814,7 +832,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
 
 /** This transaction type delegates authorized account specified permissions */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Delegate/DelegateSet.h>
+#   include <xrpl/tx/transactors/delegate/DelegateSet.h>
 #endif
 TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
     Delegation::notDelegable,
@@ -827,10 +845,10 @@ TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
 
 /** This transaction creates a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultCreate.h>
+#   include <xrpl/tx/transactors/vault/VaultCreate.h>
 #endif
 TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     createPseudoAcct | createMPTIssuance | mustModifyVault,
     ({
@@ -845,10 +863,10 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
 
 /** This transaction updates a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultSet.h>
+#   include <xrpl/tx/transactors/vault/VaultSet.h>
 #endif
 TRANSACTION(ttVAULT_SET, 66, VaultSet,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     mustModifyVault,
     ({
@@ -860,10 +878,10 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet,
 
 /** This transaction deletes a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultDelete.h>
+#   include <xrpl/tx/transactors/vault/VaultDelete.h>
 #endif
 TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     mustDeleteAcct | destroyMPTIssuance | mustModifyVault,
     ({
@@ -872,10 +890,10 @@ TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
 
 /** This transaction trades assets for shares with a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultDeposit.h>
+#   include <xrpl/tx/transactors/vault/VaultDeposit.h>
 #endif
 TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     mayAuthorizeMPT | mustModifyVault,
     ({
@@ -885,10 +903,10 @@ TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
 
 /** This transaction trades shares for assets with a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultWithdraw.h>
+#   include <xrpl/tx/transactors/vault/VaultWithdraw.h>
 #endif
 TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     mayDeleteMPT | mayAuthorizeMPT | mustModifyVault,
     ({
@@ -900,10 +918,10 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
 
 /** This transaction claws back tokens from a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Vault/VaultClawback.h>
+#   include <xrpl/tx/transactors/vault/VaultClawback.h>
 #endif
 TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureSingleAssetVault,
     mayDeleteMPT | mustModifyVault,
     ({
@@ -914,7 +932,7 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
 
 /** This transaction type batches together transactions. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Batch.h>
+#   include <xrpl/tx/transactors/system/Batch.h>
 #endif
 TRANSACTION(ttBATCH, 71, Batch,
     Delegation::notDelegable,
@@ -929,10 +947,10 @@ TRANSACTION(ttBATCH, 71, Batch,
 
 /** This transaction creates and updates a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanBrokerSet.h>
+#   include <xrpl/tx/transactors/lending/LoanBrokerSet.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     createPseudoAcct | mayAuthorizeMPT, ({
     {sfVaultID, soeREQUIRED},
@@ -946,10 +964,10 @@ TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
 
 /** This transaction deletes a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanBrokerDelete.h>
+#   include <xrpl/tx/transactors/lending/LoanBrokerDelete.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     mustDeleteAcct | mayAuthorizeMPT, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -957,10 +975,10 @@ TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
 
 /** This transaction deposits First Loss Capital into a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h>
+#   include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -969,10 +987,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
 
 /** This transaction withdraws First Loss Capital from a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h>
+#   include <xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     mayAuthorizeMPT, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -984,10 +1002,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
 /** This transaction claws back First Loss Capital from a Loan Broker to
     the issuer of the capital */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h>
+#   include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanBrokerID, soeOPTIONAL},
@@ -996,10 +1014,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
 
 /** This transaction creates a Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanSet.h>
+#   include <xrpl/tx/transactors/lending/LoanSet.h>
 #endif
 TRANSACTION(ttLOAN_SET, 80, LoanSet,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     mayAuthorizeMPT | mustModifyVault, ({
     {sfLoanBrokerID, soeREQUIRED},
@@ -1023,10 +1041,10 @@ TRANSACTION(ttLOAN_SET, 80, LoanSet,
 
 /** This transaction deletes an existing Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanDelete.h>
+#   include <xrpl/tx/transactors/lending/LoanDelete.h>
 #endif
 TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     noPriv, ({
     {sfLoanID, soeREQUIRED},
@@ -1034,10 +1052,10 @@ TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
 
 /** This transaction is used to change the delinquency status of an existing Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanManage.h>
+#   include <xrpl/tx/transactors/lending/LoanManage.h>
 #endif
 TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     // All of the LoanManage options will modify the vault, but the
     // transaction can succeed without options, essentially making it
@@ -1048,10 +1066,10 @@ TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
 
 /** The Borrower uses this transaction to make a Payment on the Loan. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Lending/LoanPay.h>
+#   include <xrpl/tx/transactors/lending/LoanPay.h>
 #endif
 TRANSACTION(ttLOAN_PAY, 84, LoanPay,
-    Delegation::delegable,
+    Delegation::notDelegable,
     featureLendingProtocol,
     mayAuthorizeMPT | mustModifyVault, ({
     {sfLoanID, soeREQUIRED},
@@ -1063,7 +1081,7 @@ TRANSACTION(ttLOAN_PAY, 84, LoanPay,
     For details, see: https://xrpl.org/amendments.html
  */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/Change.h>
+#   include <xrpl/tx/transactors/system/Change.h>
 #endif
 TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
     Delegation::notDelegable,
diff --git a/include/xrpl/protocol/digest.h b/include/xrpl/protocol/digest.h
index b5ec277e7b..9e6606f51f 100644
--- a/include/xrpl/protocol/digest.h
+++ b/include/xrpl/protocol/digest.h
@@ -40,7 +40,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[96];
+    char ctx_[96]{};
 };
 
 /** SHA-512 digest
@@ -63,7 +63,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[216];
+    char ctx_[216]{};
 };
 
 /** SHA-256 digest
@@ -86,7 +86,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[112];
+    char ctx_[112]{};
 };
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/protocol/jss.h b/include/xrpl/protocol/jss.h
index 0264f625eb..0a877cb96a 100644
--- a/include/xrpl/protocol/jss.h
+++ b/include/xrpl/protocol/jss.h
@@ -25,6 +25,7 @@ namespace jss {
 JSS(AL_size);              // out: GetCounts
 JSS(AL_hit_rate);          // out: GetCounts
 JSS(AcceptedCredentials);  // out: AccountObjects
+JSS(ACCOUNT_SET_FLAGS);    // out: RPC server_definitions
 JSS(Account);              // in: TransactionSign; field.
 JSS(AMMID);                // field
 JSS(Amount);               // in: TransactionSign; field.
@@ -111,6 +112,7 @@ JSS(accounts);                // in: LedgerEntry, Subscribe,
                               //     handlers/Ledger, Unsubscribe
 JSS(accounts_proposed);       // in: Subscribe, Unsubscribe
 JSS(action);
+JSS(active);                  // out: OverlayImpl
 JSS(acquiring);               // out: LedgerRequest
 JSS(address);                 // out: PeerImp
 JSS(affected);                // out: AcceptedLedgerTx
@@ -187,6 +189,7 @@ JSS(closed_ledger);           // out: NetworkOPs
 JSS(cluster);                 // out: PeerImp
 JSS(code);                    // out: errors
 JSS(command);                 // in: RPCHandler
+JSS(common);                  // out: RPC server_definitions
 JSS(complete);                // out: NetworkOPs, InboundLedger
 JSS(complete_ledgers);        // out: NetworkOPs, PeerImp
 JSS(consensus);               // out: NetworkOPs, LedgerConsensus
@@ -298,6 +301,7 @@ JSS(id);                      // websocket.
 JSS(ident);                   // in: AccountCurrencies, AccountInfo,
                               //     OwnerInfo
 JSS(ignore_default);          // in: AccountLines
+JSS(in);                      // out: OverlayImpl
 JSS(inLedger);                // out: tx/Transaction
 JSS(inbound);                 // out: PeerImp
 JSS(index);                   // in: LedgerEntry
@@ -356,6 +360,8 @@ JSS(ledger_min);              // in, out: AccountTx*
 JSS(ledger_time);             // out: NetworkOPs
 JSS(LEDGER_ENTRY_TYPES);      // out: RPC server_definitions
                               // matches definitions.json format
+JSS(LEDGER_ENTRY_FLAGS);      // out: RPC server_definitions
+JSS(LEDGER_ENTRY_FORMATS);    // out: RPC server_definitions
 JSS(levels);                  // LogLevels
 JSS(limit);                   // in/out: AccountTx*, AccountOffers,
                               //         AccountLines, AccountObjects
@@ -457,8 +463,10 @@ JSS(open);                    // out: handlers/Ledger
 JSS(open_ledger_cost);        // out: SubmitTransaction
 JSS(open_ledger_fee);         // out: TxQ
 JSS(open_ledger_level);       // out: TxQ
+JSS(optionality);             // out: server_definitions
 JSS(oracles);                 // in: get_aggregate_price
 JSS(oracle_document_id);      // in: get_aggregate_price
+JSS(out);                     // out: OverlayImpl
 JSS(owner);                   // in: LedgerEntry, out: NetworkOPs
 JSS(owner_funds);             // in/out: Ledger, NetworkOPs, AcceptedLedgerTx
 JSS(page_index);
@@ -616,6 +624,8 @@ JSS(TRANSACTION_RESULTS);     // out: RPC server_definitions
                               // matches definitions.json format
 JSS(TRANSACTION_TYPES);       // out: RPC server_definitions
                               // matches definitions.json format
+JSS(TRANSACTION_FLAGS);       // out: RPC server_definitions
+JSS(TRANSACTION_FORMATS);     // out: RPC server_definitions
 JSS(TYPES);                   // out: RPC server_definitions
                               // matches definitions.json format
 JSS(transfer_rate);           // out: nft_info (clio)
diff --git a/include/xrpl/tx/InvariantCheck.h b/include/xrpl/tx/InvariantCheck.h
deleted file mode 100644
index dc42f9d38c..0000000000
--- a/include/xrpl/tx/InvariantCheck.h
+++ /dev/null
@@ -1,732 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/protocol/MPTIssue.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-
-#include <cstdint>
-#include <tuple>
-#include <unordered_set>
-
-namespace xrpl {
-
-class ReadView;
-
-#if GENERATING_DOCS
-/**
- * @brief Prototype for invariant check implementations.
- *
- * __THIS CLASS DOES NOT EXIST__ - or rather it exists in documentation only to
- * communicate the interface required of any invariant checker. Any invariant
- * check implementation should implement the public methods documented here.
- *
- */
-class InvariantChecker_PROTOTYPE
-{
-public:
-    explicit InvariantChecker_PROTOTYPE() = default;
-
-    /**
-     * @brief called for each ledger entry in the current transaction.
-     *
-     * @param isDelete true if the SLE is being deleted
-     * @param before ledger entry before modification by the transaction
-     * @param after ledger entry after modification by the transaction
-     */
-    void
-    visitEntry(
-        bool isDelete,
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after);
-
-    /**
-     * @brief called after all ledger entries have been visited to determine
-     * the final status of the check
-     *
-     * @param tx the transaction being applied
-     * @param tec the current TER result of the transaction
-     * @param fee the fee actually charged for this transaction
-     * @param view a ReadView of the ledger being modified
-     * @param j journal for logging
-     *
-     * @return true if check passes, false if it fails
-     */
-    bool
-    finalize(
-        STTx const& tx,
-        TER const tec,
-        XRPAmount const fee,
-        ReadView const& view,
-        beast::Journal const& j);
-};
-#endif
-
-/**
- * @brief Invariant: We should never charge a transaction a negative fee or a
- * fee that is larger than what the transaction itself specifies.
- *
- * We can, in some circumstances, charge less.
- */
-class TransactionFeeCheck
-{
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: A transaction must not create XRP and should only destroy
- * the XRP fee.
- *
- * We iterate through all account roots, payment channels and escrow entries
- * that were modified and calculate the net change in XRP caused by the
- * transactions.
- */
-class XRPNotCreated
-{
-    std::int64_t drops_ = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: we cannot remove an account ledger entry
- *
- * We iterate all account roots that were modified, and ensure that any that
- * were present before the transaction was applied continue to be present
- * afterwards unless they were explicitly deleted by a successful
- * AccountDelete transaction.
- */
-class AccountRootsNotDeleted
-{
-    std::uint32_t accountsDeleted_ = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: a deleted account must not have any objects left
- *
- * We iterate all deleted account roots, and ensure that there are no
- * objects left that are directly accessible with that account's ID.
- *
- * There should only be one deleted account, but that's checked by
- * AccountRootsNotDeleted. This invariant will handle multiple deleted account
- * roots without a problem.
- */
-class AccountRootsDeletedClean
-{
-    // Pair is <before, after>. Before is used for most of the checks, so that
-    // if, for example, an object ID field is cleared, but the object is not
-    // deleted, it can still be found. After is used specifically for any checks
-    // that are expected as part of the deletion, such as zeroing out the
-    // balance.
-    std::vector<std::pair<std::shared_ptr<SLE const>, std::shared_ptr<SLE const>>> accountsDeleted_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: An account XRP balance must be in XRP and take a value
- *                   between 0 and INITIAL_XRP drops, inclusive.
- *
- * We iterate all account roots modified by the transaction and ensure that
- * their XRP balances are reasonable.
- */
-class XRPBalanceChecks
-{
-    bool bad_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: corresponding modified ledger entries should match in type
- *                   and added entries should be a valid type.
- */
-class LedgerEntryTypesMatch
-{
-    bool typeMismatch_ = false;
-    bool invalidTypeAdded_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: Trust lines using XRP are not allowed.
- *
- * We iterate all the trust lines created by this transaction and ensure
- * that they are against a valid issuer.
- */
-class NoXRPTrustLines
-{
-    bool xrpTrustLine_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: Trust lines with deep freeze flag are not allowed if normal
- * freeze flag is not set.
- *
- * We iterate all the trust lines created by this transaction and ensure
- * that they don't have deep freeze flag set without normal freeze flag set.
- */
-class NoDeepFreezeTrustLinesWithoutFreeze
-{
-    bool deepFreezeWithoutFreeze_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: frozen trust line balance change is not allowed.
- *
- * We iterate all affected trust lines and ensure that they don't have
- * unexpected change of balance if they're frozen.
- */
-class TransfersNotFrozen
-{
-    struct BalanceChange
-    {
-        std::shared_ptr<SLE const> const line;
-        int const balanceChangeSign;
-    };
-
-    struct IssuerChanges
-    {
-        std::vector<BalanceChange> senders;
-        std::vector<BalanceChange> receivers;
-    };
-
-    using ByIssuer = std::map<Issue, IssuerChanges>;
-    ByIssuer balanceChanges_;
-
-    std::map<AccountID, std::shared_ptr<SLE const> const> possibleIssuers_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-
-private:
-    bool
-    isValidEntry(std::shared_ptr<SLE const> const& before, std::shared_ptr<SLE const> const& after);
-
-    STAmount
-    calculateBalanceChange(
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after,
-        bool isDelete);
-
-    void
-    recordBalance(Issue const& issue, BalanceChange change);
-
-    void
-    recordBalanceChanges(std::shared_ptr<SLE const> const& after, STAmount const& balanceChange);
-
-    std::shared_ptr<SLE const>
-    findIssuer(AccountID const& issuerID, ReadView const& view);
-
-    bool
-    validateIssuerChanges(
-        std::shared_ptr<SLE const> const& issuer,
-        IssuerChanges const& changes,
-        STTx const& tx,
-        beast::Journal const& j,
-        bool enforce);
-
-    bool
-    validateFrozenState(
-        BalanceChange const& change,
-        bool high,
-        STTx const& tx,
-        beast::Journal const& j,
-        bool enforce,
-        bool globalFreeze);
-};
-
-/**
- * @brief Invariant: offers should be for non-negative amounts and must not
- *                   be XRP to XRP.
- *
- * Examine all offers modified by the transaction and ensure that there are
- * no offers which contain negative amounts or which exchange XRP for XRP.
- */
-class NoBadOffers
-{
-    bool bad_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: an escrow entry must take a value between 0 and
- *                   INITIAL_XRP drops exclusive.
- */
-class NoZeroEscrow
-{
-    bool bad_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: a new account root must be the consequence of a payment,
- *                   must have the right starting sequence, and the payment
- *                   may not create more than one new account root.
- */
-class ValidNewAccountRoot
-{
-    std::uint32_t accountsCreated_ = 0;
-    std::uint32_t accountSeq_ = 0;
-    bool pseudoAccount_ = false;
-    std::uint32_t flags_ = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: Validates several invariants for NFToken pages.
- *
- * The following checks are made:
- *  - The page is correctly associated with the owner.
- *  - The page is correctly ordered between the next and previous links.
- *  - The page contains at least one and no more than 32 NFTokens.
- *  - The NFTokens on this page do not belong on a lower or higher page.
- *  - The NFTokens are correctly sorted on the page.
- *  - Each URI, if present, is not empty.
- */
-class ValidNFTokenPage
-{
-    bool badEntry_ = false;
-    bool badLink_ = false;
-    bool badSort_ = false;
-    bool badURI_ = false;
-    bool invalidSize_ = false;
-    bool deletedFinalPage_ = false;
-    bool deletedLink_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: Validates counts of NFTokens after all transaction types.
- *
- * The following checks are made:
- *  - The number of minted or burned NFTokens can only be changed by
- *    NFTokenMint or NFTokenBurn transactions.
- *  - A successful NFTokenMint must increase the number of NFTokens.
- *  - A failed NFTokenMint must not change the number of minted NFTokens.
- *  - An NFTokenMint transaction cannot change the number of burned NFTokens.
- *  - A successful NFTokenBurn must increase the number of burned NFTokens.
- *  - A failed NFTokenBurn must not change the number of burned NFTokens.
- *  - An NFTokenBurn transaction cannot change the number of minted NFTokens.
- */
-class NFTokenCountTracking
-{
-    std::uint32_t beforeMintedTotal = 0;
-    std::uint32_t beforeBurnedTotal = 0;
-    std::uint32_t afterMintedTotal = 0;
-    std::uint32_t afterBurnedTotal = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariant: Token holder's trustline balance cannot be negative after
- * Clawback.
- *
- * We iterate all the trust lines affected by this transaction and ensure
- * that no more than one trustline is modified, and also holder's balance is
- * non-negative.
- */
-class ValidClawback
-{
-    std::uint32_t trustlinesChanged = 0;
-    std::uint32_t mptokensChanged = 0;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-class ValidMPTIssuance
-{
-    std::uint32_t mptIssuancesCreated_ = 0;
-    std::uint32_t mptIssuancesDeleted_ = 0;
-
-    std::uint32_t mptokensCreated_ = 0;
-    std::uint32_t mptokensDeleted_ = 0;
-    // non-MPT transactions may attempt to create
-    // MPToken by an issuer
-    bool mptCreatedByIssuer_ = false;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariants: Permissioned Domains must have some rules and
- * AcceptedCredentials must have length between 1 and 10 inclusive.
- *
- * Since only permissions constitute rules, an empty credentials list
- * means that there are no rules and the invariant is violated.
- *
- * Credentials must be sorted and no duplicates allowed
- *
- */
-class ValidPermissionedDomain
-{
-    struct SleStatus
-    {
-        std::size_t credentialsSize_{0};
-        bool isSorted_ = false;
-        bool isUnique_ = false;
-        bool isDelete_ = false;
-    };
-    std::vector<SleStatus> sleStatus_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariants: Pseudo-accounts have valid and consistent properties
- *
- * Pseudo-accounts have certain properties, and some of those properties are
- * unique to pseudo-accounts. Check that all pseudo-accounts are following the
- * rules, and that only pseudo-accounts look like pseudo-accounts.
- *
- */
-class ValidPseudoAccounts
-{
-    std::vector<std::string> errors_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-class ValidPermissionedDEX
-{
-    bool regularOffers_ = false;
-    bool badHybrids_ = false;
-    hash_set<uint256> domains_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-class ValidAMM
-{
-    std::optional<AccountID> ammAccount_;
-    std::optional<STAmount> lptAMMBalanceAfter_;
-    std::optional<STAmount> lptAMMBalanceBefore_;
-    bool ammPoolChanged_;
-
-public:
-    enum class ZeroAllowed : bool { No = false, Yes = true };
-
-    ValidAMM() : ammPoolChanged_{false}
-    {
-    }
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-
-private:
-    bool
-    finalizeBid(bool enforce, beast::Journal const&) const;
-    bool
-    finalizeVote(bool enforce, beast::Journal const&) const;
-    bool
-    finalizeCreate(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
-    bool
-    finalizeDelete(bool enforce, TER res, beast::Journal const&) const;
-    bool
-    finalizeDeposit(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
-    // Includes clawback
-    bool
-    finalizeWithdraw(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
-    bool
-    finalizeDEX(bool enforce, beast::Journal const&) const;
-    bool
-    generalInvariant(STTx const&, ReadView const&, ZeroAllowed zeroAllowed, beast::Journal const&)
-        const;
-};
-
-/**
- * @brief Invariants: Some fields are unmodifiable
- *
- * Check that any fields specified as unmodifiable are not modified when the
- * object is modified. Creation and deletion are ignored.
- *
- */
-class NoModifiedUnmodifiableFields
-{
-    // Pair is <before, after>.
-    std::set<std::pair<SLE::const_pointer, SLE::const_pointer>> changedEntries_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariants: Loan brokers are internally consistent
- *
- * 1. If `LoanBroker.OwnerCount = 0` the `DirectoryNode` will have at most one
- *    node (the root), which will only hold entries for `RippleState` or
- * `MPToken` objects.
- *
- */
-class ValidLoanBroker
-{
-    // Not all of these elements will necessarily be populated. Remaining items
-    // will be looked up as needed.
-    struct BrokerInfo
-    {
-        SLE::const_pointer brokerBefore = nullptr;
-        // After is used for most of the checks, except
-        // those that check changed values.
-        SLE::const_pointer brokerAfter = nullptr;
-    };
-    // Collect all the LoanBrokers found directly or indirectly through
-    // pseudo-accounts. Key is the brokerID / index. It will be used to find the
-    // LoanBroker object if brokerBefore and brokerAfter are nullptr
-    std::map<uint256, BrokerInfo> brokers_;
-    // Collect all the modified trust lines. Their high and low accounts will be
-    // loaded to look for LoanBroker pseudo-accounts.
-    std::vector<SLE::const_pointer> lines_;
-    // Collect all the modified MPTokens. Their accounts will be loaded to look
-    // for LoanBroker pseudo-accounts.
-    std::vector<SLE::const_pointer> mpts_;
-
-    bool
-    goodZeroDirectory(ReadView const& view, SLE::const_ref dir, beast::Journal const& j) const;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/**
- * @brief Invariants: Loans are internally consistent
- *
- * 1. If `Loan.PaymentRemaining = 0` then `Loan.PrincipalOutstanding = 0`
- *
- */
-class ValidLoan
-{
-    // Pair is <before, after>. After is used for most of the checks, except
-    // those that check changed values.
-    std::vector<std::pair<SLE::const_pointer, SLE::const_pointer>> loans_;
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-/*
- * @brief Invariants: Vault object and MPTokenIssuance for vault shares
- *
- * - vault deleted and vault created is empty
- * - vault created must be linked to pseudo-account for shares and assets
- * - vault must have MPTokenIssuance for shares
- * - vault without shares outstanding must have no shares
- * - loss unrealized does not exceed the difference between assets total and
- *   assets available
- * - assets available do not exceed assets total
- * - vault deposit increases assets and share issuance, and adds to:
- *   total assets, assets available, shares outstanding
- * - vault withdrawal and clawback reduce assets and share issuance, and
- *   subtracts from: total assets, assets available, shares outstanding
- * - vault set must not alter the vault assets or shares balance
- * - no vault transaction can change loss unrealized (it's updated by loan
- *   transactions)
- *
- */
-class ValidVault
-{
-    Number static constexpr zero{};
-
-    struct Vault final
-    {
-        uint256 key = beast::zero;
-        Asset asset = {};
-        AccountID pseudoId = {};
-        AccountID owner = {};
-        uint192 shareMPTID = beast::zero;
-        Number assetsTotal = 0;
-        Number assetsAvailable = 0;
-        Number assetsMaximum = 0;
-        Number lossUnrealized = 0;
-
-        Vault static make(SLE const&);
-    };
-
-    struct Shares final
-    {
-        MPTIssue share = {};
-        std::uint64_t sharesTotal = 0;
-        std::uint64_t sharesMaximum = 0;
-
-        Shares static make(SLE const&);
-    };
-
-    std::vector<Vault> afterVault_ = {};
-    std::vector<Shares> afterMPTs_ = {};
-    std::vector<Vault> beforeVault_ = {};
-    std::vector<Shares> beforeMPTs_ = {};
-    std::unordered_map<uint256, Number> deltas_ = {};
-
-public:
-    void
-    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-};
-
-// additional invariant checks can be declared above and then added to this
-// tuple
-using InvariantChecks = std::tuple<
-    TransactionFeeCheck,
-    AccountRootsNotDeleted,
-    AccountRootsDeletedClean,
-    LedgerEntryTypesMatch,
-    XRPBalanceChecks,
-    XRPNotCreated,
-    NoXRPTrustLines,
-    NoDeepFreezeTrustLinesWithoutFreeze,
-    TransfersNotFrozen,
-    NoBadOffers,
-    NoZeroEscrow,
-    ValidNewAccountRoot,
-    ValidNFTokenPage,
-    NFTokenCountTracking,
-    ValidClawback,
-    ValidMPTIssuance,
-    ValidPermissionedDomain,
-    ValidPermissionedDEX,
-    ValidAMM,
-    NoModifiedUnmodifiableFields,
-    ValidPseudoAccounts,
-    ValidLoanBroker,
-    ValidLoan,
-    ValidVault>;
-
-/**
- * @brief get a tuple of all invariant checks
- *
- * @return std::tuple of instances that implement the required invariant check
- * methods
- *
- * @see xrpl::InvariantChecker_PROTOTYPE
- */
-inline InvariantChecks
-getInvariantChecks()
-{
-    return InvariantChecks{};
-}
-
-}  // namespace xrpl
diff --git a/include/xrpl/tx/Transactor.h b/include/xrpl/tx/Transactor.h
index f1c335bc80..feb2da32bc 100644
--- a/include/xrpl/tx/Transactor.h
+++ b/include/xrpl/tx/Transactor.h
@@ -114,8 +114,7 @@ protected:
     beast::Journal const j_;
 
     AccountID const account_;
-    XRPAmount mPriorBalance;   // Balance before fees.
-    XRPAmount mSourceBalance;  // Balance after fees.
+    XRPAmount preFeeBalance_{};  // Balance before fees.
 
     virtual ~Transactor() = default;
     Transactor(Transactor const&) = delete;
diff --git a/include/xrpl/tx/invariants/AMMInvariant.h b/include/xrpl/tx/invariants/AMMInvariant.h
new file mode 100644
index 0000000000..63ebb804ae
--- /dev/null
+++ b/include/xrpl/tx/invariants/AMMInvariant.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <optional>
+
+namespace xrpl {
+
+class ValidAMM
+{
+    std::optional<AccountID> ammAccount_;
+    std::optional<STAmount> lptAMMBalanceAfter_;
+    std::optional<STAmount> lptAMMBalanceBefore_;
+    bool ammPoolChanged_;
+
+public:
+    enum class ZeroAllowed : bool { No = false, Yes = true };
+
+    ValidAMM() : ammPoolChanged_{false}
+    {
+    }
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+
+private:
+    bool
+    finalizeBid(bool enforce, beast::Journal const&) const;
+    bool
+    finalizeVote(bool enforce, beast::Journal const&) const;
+    bool
+    finalizeCreate(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
+    bool
+    finalizeDelete(bool enforce, TER res, beast::Journal const&) const;
+    bool
+    finalizeDeposit(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
+    // Includes clawback
+    bool
+    finalizeWithdraw(STTx const&, ReadView const&, bool enforce, beast::Journal const&) const;
+    bool
+    finalizeDEX(bool enforce, beast::Journal const&) const;
+    bool
+    generalInvariant(STTx const&, ReadView const&, ZeroAllowed zeroAllowed, beast::Journal const&)
+        const;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/FreezeInvariant.h b/include/xrpl/tx/invariants/FreezeInvariant.h
new file mode 100644
index 0000000000..ac9d83166e
--- /dev/null
+++ b/include/xrpl/tx/invariants/FreezeInvariant.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <map>
+#include <vector>
+
+namespace xrpl {
+
+/**
+ * @brief Invariant: frozen trust line balance change is not allowed.
+ *
+ * We iterate all affected trust lines and ensure that they don't have
+ * unexpected change of balance if they're frozen.
+ */
+class TransfersNotFrozen
+{
+    struct BalanceChange
+    {
+        std::shared_ptr<SLE const> const line;
+        int const balanceChangeSign;
+    };
+
+    struct IssuerChanges
+    {
+        std::vector<BalanceChange> senders;
+        std::vector<BalanceChange> receivers;
+    };
+
+    using ByIssuer = std::map<Issue, IssuerChanges>;
+    ByIssuer balanceChanges_;
+
+    std::map<AccountID, std::shared_ptr<SLE const> const> possibleIssuers_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+
+private:
+    bool
+    isValidEntry(std::shared_ptr<SLE const> const& before, std::shared_ptr<SLE const> const& after);
+
+    STAmount
+    calculateBalanceChange(
+        std::shared_ptr<SLE const> const& before,
+        std::shared_ptr<SLE const> const& after,
+        bool isDelete);
+
+    void
+    recordBalance(Issue const& issue, BalanceChange change);
+
+    void
+    recordBalanceChanges(std::shared_ptr<SLE const> const& after, STAmount const& balanceChange);
+
+    std::shared_ptr<SLE const>
+    findIssuer(AccountID const& issuerID, ReadView const& view);
+
+    bool
+    validateIssuerChanges(
+        std::shared_ptr<SLE const> const& issuer,
+        IssuerChanges const& changes,
+        STTx const& tx,
+        beast::Journal const& j,
+        bool enforce);
+
+    bool
+    validateFrozenState(
+        BalanceChange const& change,
+        bool high,
+        STTx const& tx,
+        beast::Journal const& j,
+        bool enforce,
+        bool globalFreeze);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/InvariantCheck.h b/include/xrpl/tx/invariants/InvariantCheck.h
new file mode 100644
index 0000000000..64eff33ff7
--- /dev/null
+++ b/include/xrpl/tx/invariants/InvariantCheck.h
@@ -0,0 +1,416 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/invariants/AMMInvariant.h>
+#include <xrpl/tx/invariants/FreezeInvariant.h>
+#include <xrpl/tx/invariants/LoanInvariant.h>
+#include <xrpl/tx/invariants/MPTInvariant.h>
+#include <xrpl/tx/invariants/NFTInvariant.h>
+#include <xrpl/tx/invariants/PermissionedDEXInvariant.h>
+#include <xrpl/tx/invariants/PermissionedDomainInvariant.h>
+#include <xrpl/tx/invariants/VaultInvariant.h>
+
+#include <cstdint>
+#include <tuple>
+
+namespace xrpl {
+
+#if GENERATING_DOCS
+/**
+ * @brief Prototype for invariant check implementations.
+ *
+ * __THIS CLASS DOES NOT EXIST__ - or rather it exists in documentation only to
+ * communicate the interface required of any invariant checker. Any invariant
+ * check implementation should implement the public methods documented here.
+ *
+ * ## Rules for implementing `finalize`
+ *
+ * ### Invariants must run regardless of transaction result
+ *
+ * An invariant's `finalize` method MUST perform meaningful checks even when
+ * the transaction has failed (i.e., `!isTesSuccess(tec)`). The following
+ * pattern is almost certainly wrong and must never be used:
+ *
+ * @code
+ * // WRONG: skipping all checks on failure defeats the purpose of invariants
+ * if (!isTesSuccess(tec))
+ *     return true;
+ * @endcode
+ *
+ * The entire purpose of invariants is to detect and prevent the impossible.
+ * A bug or exploit could cause a failed transaction to mutate ledger state in
+ * unexpected ways. Invariants are the last line of defense against such
+ * scenarios.
+ *
+ * In general: an invariant that expects a domain-specific state change to
+ * occur (e.g., a new object being created) should only expect that change
+ * when the transaction succeeded. A failed VaultCreate must not have created
+ * a Vault. A failed LoanSet must not have created a Loan.
+ *
+ * Also be aware that failed transactions, regardless of type, carry no
+ * Privileges. Any privilege-gated checks must therefore also be applied to
+ * failed transactions.
+ */
+class InvariantChecker_PROTOTYPE
+{
+public:
+    explicit InvariantChecker_PROTOTYPE() = default;
+
+    /**
+     * @brief called for each ledger entry in the current transaction.
+     *
+     * @param isDelete true if the SLE is being deleted
+     * @param before ledger entry before modification by the transaction
+     * @param after ledger entry after modification by the transaction
+     */
+    void
+    visitEntry(
+        bool isDelete,
+        std::shared_ptr<SLE const> const& before,
+        std::shared_ptr<SLE const> const& after);
+
+    /**
+     * @brief called after all ledger entries have been visited to determine
+     * the final status of the check.
+     *
+     * This method MUST perform meaningful checks even when `tec` indicates a
+     * failed transaction. See the class-level documentation for the rules
+     * governing how failed transactions must be handled.
+     *
+     * @param tx the transaction being applied
+     * @param tec the current TER result of the transaction
+     * @param fee the fee actually charged for this transaction
+     * @param view a ReadView of the ledger being modified
+     * @param j journal for logging
+     *
+     * @return true if check passes, false if it fails
+     */
+    bool
+    finalize(
+        STTx const& tx,
+        TER const tec,
+        XRPAmount const fee,
+        ReadView const& view,
+        beast::Journal const& j);
+};
+#endif
+
+/**
+ * @brief Invariant: We should never charge a transaction a negative fee or a
+ * fee that is larger than what the transaction itself specifies.
+ *
+ * We can, in some circumstances, charge less.
+ */
+class TransactionFeeCheck
+{
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: A transaction must not create XRP and should only destroy
+ * the XRP fee.
+ *
+ * We iterate through all account roots, payment channels and escrow entries
+ * that were modified and calculate the net change in XRP caused by the
+ * transactions.
+ */
+class XRPNotCreated
+{
+    std::int64_t drops_ = 0;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: we cannot remove an account ledger entry
+ *
+ * We iterate all account roots that were modified, and ensure that any that
+ * were present before the transaction was applied continue to be present
+ * afterwards unless they were explicitly deleted by a successful
+ * AccountDelete transaction.
+ */
+class AccountRootsNotDeleted
+{
+    std::uint32_t accountsDeleted_ = 0;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: a deleted account must not have any objects left
+ *
+ * We iterate all deleted account roots, and ensure that there are no
+ * objects left that are directly accessible with that account's ID.
+ *
+ * There should only be one deleted account, but that's checked by
+ * AccountRootsNotDeleted. This invariant will handle multiple deleted account
+ * roots without a problem.
+ */
+class AccountRootsDeletedClean
+{
+    // Pair is <before, after>. Before is used for most of the checks, so that
+    // if, for example, an object ID field is cleared, but the object is not
+    // deleted, it can still be found. After is used specifically for any checks
+    // that are expected as part of the deletion, such as zeroing out the
+    // balance.
+    std::vector<std::pair<std::shared_ptr<SLE const>, std::shared_ptr<SLE const>>> accountsDeleted_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: An account XRP balance must be in XRP and take a value
+ *                   between 0 and INITIAL_XRP drops, inclusive.
+ *
+ * We iterate all account roots modified by the transaction and ensure that
+ * their XRP balances are reasonable.
+ */
+class XRPBalanceChecks
+{
+    bool bad_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: corresponding modified ledger entries should match in type
+ *                   and added entries should be a valid type.
+ */
+class LedgerEntryTypesMatch
+{
+    bool typeMismatch_ = false;
+    bool invalidTypeAdded_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: Trust lines using XRP are not allowed.
+ *
+ * We iterate all the trust lines created by this transaction and ensure
+ * that they are against a valid issuer.
+ */
+class NoXRPTrustLines
+{
+    bool xrpTrustLine_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: Trust lines with deep freeze flag are not allowed if normal
+ * freeze flag is not set.
+ *
+ * We iterate all the trust lines created by this transaction and ensure
+ * that they don't have deep freeze flag set without normal freeze flag set.
+ */
+class NoDeepFreezeTrustLinesWithoutFreeze
+{
+    bool deepFreezeWithoutFreeze_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: offers should be for non-negative amounts and must not
+ *                   be XRP to XRP.
+ *
+ * Examine all offers modified by the transaction and ensure that there are
+ * no offers which contain negative amounts or which exchange XRP for XRP.
+ */
+class NoBadOffers
+{
+    bool bad_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: an escrow entry must take a value between 0 and
+ *                   INITIAL_XRP drops exclusive.
+ */
+class NoZeroEscrow
+{
+    bool bad_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: a new account root must be the consequence of a payment,
+ *                   must have the right starting sequence, and the payment
+ *                   may not create more than one new account root.
+ */
+class ValidNewAccountRoot
+{
+    std::uint32_t accountsCreated_ = 0;
+    std::uint32_t accountSeq_ = 0;
+    bool pseudoAccount_ = false;
+    std::uint32_t flags_ = 0;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: Token holder's trustline balance cannot be negative after
+ * Clawback.
+ *
+ * We iterate all the trust lines affected by this transaction and ensure
+ * that no more than one trustline is modified, and also holder's balance is
+ * non-negative.
+ */
+class ValidClawback
+{
+    std::uint32_t trustlinesChanged = 0;
+    std::uint32_t mptokensChanged = 0;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariants: Pseudo-accounts have valid and consistent properties
+ *
+ * Pseudo-accounts have certain properties, and some of those properties are
+ * unique to pseudo-accounts. Check that all pseudo-accounts are following the
+ * rules, and that only pseudo-accounts look like pseudo-accounts.
+ *
+ */
+class ValidPseudoAccounts
+{
+    std::vector<std::string> errors_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariants: Some fields are unmodifiable
+ *
+ * Check that any fields specified as unmodifiable are not modified when the
+ * object is modified. Creation and deletion are ignored.
+ *
+ */
+class NoModifiedUnmodifiableFields
+{
+    // Pair is <before, after>.
+    std::set<std::pair<SLE::const_pointer, SLE::const_pointer>> changedEntries_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+// additional invariant checks can be declared above and then added to this
+// tuple
+using InvariantChecks = std::tuple<
+    TransactionFeeCheck,
+    AccountRootsNotDeleted,
+    AccountRootsDeletedClean,
+    LedgerEntryTypesMatch,
+    XRPBalanceChecks,
+    XRPNotCreated,
+    NoXRPTrustLines,
+    NoDeepFreezeTrustLinesWithoutFreeze,
+    TransfersNotFrozen,
+    NoBadOffers,
+    NoZeroEscrow,
+    ValidNewAccountRoot,
+    ValidNFTokenPage,
+    NFTokenCountTracking,
+    ValidClawback,
+    ValidMPTIssuance,
+    ValidPermissionedDomain,
+    ValidPermissionedDEX,
+    ValidAMM,
+    NoModifiedUnmodifiableFields,
+    ValidPseudoAccounts,
+    ValidLoanBroker,
+    ValidLoan,
+    ValidVault>;
+
+/**
+ * @brief get a tuple of all invariant checks
+ *
+ * @return std::tuple of instances that implement the required invariant check
+ * methods
+ *
+ * @see xrpl::InvariantChecker_PROTOTYPE
+ */
+inline InvariantChecks
+getInvariantChecks()
+{
+    return InvariantChecks{};
+}
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
new file mode 100644
index 0000000000..161b3572db
--- /dev/null
+++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+
+#include <type_traits>
+
+namespace xrpl {
+
+/*
+assert(enforce)
+
+There are several asserts (or XRPL_ASSERTs) in invariant check files that check
+a variable named `enforce` when an invariant fails. At first glance, those
+asserts may look incorrect, but they are not.
+
+Those asserts take advantage of two facts:
+1. `asserts` are not (normally) executed in release builds.
+2. Invariants should *never* fail, except in tests that specifically modify
+   the open ledger to break them.
+
+This makes `assert(enforce)` sort of a second-layer of invariant enforcement
+aimed at _developers_. It's designed to fire if a developer writes code that
+violates an invariant, and runs it in unit tests or a develop build that _does
+not have the relevant amendments enabled_. It's intentionally a pain in the neck
+so that bad code gets caught and fixed as early as possible.
+*/
+
+enum Privilege {
+    noPriv = 0x0000,              // The transaction can not do any of the enumerated operations
+    createAcct = 0x0001,          // The transaction can create a new ACCOUNT_ROOT object.
+    createPseudoAcct = 0x0002,    // The transaction can create a pseudo account,
+                                  // which implies createAcct
+    mustDeleteAcct = 0x0004,      // The transaction must delete an ACCOUNT_ROOT object
+    mayDeleteAcct = 0x0008,       // The transaction may delete an ACCOUNT_ROOT
+                                  // object, but does not have to
+    overrideFreeze = 0x0010,      // The transaction can override some freeze rules
+    changeNFTCounts = 0x0020,     // The transaction can mint or burn an NFT
+    createMPTIssuance = 0x0040,   // The transaction can create a new MPT issuance
+    destroyMPTIssuance = 0x0080,  // The transaction can destroy an MPT issuance
+    mustAuthorizeMPT = 0x0100,    // The transaction MUST create or delete an MPT
+                                  // object (except by issuer)
+    mayAuthorizeMPT = 0x0200,     // The transaction MAY create or delete an MPT
+                                  // object (except by issuer)
+    mayDeleteMPT = 0x0400,        // The transaction MAY delete an MPT object. May not create.
+    mustModifyVault = 0x0800,     // The transaction must modify, delete or create, a vault
+    mayModifyVault = 0x1000,      // The transaction MAY modify, delete or create, a vault
+};
+
+constexpr Privilege
+operator|(Privilege lhs, Privilege rhs)
+{
+    return safe_cast<Privilege>(
+        safe_cast<std::underlying_type_t<Privilege>>(lhs) |
+        safe_cast<std::underlying_type_t<Privilege>>(rhs));
+}
+
+bool
+hasPrivilege(STTx const& tx, Privilege priv);
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/LoanInvariant.h b/include/xrpl/tx/invariants/LoanInvariant.h
new file mode 100644
index 0000000000..be771cd582
--- /dev/null
+++ b/include/xrpl/tx/invariants/LoanInvariant.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <map>
+#include <vector>
+
+namespace xrpl {
+
+/**
+ * @brief Invariants: Loan brokers are internally consistent
+ *
+ * 1. If `LoanBroker.OwnerCount = 0` the `DirectoryNode` will have at most one
+ *    node (the root), which will only hold entries for `RippleState` or
+ * `MPToken` objects.
+ *
+ */
+class ValidLoanBroker
+{
+    // Not all of these elements will necessarily be populated. Remaining items
+    // will be looked up as needed.
+    struct BrokerInfo
+    {
+        SLE::const_pointer brokerBefore = nullptr;
+        // After is used for most of the checks, except
+        // those that check changed values.
+        SLE::const_pointer brokerAfter = nullptr;
+    };
+    // Collect all the LoanBrokers found directly or indirectly through
+    // pseudo-accounts. Key is the brokerID / index. It will be used to find the
+    // LoanBroker object if brokerBefore and brokerAfter are nullptr
+    std::map<uint256, BrokerInfo> brokers_;
+    // Collect all the modified trust lines. Their high and low accounts will be
+    // loaded to look for LoanBroker pseudo-accounts.
+    std::vector<SLE::const_pointer> lines_;
+    // Collect all the modified MPTokens. Their accounts will be loaded to look
+    // for LoanBroker pseudo-accounts.
+    std::vector<SLE::const_pointer> mpts_;
+
+    bool
+    goodZeroDirectory(ReadView const& view, SLE::const_ref dir, beast::Journal const& j) const;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariants: Loans are internally consistent
+ *
+ * 1. If `Loan.PaymentRemaining = 0` then `Loan.PrincipalOutstanding = 0`
+ *
+ */
+class ValidLoan
+{
+    // Pair is <before, after>. After is used for most of the checks, except
+    // those that check changed values.
+    std::vector<std::pair<SLE::const_pointer, SLE::const_pointer>> loans_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/MPTInvariant.h b/include/xrpl/tx/invariants/MPTInvariant.h
new file mode 100644
index 0000000000..b6533c263d
--- /dev/null
+++ b/include/xrpl/tx/invariants/MPTInvariant.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+class ValidMPTIssuance
+{
+    std::uint32_t mptIssuancesCreated_ = 0;
+    std::uint32_t mptIssuancesDeleted_ = 0;
+
+    std::uint32_t mptokensCreated_ = 0;
+    std::uint32_t mptokensDeleted_ = 0;
+    // non-MPT transactions may attempt to create
+    // MPToken by an issuer
+    bool mptCreatedByIssuer_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/NFTInvariant.h b/include/xrpl/tx/invariants/NFTInvariant.h
new file mode 100644
index 0000000000..8a88ca1c63
--- /dev/null
+++ b/include/xrpl/tx/invariants/NFTInvariant.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+/**
+ * @brief Invariant: Validates several invariants for NFToken pages.
+ *
+ * The following checks are made:
+ *  - The page is correctly associated with the owner.
+ *  - The page is correctly ordered between the next and previous links.
+ *  - The page contains at least one and no more than 32 NFTokens.
+ *  - The NFTokens on this page do not belong on a lower or higher page.
+ *  - The NFTokens are correctly sorted on the page.
+ *  - Each URI, if present, is not empty.
+ */
+class ValidNFTokenPage
+{
+    bool badEntry_ = false;
+    bool badLink_ = false;
+    bool badSort_ = false;
+    bool badURI_ = false;
+    bool invalidSize_ = false;
+    bool deletedFinalPage_ = false;
+    bool deletedLink_ = false;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+/**
+ * @brief Invariant: Validates counts of NFTokens after all transaction types.
+ *
+ * The following checks are made:
+ *  - The number of minted or burned NFTokens can only be changed by
+ *    NFTokenMint or NFTokenBurn transactions.
+ *  - A successful NFTokenMint must increase the number of NFTokens.
+ *  - A failed NFTokenMint must not change the number of minted NFTokens.
+ *  - An NFTokenMint transaction cannot change the number of burned NFTokens.
+ *  - A successful NFTokenBurn must increase the number of burned NFTokens.
+ *  - A failed NFTokenBurn must not change the number of burned NFTokens.
+ *  - An NFTokenBurn transaction cannot change the number of minted NFTokens.
+ */
+class NFTokenCountTracking
+{
+    std::uint32_t beforeMintedTotal = 0;
+    std::uint32_t beforeBurnedTotal = 0;
+    std::uint32_t afterMintedTotal = 0;
+    std::uint32_t afterBurnedTotal = 0;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h
new file mode 100644
index 0000000000..b4e06cd212
--- /dev/null
+++ b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+namespace xrpl {
+
+class ValidPermissionedDEX
+{
+    bool regularOffers_ = false;
+    bool badHybrids_ = false;
+    hash_set<uint256> domains_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/PermissionedDomainInvariant.h b/include/xrpl/tx/invariants/PermissionedDomainInvariant.h
new file mode 100644
index 0000000000..f6c902ecb2
--- /dev/null
+++ b/include/xrpl/tx/invariants/PermissionedDomainInvariant.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <vector>
+
+namespace xrpl {
+
+/**
+ * @brief Invariants: Permissioned Domains must have some rules and
+ * AcceptedCredentials must have length between 1 and 10 inclusive.
+ *
+ * Since only permissions constitute rules, an empty credentials list
+ * means that there are no rules and the invariant is violated.
+ *
+ * Credentials must be sorted and no duplicates allowed
+ *
+ */
+class ValidPermissionedDomain
+{
+    struct SleStatus
+    {
+        std::size_t credentialsSize_{0};
+        bool isSorted_ = false;
+        bool isUnique_ = false;
+        bool isDelete_ = false;
+    };
+    std::vector<SleStatus> sleStatus_;
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/invariants/VaultInvariant.h b/include/xrpl/tx/invariants/VaultInvariant.h
new file mode 100644
index 0000000000..ded9e4618b
--- /dev/null
+++ b/include/xrpl/tx/invariants/VaultInvariant.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <xrpl/basics/Number.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+
+#include <unordered_map>
+#include <vector>
+
+namespace xrpl {
+
+/*
+ * @brief Invariants: Vault object and MPTokenIssuance for vault shares
+ *
+ * - vault deleted and vault created is empty
+ * - vault created must be linked to pseudo-account for shares and assets
+ * - vault must have MPTokenIssuance for shares
+ * - vault without shares outstanding must have no shares
+ * - loss unrealized does not exceed the difference between assets total and
+ *   assets available
+ * - assets available do not exceed assets total
+ * - vault deposit increases assets and share issuance, and adds to:
+ *   total assets, assets available, shares outstanding
+ * - vault withdrawal and clawback reduce assets and share issuance, and
+ *   subtracts from: total assets, assets available, shares outstanding
+ * - vault set must not alter the vault assets or shares balance
+ * - no vault transaction can change loss unrealized (it's updated by loan
+ *   transactions)
+ *
+ */
+class ValidVault
+{
+    Number static constexpr zero{};
+
+    struct Vault final
+    {
+        uint256 key = beast::zero;
+        Asset asset = {};
+        AccountID pseudoId = {};
+        AccountID owner = {};
+        uint192 shareMPTID = beast::zero;
+        Number assetsTotal = 0;
+        Number assetsAvailable = 0;
+        Number assetsMaximum = 0;
+        Number lossUnrealized = 0;
+
+        Vault static make(SLE const&);
+    };
+
+    struct Shares final
+    {
+        MPTIssue share = {};
+        std::uint64_t sharesTotal = 0;
+        std::uint64_t sharesMaximum = 0;
+
+        Shares static make(SLE const&);
+    };
+
+    std::vector<Vault> afterVault_ = {};
+    std::vector<Shares> afterMPTs_ = {};
+    std::vector<Vault> beforeVault_ = {};
+    std::vector<Shares> beforeMPTs_ = {};
+    std::unordered_map<uint256, Number> deltas_ = {};
+
+public:
+    void
+    visitEntry(bool, std::shared_ptr<SLE const> const&, std::shared_ptr<SLE const> const&);
+
+    bool
+    finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/paths/BookTip.h b/include/xrpl/tx/paths/BookTip.h
index 69d3ec70d8..98036a86eb 100644
--- a/include/xrpl/tx/paths/BookTip.h
+++ b/include/xrpl/tx/paths/BookTip.h
@@ -22,7 +22,7 @@ private:
     uint256 m_dir;
     uint256 m_index;
     std::shared_ptr<SLE> m_entry;
-    Quality m_quality;
+    Quality m_quality{};
 
 public:
     /** Create the iterator. */
diff --git a/include/xrpl/tx/paths/detail/StrandFlow.h b/include/xrpl/tx/paths/detail/StrandFlow.h
index 929aca0663..67e333f2e6 100644
--- a/include/xrpl/tx/paths/detail/StrandFlow.h
+++ b/include/xrpl/tx/paths/detail/StrandFlow.h
@@ -10,8 +10,8 @@
 #include <xrpl/tx/paths/detail/FlatSets.h>
 #include <xrpl/tx/paths/detail/FlowDebugInfo.h>
 #include <xrpl/tx/paths/detail/Steps.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
 
 #include <boost/container/flat_set.hpp>
 
diff --git a/include/xrpl/tx/transactors/Credentials.h b/include/xrpl/tx/transactors/Credentials.h
deleted file mode 100644
index 8c96f40526..0000000000
--- a/include/xrpl/tx/transactors/Credentials.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class CredentialCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-//------------------------------------------------------------------------------
-
-class CredentialDelete : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-//------------------------------------------------------------------------------
-
-class CredentialAccept : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/Escrow.h b/include/xrpl/tx/transactors/Escrow.h
deleted file mode 100644
index 0fd627e5a9..0000000000
--- a/include/xrpl/tx/transactors/Escrow.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class EscrowCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-//------------------------------------------------------------------------------
-
-class EscrowFinish : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static bool
-    checkExtraFeatures(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static NotTEC
-    preflightSigValidated(PreflightContext const& ctx);
-
-    static XRPAmount
-    calculateBaseFee(ReadView const& view, STTx const& tx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-//------------------------------------------------------------------------------
-
-class EscrowCancel : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/PayChan.h b/include/xrpl/tx/transactors/PayChan.h
deleted file mode 100644
index cc23f029f2..0000000000
--- a/include/xrpl/tx/transactors/PayChan.h
+++ /dev/null
@@ -1,83 +0,0 @@
-#pragma once
-
-#include <xrpl/tx/Transactor.h>
-
-namespace xrpl {
-
-class PayChanCreate : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit PayChanCreate(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelCreate = PayChanCreate;
-
-//------------------------------------------------------------------------------
-
-class PayChanFund : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
-
-    explicit PayChanFund(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelFund = PayChanFund;
-
-//------------------------------------------------------------------------------
-
-class PayChanClaim : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit PayChanClaim(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static bool
-    checkExtraFeatures(PreflightContext const& ctx);
-
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-using PaymentChannelClaim = PayChanClaim;
-
-}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/DeleteAccount.h b/include/xrpl/tx/transactors/account/DeleteAccount.h
similarity index 100%
rename from include/xrpl/tx/transactors/DeleteAccount.h
rename to include/xrpl/tx/transactors/account/DeleteAccount.h
diff --git a/include/xrpl/tx/transactors/SetAccount.h b/include/xrpl/tx/transactors/account/SetAccount.h
similarity index 100%
rename from include/xrpl/tx/transactors/SetAccount.h
rename to include/xrpl/tx/transactors/account/SetAccount.h
diff --git a/include/xrpl/tx/transactors/SetRegularKey.h b/include/xrpl/tx/transactors/account/SetRegularKey.h
similarity index 100%
rename from include/xrpl/tx/transactors/SetRegularKey.h
rename to include/xrpl/tx/transactors/account/SetRegularKey.h
diff --git a/include/xrpl/tx/transactors/SetSignerList.h b/include/xrpl/tx/transactors/account/SetSignerList.h
similarity index 100%
rename from include/xrpl/tx/transactors/SetSignerList.h
rename to include/xrpl/tx/transactors/account/SetSignerList.h
diff --git a/include/xrpl/tx/transactors/XChainBridge.h b/include/xrpl/tx/transactors/bridge/XChainBridge.h
similarity index 100%
rename from include/xrpl/tx/transactors/XChainBridge.h
rename to include/xrpl/tx/transactors/bridge/XChainBridge.h
diff --git a/include/xrpl/tx/transactors/Check/CancelCheck.h b/include/xrpl/tx/transactors/check/CancelCheck.h
similarity index 100%
rename from include/xrpl/tx/transactors/Check/CancelCheck.h
rename to include/xrpl/tx/transactors/check/CancelCheck.h
diff --git a/include/xrpl/tx/transactors/Check/CashCheck.h b/include/xrpl/tx/transactors/check/CashCheck.h
similarity index 100%
rename from include/xrpl/tx/transactors/Check/CashCheck.h
rename to include/xrpl/tx/transactors/check/CashCheck.h
diff --git a/include/xrpl/tx/transactors/Check/CreateCheck.h b/include/xrpl/tx/transactors/check/CreateCheck.h
similarity index 100%
rename from include/xrpl/tx/transactors/Check/CreateCheck.h
rename to include/xrpl/tx/transactors/check/CreateCheck.h
diff --git a/include/xrpl/tx/transactors/credentials/CredentialAccept.h b/include/xrpl/tx/transactors/credentials/CredentialAccept.h
new file mode 100644
index 0000000000..1895e54589
--- /dev/null
+++ b/include/xrpl/tx/transactors/credentials/CredentialAccept.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class CredentialAccept : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/credentials/CredentialCreate.h b/include/xrpl/tx/transactors/credentials/CredentialCreate.h
new file mode 100644
index 0000000000..500b034a9c
--- /dev/null
+++ b/include/xrpl/tx/transactors/credentials/CredentialCreate.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class CredentialCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/credentials/CredentialDelete.h b/include/xrpl/tx/transactors/credentials/CredentialDelete.h
new file mode 100644
index 0000000000..26305232ce
--- /dev/null
+++ b/include/xrpl/tx/transactors/credentials/CredentialDelete.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class CredentialDelete : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/Delegate/DelegateSet.h b/include/xrpl/tx/transactors/delegate/DelegateSet.h
similarity index 100%
rename from include/xrpl/tx/transactors/Delegate/DelegateSet.h
rename to include/xrpl/tx/transactors/delegate/DelegateSet.h
diff --git a/include/xrpl/tx/transactors/Delegate/DelegateUtils.h b/include/xrpl/tx/transactors/delegate/DelegateUtils.h
similarity index 100%
rename from include/xrpl/tx/transactors/Delegate/DelegateUtils.h
rename to include/xrpl/tx/transactors/delegate/DelegateUtils.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMBid.h b/include/xrpl/tx/transactors/dex/AMMBid.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMBid.h
rename to include/xrpl/tx/transactors/dex/AMMBid.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMClawback.h b/include/xrpl/tx/transactors/dex/AMMClawback.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMClawback.h
rename to include/xrpl/tx/transactors/dex/AMMClawback.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMContext.h b/include/xrpl/tx/transactors/dex/AMMContext.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMContext.h
rename to include/xrpl/tx/transactors/dex/AMMContext.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMCreate.h b/include/xrpl/tx/transactors/dex/AMMCreate.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMCreate.h
rename to include/xrpl/tx/transactors/dex/AMMCreate.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMDelete.h b/include/xrpl/tx/transactors/dex/AMMDelete.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMDelete.h
rename to include/xrpl/tx/transactors/dex/AMMDelete.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMDeposit.h b/include/xrpl/tx/transactors/dex/AMMDeposit.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMDeposit.h
rename to include/xrpl/tx/transactors/dex/AMMDeposit.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMHelpers.h b/include/xrpl/tx/transactors/dex/AMMHelpers.h
similarity index 99%
rename from include/xrpl/tx/transactors/AMM/AMMHelpers.h
rename to include/xrpl/tx/transactors/dex/AMMHelpers.h
index 1db9176538..e2735ea80f 100644
--- a/include/xrpl/tx/transactors/AMM/AMMHelpers.h
+++ b/include/xrpl/tx/transactors/dex/AMMHelpers.h
@@ -370,7 +370,7 @@ changeSpotPriceQuality(
     if (!amounts)
     {
         JLOG(j.trace()) << "changeSpotPrice calc failed: " << to_string(pool.in) << " "
-                        << to_string(pool.out) << " " << quality << " " << tfee << std::endl;
+                        << to_string(pool.out) << " " << quality << " " << tfee;
         return std::nullopt;
     }
 
@@ -639,9 +639,9 @@ getRoundedAsset(Rules const& rules, STAmount const& balance, A const& frac, IsDe
 STAmount
 getRoundedAsset(
     Rules const& rules,
-    std::function<Number()>&& noRoundCb,
+    std::function<Number()> const& noRoundCb,
     STAmount const& balance,
-    std::function<Number()>&& productCb,
+    std::function<Number()> const& productCb,
     IsDeposit isDeposit);
 
 /** Round AMM deposit/withdrawal LPToken amount. Deposit/withdrawal formulas
@@ -672,9 +672,9 @@ getRoundedLPTokens(
 STAmount
 getRoundedLPTokens(
     Rules const& rules,
-    std::function<Number()>&& noRoundCb,
+    std::function<Number()> const& noRoundCb,
     STAmount const& lptAMMBalance,
-    std::function<Number()>&& productCb,
+    std::function<Number()> const& productCb,
     IsDeposit isDeposit);
 
 /* Next two functions adjust asset in/out amount to factor in the adjusted
diff --git a/include/xrpl/tx/transactors/AMM/AMMUtils.h b/include/xrpl/tx/transactors/dex/AMMUtils.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMUtils.h
rename to include/xrpl/tx/transactors/dex/AMMUtils.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMVote.h b/include/xrpl/tx/transactors/dex/AMMVote.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMVote.h
rename to include/xrpl/tx/transactors/dex/AMMVote.h
diff --git a/include/xrpl/tx/transactors/AMM/AMMWithdraw.h b/include/xrpl/tx/transactors/dex/AMMWithdraw.h
similarity index 100%
rename from include/xrpl/tx/transactors/AMM/AMMWithdraw.h
rename to include/xrpl/tx/transactors/dex/AMMWithdraw.h
diff --git a/include/xrpl/tx/transactors/Offer/CancelOffer.h b/include/xrpl/tx/transactors/dex/CancelOffer.h
similarity index 100%
rename from include/xrpl/tx/transactors/Offer/CancelOffer.h
rename to include/xrpl/tx/transactors/dex/CancelOffer.h
diff --git a/include/xrpl/tx/transactors/Offer/CreateOffer.h b/include/xrpl/tx/transactors/dex/CreateOffer.h
similarity index 100%
rename from include/xrpl/tx/transactors/Offer/CreateOffer.h
rename to include/xrpl/tx/transactors/dex/CreateOffer.h
diff --git a/include/xrpl/tx/transactors/PermissionedDEXHelpers.h b/include/xrpl/tx/transactors/dex/PermissionedDEXHelpers.h
similarity index 100%
rename from include/xrpl/tx/transactors/PermissionedDEXHelpers.h
rename to include/xrpl/tx/transactors/dex/PermissionedDEXHelpers.h
diff --git a/include/xrpl/tx/transactors/DID.h b/include/xrpl/tx/transactors/did/DIDDelete.h
similarity index 61%
rename from include/xrpl/tx/transactors/DID.h
rename to include/xrpl/tx/transactors/did/DIDDelete.h
index 8ab80bc694..037a57bb02 100644
--- a/include/xrpl/tx/transactors/DID.h
+++ b/include/xrpl/tx/transactors/did/DIDDelete.h
@@ -4,24 +4,6 @@
 
 namespace xrpl {
 
-class DIDSet : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-//------------------------------------------------------------------------------
-
 class DIDDelete : public Transactor
 {
 public:
diff --git a/include/xrpl/tx/transactors/did/DIDSet.h b/include/xrpl/tx/transactors/did/DIDSet.h
new file mode 100644
index 0000000000..fe1c476b47
--- /dev/null
+++ b/include/xrpl/tx/transactors/did/DIDSet.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class DIDSet : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/escrow/EscrowCancel.h b/include/xrpl/tx/transactors/escrow/EscrowCancel.h
new file mode 100644
index 0000000000..c8b97203f0
--- /dev/null
+++ b/include/xrpl/tx/transactors/escrow/EscrowCancel.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class EscrowCancel : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/escrow/EscrowCreate.h b/include/xrpl/tx/transactors/escrow/EscrowCreate.h
new file mode 100644
index 0000000000..221ffee070
--- /dev/null
+++ b/include/xrpl/tx/transactors/escrow/EscrowCreate.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class EscrowCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/escrow/EscrowFinish.h b/include/xrpl/tx/transactors/escrow/EscrowFinish.h
new file mode 100644
index 0000000000..0917c35d93
--- /dev/null
+++ b/include/xrpl/tx/transactors/escrow/EscrowFinish.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class EscrowFinish : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static NotTEC
+    preflightSigValidated(PreflightContext const& ctx);
+
+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/Lending/LendingHelpers.h b/include/xrpl/tx/transactors/lending/LendingHelpers.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LendingHelpers.h
rename to include/xrpl/tx/transactors/lending/LendingHelpers.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h
rename to include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h
rename to include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h b/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h
rename to include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanBrokerDelete.h b/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanBrokerDelete.h
rename to include/xrpl/tx/transactors/lending/LoanBrokerDelete.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanBrokerSet.h b/include/xrpl/tx/transactors/lending/LoanBrokerSet.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanBrokerSet.h
rename to include/xrpl/tx/transactors/lending/LoanBrokerSet.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanDelete.h b/include/xrpl/tx/transactors/lending/LoanDelete.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanDelete.h
rename to include/xrpl/tx/transactors/lending/LoanDelete.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanManage.h b/include/xrpl/tx/transactors/lending/LoanManage.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanManage.h
rename to include/xrpl/tx/transactors/lending/LoanManage.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanPay.h b/include/xrpl/tx/transactors/lending/LoanPay.h
similarity index 100%
rename from include/xrpl/tx/transactors/Lending/LoanPay.h
rename to include/xrpl/tx/transactors/lending/LoanPay.h
diff --git a/include/xrpl/tx/transactors/Lending/LoanSet.h b/include/xrpl/tx/transactors/lending/LoanSet.h
similarity index 96%
rename from include/xrpl/tx/transactors/Lending/LoanSet.h
rename to include/xrpl/tx/transactors/lending/LoanSet.h
index e9916b9d6b..86101d0735 100644
--- a/include/xrpl/tx/transactors/Lending/LoanSet.h
+++ b/include/xrpl/tx/transactors/lending/LoanSet.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <xrpl/tx/Transactor.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h b/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h
similarity index 91%
rename from include/xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h
rename to include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h
index d876a70362..60962fc9ca 100644
--- a/include/xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h
+++ b/include/xrpl/tx/transactors/nft/NFTokenAcceptOffer.h
@@ -26,9 +26,6 @@ public:
     {
     }
 
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
     static NotTEC
     preflight(PreflightContext const& ctx);
 
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenBurn.h b/include/xrpl/tx/transactors/nft/NFTokenBurn.h
similarity index 100%
rename from include/xrpl/tx/transactors/NFT/NFTokenBurn.h
rename to include/xrpl/tx/transactors/nft/NFTokenBurn.h
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenCancelOffer.h b/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h
similarity index 86%
rename from include/xrpl/tx/transactors/NFT/NFTokenCancelOffer.h
rename to include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h
index bb8cd4c216..6d60a0bebd 100644
--- a/include/xrpl/tx/transactors/NFT/NFTokenCancelOffer.h
+++ b/include/xrpl/tx/transactors/nft/NFTokenCancelOffer.h
@@ -13,9 +13,6 @@ public:
     {
     }
 
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
     static NotTEC
     preflight(PreflightContext const& ctx);
 
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenCreateOffer.h b/include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h
similarity index 100%
rename from include/xrpl/tx/transactors/NFT/NFTokenCreateOffer.h
rename to include/xrpl/tx/transactors/nft/NFTokenCreateOffer.h
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenMint.h b/include/xrpl/tx/transactors/nft/NFTokenMint.h
similarity index 94%
rename from include/xrpl/tx/transactors/NFT/NFTokenMint.h
rename to include/xrpl/tx/transactors/nft/NFTokenMint.h
index c3a7db4581..d4eeba2bf0 100644
--- a/include/xrpl/tx/transactors/NFT/NFTokenMint.h
+++ b/include/xrpl/tx/transactors/nft/NFTokenMint.h
@@ -2,7 +2,7 @@
 
 #include <xrpl/protocol/nft.h>
 #include <xrpl/tx/Transactor.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenModify.h b/include/xrpl/tx/transactors/nft/NFTokenModify.h
similarity index 100%
rename from include/xrpl/tx/transactors/NFT/NFTokenModify.h
rename to include/xrpl/tx/transactors/nft/NFTokenModify.h
diff --git a/include/xrpl/tx/transactors/NFT/NFTokenUtils.h b/include/xrpl/tx/transactors/nft/NFTokenUtils.h
similarity index 99%
rename from include/xrpl/tx/transactors/NFT/NFTokenUtils.h
rename to include/xrpl/tx/transactors/nft/NFTokenUtils.h
index a5e2b30354..f33bd6e911 100644
--- a/include/xrpl/tx/transactors/NFT/NFTokenUtils.h
+++ b/include/xrpl/tx/transactors/nft/NFTokenUtils.h
@@ -54,7 +54,7 @@ removeToken(
     ApplyView& view,
     AccountID const& owner,
     uint256 const& nftokenID,
-    std::shared_ptr<SLE>&& page);
+    std::shared_ptr<SLE> const& page);
 
 /** Deletes the given token offer.
 
diff --git a/include/xrpl/tx/transactors/DeleteOracle.h b/include/xrpl/tx/transactors/oracle/DeleteOracle.h
similarity index 100%
rename from include/xrpl/tx/transactors/DeleteOracle.h
rename to include/xrpl/tx/transactors/oracle/DeleteOracle.h
diff --git a/include/xrpl/tx/transactors/SetOracle.h b/include/xrpl/tx/transactors/oracle/SetOracle.h
similarity index 100%
rename from include/xrpl/tx/transactors/SetOracle.h
rename to include/xrpl/tx/transactors/oracle/SetOracle.h
diff --git a/include/xrpl/tx/transactors/DepositPreauth.h b/include/xrpl/tx/transactors/payment/DepositPreauth.h
similarity index 100%
rename from include/xrpl/tx/transactors/DepositPreauth.h
rename to include/xrpl/tx/transactors/payment/DepositPreauth.h
diff --git a/include/xrpl/tx/transactors/Payment.h b/include/xrpl/tx/transactors/payment/Payment.h
similarity index 100%
rename from include/xrpl/tx/transactors/Payment.h
rename to include/xrpl/tx/transactors/payment/Payment.h
diff --git a/include/xrpl/tx/transactors/payment_channel/PayChanClaim.h b/include/xrpl/tx/transactors/payment_channel/PayChanClaim.h
new file mode 100644
index 0000000000..a2728a60e7
--- /dev/null
+++ b/include/xrpl/tx/transactors/payment_channel/PayChanClaim.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class PayChanClaim : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+
+    explicit PayChanClaim(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelClaim = PayChanClaim;
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/payment_channel/PayChanCreate.h b/include/xrpl/tx/transactors/payment_channel/PayChanCreate.h
new file mode 100644
index 0000000000..ff59fdbdd0
--- /dev/null
+++ b/include/xrpl/tx/transactors/payment_channel/PayChanCreate.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class PayChanCreate : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit PayChanCreate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelCreate = PayChanCreate;
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/payment_channel/PayChanFund.h b/include/xrpl/tx/transactors/payment_channel/PayChanFund.h
new file mode 100644
index 0000000000..ac0f9e0ce2
--- /dev/null
+++ b/include/xrpl/tx/transactors/payment_channel/PayChanFund.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+class PayChanFund : public Transactor
+{
+public:
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
+
+    explicit PayChanFund(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    TER
+    doApply() override;
+};
+
+using PaymentChannelFund = PayChanFund;
+
+}  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h
similarity index 100%
rename from include/xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h
rename to include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h
diff --git a/include/xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h b/include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h
similarity index 100%
rename from include/xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h
rename to include/xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h
diff --git a/include/xrpl/tx/transactors/Batch.h b/include/xrpl/tx/transactors/system/Batch.h
similarity index 100%
rename from include/xrpl/tx/transactors/Batch.h
rename to include/xrpl/tx/transactors/system/Batch.h
diff --git a/include/xrpl/tx/transactors/Change.h b/include/xrpl/tx/transactors/system/Change.h
similarity index 100%
rename from include/xrpl/tx/transactors/Change.h
rename to include/xrpl/tx/transactors/system/Change.h
diff --git a/include/xrpl/tx/transactors/CreateTicket.h b/include/xrpl/tx/transactors/system/CreateTicket.h
similarity index 100%
rename from include/xrpl/tx/transactors/CreateTicket.h
rename to include/xrpl/tx/transactors/system/CreateTicket.h
diff --git a/include/xrpl/tx/transactors/LedgerStateFix.h b/include/xrpl/tx/transactors/system/LedgerStateFix.h
similarity index 100%
rename from include/xrpl/tx/transactors/LedgerStateFix.h
rename to include/xrpl/tx/transactors/system/LedgerStateFix.h
diff --git a/include/xrpl/tx/transactors/Clawback.h b/include/xrpl/tx/transactors/token/Clawback.h
similarity index 85%
rename from include/xrpl/tx/transactors/Clawback.h
rename to include/xrpl/tx/transactors/token/Clawback.h
index 7451266461..a795115f7a 100644
--- a/include/xrpl/tx/transactors/Clawback.h
+++ b/include/xrpl/tx/transactors/token/Clawback.h
@@ -13,9 +13,6 @@ public:
     {
     }
 
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
     static NotTEC
     preflight(PreflightContext const& ctx);
 
diff --git a/include/xrpl/tx/transactors/MPT/MPTokenAuthorize.h b/include/xrpl/tx/transactors/token/MPTokenAuthorize.h
similarity index 100%
rename from include/xrpl/tx/transactors/MPT/MPTokenAuthorize.h
rename to include/xrpl/tx/transactors/token/MPTokenAuthorize.h
diff --git a/include/xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h
similarity index 100%
rename from include/xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h
rename to include/xrpl/tx/transactors/token/MPTokenIssuanceCreate.h
diff --git a/include/xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h
similarity index 86%
rename from include/xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h
rename to include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h
index c4a448032a..416708565a 100644
--- a/include/xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h
+++ b/include/xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h
@@ -13,9 +13,6 @@ public:
     {
     }
 
-    static std::uint32_t
-    getFlagsMask(PreflightContext const& ctx);
-
     static NotTEC
     preflight(PreflightContext const& ctx);
 
diff --git a/include/xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h b/include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h
similarity index 100%
rename from include/xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h
rename to include/xrpl/tx/transactors/token/MPTokenIssuanceSet.h
diff --git a/include/xrpl/tx/transactors/SetTrust.h b/include/xrpl/tx/transactors/token/SetTrust.h
similarity index 100%
rename from include/xrpl/tx/transactors/SetTrust.h
rename to include/xrpl/tx/transactors/token/SetTrust.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultClawback.h b/include/xrpl/tx/transactors/vault/VaultClawback.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultClawback.h
rename to include/xrpl/tx/transactors/vault/VaultClawback.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultCreate.h b/include/xrpl/tx/transactors/vault/VaultCreate.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultCreate.h
rename to include/xrpl/tx/transactors/vault/VaultCreate.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultDelete.h b/include/xrpl/tx/transactors/vault/VaultDelete.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultDelete.h
rename to include/xrpl/tx/transactors/vault/VaultDelete.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultDeposit.h b/include/xrpl/tx/transactors/vault/VaultDeposit.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultDeposit.h
rename to include/xrpl/tx/transactors/vault/VaultDeposit.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultSet.h b/include/xrpl/tx/transactors/vault/VaultSet.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultSet.h
rename to include/xrpl/tx/transactors/vault/VaultSet.h
diff --git a/include/xrpl/tx/transactors/Vault/VaultWithdraw.h b/include/xrpl/tx/transactors/vault/VaultWithdraw.h
similarity index 100%
rename from include/xrpl/tx/transactors/Vault/VaultWithdraw.h
rename to include/xrpl/tx/transactors/vault/VaultWithdraw.h
diff --git a/sanitizers/suppressions/asan.supp b/sanitizers/suppressions/asan.supp
index 7ba98766bd..e02d580aa6 100644
--- a/sanitizers/suppressions/asan.supp
+++ b/sanitizers/suppressions/asan.supp
@@ -1,24 +1,6 @@
 # The idea is to empty this file gradually by fixing the underlying issues and removing suppressions.
 #
 # ASAN_OPTIONS="print_stacktrace=1:detect_container_overflow=0:suppressions=sanitizers/suppressions/asan.supp:halt_on_error=0"
-#
-# The detect_container_overflow=0 option disables false positives from:
-# - Boost intrusive containers (slist_iterator.hpp, hashtable.hpp, aged_unordered_container.h)
-# - Boost context/coroutine stack switching (Workers.cpp, thread.h)
-#
-# See: https://github.com/google/sanitizers/wiki/AddressSanitizerContainerOverflow
-
-# Boost
-interceptor_name:boost/asio
-
-# Leaks in Doctest tests: xrpl.test.*
-interceptor_name:src/libxrpl/net/HTTPClient.cpp
-interceptor_name:src/libxrpl/net/RegisterSSLCerts.cpp
-interceptor_name:src/tests/libxrpl/net/HTTPClient.cpp
-interceptor_name:xrpl/net/AutoSocket.h
-interceptor_name:xrpl/net/HTTPClient.h
-interceptor_name:xrpl/net/HTTPClientSSLContext.h
-interceptor_name:xrpl/net/RegisterSSLCerts.h
 
 # Suppress false positive stack-buffer errors in thread stack allocation
 # Related to ASan's __asan_handle_no_return warnings (github.com/google/sanitizers/issues/189)
diff --git a/sanitizers/suppressions/lsan.supp b/sanitizers/suppressions/lsan.supp
index a81d7d89fa..30d01a2bfa 100644
--- a/sanitizers/suppressions/lsan.supp
+++ b/sanitizers/suppressions/lsan.supp
@@ -1,16 +1,5 @@
 # The idea is to empty this file gradually by fixing the underlying issues and removing suppresions.
 
-# Suppress leaks detected by asan in rippled code.
-leak:src/libxrpl/net/HTTPClient.cpp
-leak:src/libxrpl/net/RegisterSSLCerts.cpp
-leak:src/tests/libxrpl/net/HTTPClient.cpp
-leak:xrpl/net/AutoSocket.h
-leak:xrpl/net/HTTPClient.h
-leak:xrpl/net/HTTPClientSSLContext.h
-leak:xrpl/net/RegisterSSLCerts.h
-leak:ripple::HTTPClient
-leak:ripple::HTTPClientImp
-
 # Suppress leaks detected by asan in boost code.
 leak:boost::asio
 leak:boost/asio
diff --git a/sanitizers/suppressions/runtime-asan-options.txt b/sanitizers/suppressions/runtime-asan-options.txt
new file mode 100644
index 0000000000..fb2727f868
--- /dev/null
+++ b/sanitizers/suppressions/runtime-asan-options.txt
@@ -0,0 +1,8 @@
+detect_container_overflow=false
+detect_stack_use_after_return=false
+debug=true
+halt_on_error=false
+print_stats=true
+print_cmdline=true
+use_sigaltstack=0
+print_stacktrace=1
diff --git a/sanitizers/suppressions/runtime-lsan-options.txt b/sanitizers/suppressions/runtime-lsan-options.txt
new file mode 100644
index 0000000000..fcfccf7bae
--- /dev/null
+++ b/sanitizers/suppressions/runtime-lsan-options.txt
@@ -0,0 +1 @@
+halt_on_error=false
diff --git a/sanitizers/suppressions/runtime-tsan-options.txt b/sanitizers/suppressions/runtime-tsan-options.txt
new file mode 100644
index 0000000000..aafe997ea4
--- /dev/null
+++ b/sanitizers/suppressions/runtime-tsan-options.txt
@@ -0,0 +1,3 @@
+halt_on_error=false
+verbosity=1
+second_deadlock_stack=1
diff --git a/sanitizers/suppressions/runtime-ubsan-options.txt b/sanitizers/suppressions/runtime-ubsan-options.txt
new file mode 100644
index 0000000000..fcfccf7bae
--- /dev/null
+++ b/sanitizers/suppressions/runtime-ubsan-options.txt
@@ -0,0 +1 @@
+halt_on_error=false
diff --git a/sanitizers/suppressions/sanitizer-ignorelist.txt b/sanitizers/suppressions/sanitizer-ignorelist.txt
index 5dbead48a2..dc9a31f8e4 100644
--- a/sanitizers/suppressions/sanitizer-ignorelist.txt
+++ b/sanitizers/suppressions/sanitizer-ignorelist.txt
@@ -27,3 +27,11 @@ src:core/JobQueue.cpp
 src:libxrpl/beast/utility/beast_Journal.cpp
 src:test/beast/beast_PropertyStream_test.cpp
 src:src/test/app/Invariants_test.cpp
+
+# ASan false positive: stack-use-after-scope in ErrorCodes.h inline functions.
+# When Clang inlines the StaticString overloads (e.g. invalid_field_error(StaticString)),
+# ASan scope-poisons the temporary std::string before the inlined callee finishes reading
+# through the const ref. This corrupts the coroutine stack and crashes the Simulate test.
+# See asan.supp comments for full explanation and planned fix.
+[address]
+src:*ErrorCodes.h
diff --git a/sanitizers/suppressions/ubsan.supp b/sanitizers/suppressions/ubsan.supp
index 1504ef685f..bd38e43c32 100644
--- a/sanitizers/suppressions/ubsan.supp
+++ b/sanitizers/suppressions/ubsan.supp
@@ -182,6 +182,17 @@ signed-integer-overflow:src/test/beast/LexicalCast_test.cpp
 # External library suppressions
 unsigned-integer-overflow:nudb/detail/xxhash.hpp
 
+# Loan_test.cpp intentional underflow in test arithmetic
+unsigned-integer-overflow:src/test/app/Loan_test.cpp
+undefined:src/test/app/Loan_test.cpp
+
+# Source tree restructured paths (libxrpl/tx/transactors/)
+# These duplicate the xrpld/app/tx/detail entries above for the new layout
+unsigned-integer-overflow:src/libxrpl/tx/transactors/oracle/SetOracle.cpp
+undefined:src/libxrpl/tx/transactors/oracle/SetOracle.cpp
+unsigned-integer-overflow:src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
+undefined:src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
+
 # Protobuf intentional overflows in hash functions
 # Protobuf uses intentional unsigned overflow for hash computation (stringpiece.h:393)
 unsigned-integer-overflow:google/protobuf/stubs/stringpiece.h
diff --git a/src/libxrpl/basics/Archive.cpp b/src/libxrpl/basics/Archive.cpp
index 06f19b27ee..a09d77d794 100644
--- a/src/libxrpl/basics/Archive.cpp
+++ b/src/libxrpl/basics/Archive.cpp
@@ -51,8 +51,8 @@ extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const&
     if (archive_write_disk_set_standard_lookup(aw.get()) < ARCHIVE_OK)
         Throw<std::runtime_error>(archive_error_string(aw.get()));
 
-    int result;
-    struct archive_entry* entry;
+    int result = 0;
+    struct archive_entry* entry = nullptr;
     while (true)
     {
         result = archive_read_next_header(ar.get(), &entry);
@@ -67,9 +67,9 @@ extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const&
 
         if (archive_entry_size(entry) > 0)
         {
-            void const* buf;
-            size_t sz;
-            la_int64_t offset;
+            void const* buf = nullptr;
+            size_t sz = 0;
+            la_int64_t offset = 0;
             while (true)
             {
                 result = archive_read_data_block(ar.get(), &buf, &sz, &offset);
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index 59a41157db..11d2368b03 100644
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -66,14 +66,12 @@ concept UnsignedMantissa = std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>
 
 class Number::Guard
 {
-    std::uint64_t digits_;   // 16 decimal guard digits
-    std::uint8_t xbit_ : 1;  // has a non-zero digit been shifted off the end
-    std::uint8_t sbit_ : 1;  // the sign of the guard digits
+    std::uint64_t digits_{0};    // 16 decimal guard digits
+    std::uint8_t xbit_ : 1 {0};  // has a non-zero digit been shifted off the end
+    std::uint8_t sbit_ : 1 {0};  // the sign of the guard digits
 
 public:
-    explicit Guard() : digits_{0}, xbit_{0}, sbit_{0}
-    {
-    }
+    explicit Guard() = default;
 
     // set & test the sign bit
     void
@@ -258,7 +256,7 @@ Number::Guard::doRoundUp(
     }
     bringIntoRange(negative, mantissa, exponent, minMantissa);
     if (exponent > maxExponent)
-        throw std::overflow_error(location);
+        Throw<std::overflow_error>(std::string(location));
 }
 
 template <UnsignedMantissa T>
@@ -298,7 +296,7 @@ Number::Guard::doRound(rep& drops, std::string location)
             // or "(maxRep + 1) / 10", neither of which will round up when
             // converting to rep, though the latter might overflow _before_
             // rounding.
-            throw std::overflow_error(location);  // LCOV_EXCL_LINE
+            Throw<std::overflow_error>(std::string(location));  // LCOV_EXCL_LINE
         }
         ++drops;
     }
diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp
index 7c0a93a930..225cbe2926 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -35,7 +35,6 @@ namespace xrpl {
 template <class Derived>
 class AsyncObject
 {
-protected:
     AsyncObject() : m_pending(0)
     {
     }
@@ -93,6 +92,8 @@ public:
 private:
     // The number of handlers pending.
     std::atomic<int> m_pending;
+
+    friend Derived;
 };
 
 class ResolverAsioImpl : public ResolverAsio, public AsyncObject<ResolverAsioImpl>
@@ -108,7 +109,7 @@ public:
 
     std::condition_variable m_cv;
     std::mutex m_mut;
-    bool m_asyncHandlersCompleted;
+    bool m_asyncHandlersCompleted{true};
 
     std::atomic<bool> m_stop_called;
     std::atomic<bool> m_stopped;
@@ -135,7 +136,6 @@ public:
         , m_io_context(io_context)
         , m_strand(boost::asio::make_strand(io_context))
         , m_resolver(io_context)
-        , m_asyncHandlersCompleted(true)
         , m_stop_called(false)
         , m_stopped(true)
     {
diff --git a/src/libxrpl/basics/StringUtilities.cpp b/src/libxrpl/basics/StringUtilities.cpp
index 96b5cfdb9b..0dd466c9b4 100644
--- a/src/libxrpl/basics/StringUtilities.cpp
+++ b/src/libxrpl/basics/StringUtilities.cpp
@@ -103,7 +103,7 @@ trim_whitespace(std::string str)
 std::optional<std::uint64_t>
 to_uint64(std::string const& s)
 {
-    std::uint64_t result;
+    std::uint64_t result = 0;
     if (beast::lexicalCastChecked(result, s))
         return result;
     return std::nullopt;
diff --git a/src/libxrpl/basics/base64.cpp b/src/libxrpl/basics/base64.cpp
index fa06ac2cdc..90bbc71359 100644
--- a/src/libxrpl/basics/base64.cpp
+++ b/src/libxrpl/basics/base64.cpp
@@ -116,6 +116,7 @@ encode(void* dest, void const* src, std::size_t len)
         in += 3;
     }
 
+    // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
     switch (len % 3)
     {
         case 2:
@@ -168,7 +169,7 @@ decode(void* dest, char const* src, std::size_t len)
             break;
         ++in;
         c4[i] = v;
-        if (++i == 4)
+        if (++i; i == 4)
         {
             c3[0] = (c4[0] << 2) + ((c4[1] & 0x30) >> 4);
             c3[1] = ((c4[1] & 0xf) << 4) + ((c4[2] & 0x3c) >> 2);
diff --git a/src/libxrpl/basics/make_SSLContext.cpp b/src/libxrpl/basics/make_SSLContext.cpp
index 885275be9e..7fd6c5b97a 100644
--- a/src/libxrpl/basics/make_SSLContext.cpp
+++ b/src/libxrpl/basics/make_SSLContext.cpp
@@ -239,6 +239,7 @@ initAuthenticated(
     {
         boost::system::error_code ec;
 
+        // NOLINTNEXTLINE(bugprone-unused-return-value)
         context.use_certificate_file(cert_file, boost::asio::ssl::context::pem, ec);
 
         if (ec)
@@ -298,6 +299,7 @@ initAuthenticated(
     {
         boost::system::error_code ec;
 
+        // NOLINTNEXTLINE(bugprone-unused-return-value)
         context.use_private_key_file(key_file, boost::asio::ssl::context::pem, ec);
 
         if (ec)
diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
index 5248657479..4727599740 100644
--- a/src/libxrpl/beast/clock/basic_seconds_clock.cpp
+++ b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
@@ -16,7 +16,7 @@ class seconds_clock_thread
 {
     using Clock = basic_seconds_clock::Clock;
 
-    bool stop_;
+    bool stop_{false};
     std::mutex mut_;
     std::condition_variable cv_;
     std::thread thread_;
@@ -48,8 +48,7 @@ seconds_clock_thread::~seconds_clock_thread()
     thread_.join();
 }
 
-seconds_clock_thread::seconds_clock_thread()
-    : stop_{false}, tp_{Clock::now().time_since_epoch().count()}
+seconds_clock_thread::seconds_clock_thread() : tp_{Clock::now().time_since_epoch().count()}
 {
     thread_ = std::thread(&seconds_clock_thread::run, this);
 }
diff --git a/src/libxrpl/beast/core/CurrentThreadName.cpp b/src/libxrpl/beast/core/CurrentThreadName.cpp
index b63911e9f4..8e54a74e4d 100644
--- a/src/libxrpl/beast/core/CurrentThreadName.cpp
+++ b/src/libxrpl/beast/core/CurrentThreadName.cpp
@@ -62,7 +62,8 @@ namespace beast::detail {
 inline void
 setCurrentThreadNameImpl(std::string_view name)
 {
-    pthread_setname_np(name.data());
+    // The string is assumed to be null terminated
+    pthread_setname_np(name.data());  // NOLINT(bugprone-suspicious-stringview-data-usage)
 }
 
 }  // namespace beast::detail
@@ -85,7 +86,7 @@ setCurrentThreadNameImpl(std::string_view name)
         sizeof(boundedName),
         "%.*s",
         static_cast<int>(maxThreadNameLength),
-        name.data());
+        name.data());  // NOLINT(bugprone-suspicious-stringview-data-usage)
 
     pthread_setname_np(pthread_self(), boundedName);
 
diff --git a/src/libxrpl/beast/core/SemanticVersion.cpp b/src/libxrpl/beast/core/SemanticVersion.cpp
index b18043d5f0..e8899e6854 100644
--- a/src/libxrpl/beast/core/SemanticVersion.cpp
+++ b/src/libxrpl/beast/core/SemanticVersion.cpp
@@ -29,7 +29,7 @@ print_identifiers(SemanticVersion::identifier_list const& list)
 bool
 isNumeric(std::string const& s)
 {
-    int n;
+    int n = 0;
 
     // Must be convertible to an integer
     if (!lexicalCastChecked(n, s))
@@ -68,7 +68,7 @@ chopUInt(int& value, int limit, std::string& input)
     if (item.empty())
         return false;
 
-    int n;
+    int n = 0;
 
     // Must be convertible to an integer
     if (!lexicalCastChecked(n, item))
@@ -138,14 +138,14 @@ SemanticVersion::SemanticVersion() : majorVersion(0), minorVersion(0), patchVers
 {
 }
 
-SemanticVersion::SemanticVersion(std::string const& version) : SemanticVersion()
+SemanticVersion::SemanticVersion(std::string_view version) : SemanticVersion()
 {
     if (!parse(version))
         throw std::invalid_argument("invalid version string");
 }
 
 bool
-SemanticVersion::parse(std::string const& input)
+SemanticVersion::parse(std::string_view input)
 {
     // May not have leading or trailing whitespace
     auto left_iter = std::find_if_not(input.begin(), input.end(), [](std::string::value_type c) {
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index 8462a00b3d..cc3bbf2861 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -104,8 +104,8 @@ private:
 
     std::shared_ptr<StatsDCollectorImp> m_impl;
     std::string m_name;
-    CounterImpl::value_type m_value;
-    bool m_dirty;
+    CounterImpl::value_type m_value{0};
+    bool m_dirty{false};
 };
 
 //------------------------------------------------------------------------------
@@ -162,9 +162,9 @@ private:
 
     std::shared_ptr<StatsDCollectorImp> m_impl;
     std::string m_name;
-    GaugeImpl::value_type m_last_value;
-    GaugeImpl::value_type m_value;
-    bool m_dirty;
+    GaugeImpl::value_type m_last_value{0};
+    GaugeImpl::value_type m_value{0};
+    bool m_dirty{false};
 };
 
 //------------------------------------------------------------------------------
@@ -194,8 +194,8 @@ private:
 
     std::shared_ptr<StatsDCollectorImp> m_impl;
     std::string m_name;
-    MeterImpl::value_type m_value;
-    bool m_dirty;
+    MeterImpl::value_type m_value{0};
+    bool m_dirty{false};
 };
 
 //------------------------------------------------------------------------------
@@ -249,7 +249,7 @@ public:
         {
             m_timer.cancel();
         }
-        catch (boost::system::system_error const&)
+        catch (boost::system::system_error const&)  // NOLINT(bugprone-empty-catch)
         {
             // ignored
         }
@@ -470,6 +470,7 @@ public:
 
         m_io_context.run();
 
+        // NOLINTNEXTLINE(bugprone-unused-return-value)
         m_socket.shutdown(boost::asio::ip::udp::socket::shutdown_send, ec);
 
         m_socket.close();
@@ -504,7 +505,7 @@ StatsDHookImpl::do_process()
 StatsDCounterImpl::StatsDCounterImpl(
     std::string const& name,
     std::shared_ptr<StatsDCollectorImp> const& impl)
-    : m_impl(impl), m_name(name), m_value(0), m_dirty(false)
+    : m_impl(impl), m_name(name)
 {
     m_impl->add(*this);
 }
@@ -586,7 +587,7 @@ StatsDEventImpl::do_notify(EventImpl::value_type const& value)
 StatsDGaugeImpl::StatsDGaugeImpl(
     std::string const& name,
     std::shared_ptr<StatsDCollectorImp> const& impl)
-    : m_impl(impl), m_name(name), m_last_value(0), m_value(0), m_dirty(false)
+    : m_impl(impl), m_name(name)
 {
     m_impl->add(*this);
 }
@@ -675,7 +676,7 @@ StatsDGaugeImpl::do_process()
 StatsDMeterImpl::StatsDMeterImpl(
     std::string const& name,
     std::shared_ptr<StatsDCollectorImp> const& impl)
-    : m_impl(impl), m_name(name), m_value(0), m_dirty(false)
+    : m_impl(impl), m_name(name)
 {
     m_impl->add(*this);
 }
diff --git a/src/libxrpl/beast/net/IPEndpoint.cpp b/src/libxrpl/beast/net/IPEndpoint.cpp
index 701181ef88..992da0041b 100644
--- a/src/libxrpl/beast/net/IPEndpoint.cpp
+++ b/src/libxrpl/beast/net/IPEndpoint.cpp
@@ -159,7 +159,7 @@ operator>>(std::istream& is, Endpoint& endpoint)
 
     if (is.rdbuf()->in_avail() > 0)
     {
-        Port port;
+        Port port = 0;
         is >> port;
         if (is.fail())
             return is;
diff --git a/src/libxrpl/beast/utility/beast_PropertyStream.cpp b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
index f714ad8871..f1edb4c4ef 100644
--- a/src/libxrpl/beast/utility/beast_PropertyStream.cpp
+++ b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
@@ -15,7 +15,7 @@ namespace beast {
 //
 //------------------------------------------------------------------------------
 
-PropertyStream::Item::Item(Source* source) : m_source(source)
+PropertyStream::Item::Item(Source* source) : ListNode(), m_source(source)
 {
 }
 
diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp
index 80fb8d2536..9adbf6312b 100644
--- a/src/libxrpl/core/detail/JobQueue.cpp
+++ b/src/libxrpl/core/detail/JobQueue.cpp
@@ -331,7 +331,7 @@ JobQueue::finishJob(JobType type)
 void
 JobQueue::processTask(int instance)
 {
-    JobType type;
+    JobType type = jtINVALID;
 
     {
         using namespace std::chrono;
diff --git a/src/libxrpl/crypto/RFC1751.cpp b/src/libxrpl/crypto/RFC1751.cpp
index 54d3e6f9d0..a21bc71c31 100644
--- a/src/libxrpl/crypto/RFC1751.cpp
+++ b/src/libxrpl/crypto/RFC1751.cpp
@@ -198,10 +198,10 @@ char const* RFC1751::s_dictionary[2048] = {
 unsigned long
 RFC1751::extract(char const* s, int start, int length)
 {
-    unsigned char cl;
-    unsigned char cc;
-    unsigned char cr;
-    unsigned long x;
+    unsigned char cl = 0;
+    unsigned char cc = 0;
+    unsigned char cr = 0;
+    unsigned long x = 0;
 
     XRPL_ASSERT(length <= 11, "xrpl::RFC1751::extract : maximum length");
     XRPL_ASSERT(start >= 0, "xrpl::RFC1751::extract : minimum start");
@@ -226,7 +226,7 @@ void
 RFC1751::btoe(std::string& strHuman, std::string const& strData)
 {
     char caBuffer[9]; /* add in room for the parity 2 bits*/
-    int p, i;
+    int p = 0, i = 0;
 
     memcpy(caBuffer, strData.c_str(), 8);
 
@@ -245,11 +245,11 @@ RFC1751::btoe(std::string& strHuman, std::string const& strData)
 void
 RFC1751::insert(char* s, int x, int start, int length)
 {
-    unsigned char cl;
-    unsigned char cc;
-    unsigned char cr;
-    unsigned long y;
-    int shift;
+    unsigned char cl = 0;
+    unsigned char cc = 0;
+    unsigned char cr = 0;
+    unsigned long y = 0;
+    int shift = 0;
 
     XRPL_ASSERT(length <= 11, "xrpl::RFC1751::insert : maximum length");
     XRPL_ASSERT(start >= 0, "xrpl::RFC1751::insert : minimum start");
@@ -336,7 +336,7 @@ RFC1751::etob(std::string& strData, std::vector<std::string> vsHuman)
     if (6 != vsHuman.size())
         return -1;
 
-    int i, p = 0;
+    int i = 0, p = 0;
     char b[9] = {0};
 
     for (auto& strWord : vsHuman)
diff --git a/src/libxrpl/crypto/csprng.cpp b/src/libxrpl/crypto/csprng.cpp
index 7858d4089c..25e24c0b08 100644
--- a/src/libxrpl/crypto/csprng.cpp
+++ b/src/libxrpl/crypto/csprng.cpp
@@ -30,7 +30,7 @@ csprng_engine::~csprng_engine()
 void
 csprng_engine::mix_entropy(void* buffer, std::size_t count)
 {
-    std::array<std::random_device::result_type, 128> entropy;
+    std::array<std::random_device::result_type, 128> entropy{};
 
     {
         // On every platform we support, std::random_device
@@ -71,7 +71,7 @@ csprng_engine::operator()(void* ptr, std::size_t count)
 csprng_engine::result_type
 csprng_engine::operator()()
 {
-    result_type ret;
+    result_type ret = 0;
     (*this)(&ret, sizeof(result_type));
     return ret;
 }
diff --git a/src/libxrpl/git/Git.cpp b/src/libxrpl/git/Git.cpp
new file mode 100644
index 0000000000..2992852632
--- /dev/null
+++ b/src/libxrpl/git/Git.cpp
@@ -0,0 +1,31 @@
+#include "xrpl/git/Git.h"
+
+#include <string>
+
+#ifndef GIT_COMMIT_HASH
+#error "GIT_COMMIT_HASH must be defined"
+#endif
+#ifndef GIT_BUILD_BRANCH
+#error "GIT_BUILD_BRANCH must be defined"
+#endif
+
+namespace xrpl::git {
+
+static constexpr char kGIT_COMMIT_HASH[] = GIT_COMMIT_HASH;
+static constexpr char kGIT_BUILD_BRANCH[] = GIT_BUILD_BRANCH;
+
+std::string const&
+getCommitHash()
+{
+    static std::string const kVALUE = kGIT_COMMIT_HASH;
+    return kVALUE;
+}
+
+std::string const&
+getBuildBranch()
+{
+    static std::string const kVALUE = kGIT_BUILD_BRANCH;
+    return kVALUE;
+}
+
+}  // namespace xrpl::git
diff --git a/src/libxrpl/json/Writer.cpp b/src/libxrpl/json/Writer.cpp
index be9595b088..ee3d6f97a8 100644
--- a/src/libxrpl/json/Writer.cpp
+++ b/src/libxrpl/json/Writer.cpp
@@ -196,7 +196,7 @@ private:
         explicit Collection() = default;
 
         /** What type of collection are we in? */
-        Writer::CollectionType type;
+        Writer::CollectionType type = Writer::CollectionType::array;
 
         /** Is this the first entry in a collection?
          *  If false, we have to emit a , before we write the next entry. */
diff --git a/src/libxrpl/json/json_reader.cpp b/src/libxrpl/json/json_reader.cpp
index d28268454f..1195816516 100644
--- a/src/libxrpl/json/json_reader.cpp
+++ b/src/libxrpl/json/json_reader.cpp
@@ -94,7 +94,7 @@ Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
 
     nodes_.push(&root);
     bool successful = readValue(0);
-    Token token;
+    Token token{};
     skipCommentTokens(token);
 
     if (!root.isNull() && !root.isArray() && !root.isObject())
@@ -114,7 +114,7 @@ Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
 bool
 Reader::readValue(unsigned depth)
 {
-    Token token;
+    Token token{};
     skipCommentTokens(token);
     if (depth > nest_limit)
         return addError("Syntax error: maximum nesting depth exceeded", token);
@@ -395,7 +395,7 @@ Reader::readString()
 bool
 Reader::readObject(Token& tokenStart, unsigned depth)
 {
-    Token tokenName;
+    Token tokenName{};
     std::string name;
     currentValue() = Value(objectValue);
 
@@ -420,7 +420,7 @@ Reader::readObject(Token& tokenStart, unsigned depth)
         if (!decodeString(tokenName, name))
             return recoverFromError(tokenObjectEnd);
 
-        Token colon;
+        Token colon{};
 
         if (!readToken(colon) || colon.type_ != tokenMemberSeparator)
         {
@@ -440,7 +440,7 @@ Reader::readObject(Token& tokenStart, unsigned depth)
         if (!ok)  // error already set
             return recoverFromError(tokenObjectEnd);
 
-        Token comma;
+        Token comma{};
 
         if (!readToken(comma) ||
             (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
@@ -470,7 +470,7 @@ Reader::readArray(Token& tokenStart, unsigned depth)
 
     if (*current_ == ']')  // empty array
     {
-        Token endArray;
+        Token endArray{};
         readToken(endArray);
         return true;
     }
@@ -487,7 +487,7 @@ Reader::readArray(Token& tokenStart, unsigned depth)
         if (!ok)  // error already set
             return recoverFromError(tokenArrayEnd);
 
-        Token token;
+        Token token{};
         // Accept Comment after last item in the array.
         ok = readToken(token);
 
@@ -591,7 +591,7 @@ Reader::decodeDouble(Token& token)
 {
     double value = 0;
     int const bufferSize = 32;
-    int count;
+    int count = 0;
     int length = int(token.end_ - token.start_);
     // Sanity check to avoid buffer overflow exploits.
     if (length < 0)
@@ -689,7 +689,7 @@ Reader::decodeString(Token& token, std::string& decoded)
                     break;
 
                 case 'u': {
-                    unsigned int unicode;
+                    unsigned int unicode = 0;
 
                     if (!decodeUnicodeCodePoint(token, current, end, unicode))
                         return false;
@@ -727,23 +727,20 @@ Reader::decodeUnicodeCodePoint(Token& token, Location& current, Location end, un
                 token,
                 current);
 
-        unsigned int surrogatePair;
+        unsigned int surrogatePair = 0;
 
-        if (*(current++) == '\\' && *(current++) == 'u')
-        {
-            if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair))
-            {
-                unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
-            }
-            else
-                return false;
-        }
-        else
+        if (*current != '\\' || *(current + 1) != 'u')
             return addError(
-                "expecting another \\u token to begin the second half of a "
-                "unicode surrogate pair",
+                "expecting another \\u token to begin the second half of a unicode surrogate pair",
                 token,
                 current);
+
+        current += 2;  // skip two characters checked above
+
+        if (!decodeUnicodeEscapeSequence(token, current, end, surrogatePair))
+            return false;
+
+        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
     }
 
     return true;
@@ -799,7 +796,7 @@ bool
 Reader::recoverFromError(TokenType skipUntilToken)
 {
     int errorCount = int(errors_.size());
-    Token skip;
+    Token skip{};
 
     while (true)
     {
@@ -870,7 +867,7 @@ Reader::getLocationLineAndColumn(Location location, int& line, int& column) cons
 std::string
 Reader::getLocationLineAndColumn(Location location) const
 {
-    int line, column;
+    int line = 0, column = 0;
     getLocationLineAndColumn(location, line, column);
     return "Line " + std::to_string(line) + ", Column " + std::to_string(column);
 }
diff --git a/src/libxrpl/json/json_value.cpp b/src/libxrpl/json/json_value.cpp
index 60197d75f0..88542f530d 100644
--- a/src/libxrpl/json/json_value.cpp
+++ b/src/libxrpl/json/json_value.cpp
@@ -157,7 +157,7 @@ Value::CZString::isStaticString() const
  * memset( this, 0, sizeof(Value) )
  * This optimization is used in ValueInternalMap fast allocator.
  */
-Value::Value(ValueType type) : type_(type), allocated_(0)
+Value::Value(ValueType type) : type_(type)
 {
     switch (type)
     {
@@ -225,7 +225,7 @@ Value::Value(std::string const& value) : type_(stringValue), allocated_(true)
         valueAllocator()->duplicateStringValue(value.c_str(), (unsigned int)value.length());
 }
 
-Value::Value(StaticString const& value) : type_(stringValue), allocated_(false)
+Value::Value(StaticString const& value) : type_(stringValue)
 {
     value_.string_ = const_cast<char*>(value.c_str());
 }
diff --git a/src/libxrpl/json/json_writer.cpp b/src/libxrpl/json/json_writer.cpp
index 13baf95845..8ba2576552 100644
--- a/src/libxrpl/json/json_writer.cpp
+++ b/src/libxrpl/json/json_writer.cpp
@@ -319,7 +319,7 @@ StyledWriter::writeValue(Value const& value)
                     document_ += " : ";
                     writeValue(childValue);
 
-                    if (++it == members.end())
+                    if (++it; it == members.end())
                         break;
 
                     document_ += ",";
diff --git a/src/libxrpl/ledger/ApplyStateTable.cpp b/src/libxrpl/ledger/ApplyStateTable.cpp
index e31b39b437..8c1f8d64d2 100644
--- a/src/libxrpl/ledger/ApplyStateTable.cpp
+++ b/src/libxrpl/ledger/ApplyStateTable.cpp
@@ -107,7 +107,7 @@ ApplyStateTable::apply(
         Mods newMod;
         for (auto& item : items_)
         {
-            SField const* type;
+            SField const* type = nullptr;
             switch (item.second.first)
             {
                 default:
@@ -513,7 +513,7 @@ void
 ApplyStateTable::threadItem(TxMeta& meta, std::shared_ptr<SLE> const& sle)
 {
     key_type prevTxID;
-    LedgerIndex prevLgrID;
+    LedgerIndex prevLgrID = 0;
 
     if (!sle->thread(meta.getTxID(), meta.getLgrSeq(), prevTxID, prevLgrID))
         return;
diff --git a/src/libxrpl/ledger/BookDirs.cpp b/src/libxrpl/ledger/BookDirs.cpp
index 4ba5945e8e..699d6c2879 100644
--- a/src/libxrpl/ledger/BookDirs.cpp
+++ b/src/libxrpl/ledger/BookDirs.cpp
@@ -74,8 +74,10 @@ BookDirs::const_iterator::operator++()
     XRPL_ASSERT(index_ != zero, "xrpl::BookDirs::const_iterator::operator++ : nonzero index");
     if (!cdirNext(*view_, cur_key_, sle_, entry_, index_))
     {
-        if (index_ != 0 ||
-            (cur_key_ = view_->succ(++cur_key_, next_quality_).value_or(zero)) == zero)
+        if (index_ == 0)
+            cur_key_ = view_->succ(++cur_key_, next_quality_).value_or(zero);
+
+        if (index_ != 0 || cur_key_ == zero)
         {
             cur_key_ = key_;
             entry_ = 0;
@@ -84,9 +86,7 @@ BookDirs::const_iterator::operator++()
         else if (!cdirFirst(*view_, cur_key_, sle_, entry_, index_))
         {
             // LCOV_EXCL_START
-            UNREACHABLE(
-                "xrpl::BookDirs::const_iterator::operator++ : directory is "
-                "empty");
+            UNREACHABLE("xrpl::BookDirs::const_iterator::operator++ : directory is empty");
             // LCOV_EXCL_STOP
         }
     }
diff --git a/src/libxrpl/ledger/CredentialHelpers.cpp b/src/libxrpl/ledger/CredentialHelpers.cpp
index 04438e09ad..1f32f5f1fa 100644
--- a/src/libxrpl/ledger/CredentialHelpers.cpp
+++ b/src/libxrpl/ledger/CredentialHelpers.cpp
@@ -197,7 +197,7 @@ validDomain(ReadView const& view, uint256 domainID, AccountID const& subject)
 }
 
 TER
-authorizedDepositPreauth(ApplyView const& view, STVector256 const& credIDs, AccountID const& dst)
+authorizedDepositPreauth(ReadView const& view, STVector256 const& credIDs, AccountID const& dst)
 {
     std::set<std::pair<AccountID, Slice>> sorted;
     std::vector<std::shared_ptr<SLE const>> lifeExtender;
@@ -318,7 +318,7 @@ verifyDepositPreauth(
     ApplyView& view,
     AccountID const& src,
     AccountID const& dst,
-    std::shared_ptr<SLE> const& sleDst,
+    std::shared_ptr<SLE const> const& sleDst,
     beast::Journal j)
 {
     // If depositPreauth is enabled, then an account that requires
diff --git a/src/libxrpl/ledger/OpenView.cpp b/src/libxrpl/ledger/OpenView.cpp
index d27d755c66..5b94be5da8 100644
--- a/src/libxrpl/ledger/OpenView.cpp
+++ b/src/libxrpl/ledger/OpenView.cpp
@@ -72,8 +72,8 @@ OpenView::OpenView(
     ReadView const* base,
     Rules const& rules,
     std::shared_ptr<void const> hold)
-    : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-          initialBufferSize)}
+    : monotonic_resource_{
+          std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
     , txs_{monotonic_resource_.get()}
     , rules_(rules)
     , header_(base->header())
@@ -88,8 +88,8 @@ OpenView::OpenView(
 }
 
 OpenView::OpenView(ReadView const* base, std::shared_ptr<void const> hold)
-    : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-          initialBufferSize)}
+    : monotonic_resource_{
+          std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
     , txs_{monotonic_resource_.get()}
     , rules_(base->rules())
     , header_(base->header())
diff --git a/src/libxrpl/ledger/View.cpp b/src/libxrpl/ledger/View.cpp
index 837d5dfee6..4df6f47cea 100644
--- a/src/libxrpl/ledger/View.cpp
+++ b/src/libxrpl/ledger/View.cpp
@@ -1321,7 +1321,7 @@ doWithdraw(
     }
     else
     {
-        auto dstSle = view.peek(keylet::account(dstAcct));
+        auto dstSle = view.read(keylet::account(dstAcct));
         if (auto err = verifyDepositPreauth(tx, view, senderAcct, dstAcct, dstSle, j))
             return err;
     }
@@ -2333,7 +2333,6 @@ accountSendMultiIOU(
     if (auto stream = j.trace())
     {
         std::string sender_bal("-");
-        std::string receiver_bal("-");
 
         if (sender)
             sender_bal = sender->getFieldAmount(sfBalance).getFullText();
diff --git a/src/libxrpl/net/HTTPClient.cpp b/src/libxrpl/net/HTTPClient.cpp
index 91a64a1ca9..8ddae12a7e 100644
--- a/src/libxrpl/net/HTTPClient.cpp
+++ b/src/libxrpl/net/HTTPClient.cpp
@@ -26,6 +26,12 @@ HTTPClient::initializeSSLContext(
     httpClientSSLContext.emplace(sslVerifyDir, sslVerifyFile, sslVerify, j);
 }
 
+void
+HTTPClient::cleanupSSLContext()
+{
+    httpClientSSLContext.reset();
+}
+
 //------------------------------------------------------------------------------
 //
 // Fetch a web page via http or https.
@@ -472,7 +478,7 @@ public:
 private:
     using pointer = std::shared_ptr<HTTPClient>;
 
-    bool mSSL;
+    bool mSSL{};
     AutoSocket mSocket;
     boost::asio::ip::tcp::resolver mResolver;
 
@@ -490,7 +496,7 @@ private:
     std::string mBody;
     unsigned short const mPort;
     std::size_t const maxResponseSize_;
-    int mStatus;
+    int mStatus{};
     std::function<void(boost::asio::streambuf& sb, std::string const& strHost)> mBuild;
     std::function<
         bool(boost::system::error_code const& ecResult, int iStatus, std::string const& strData)>
@@ -502,7 +508,7 @@ private:
     boost::system::error_code mShutdown;
 
     std::deque<std::string> mDeqSites;
-    std::chrono::seconds mTimeout;
+    std::chrono::seconds mTimeout{};
     beast::Journal j_;
 };
 
diff --git a/src/libxrpl/net/RegisterSSLCerts.cpp b/src/libxrpl/net/RegisterSSLCerts.cpp
index 87c2eb81b7..1f21a76ddb 100644
--- a/src/libxrpl/net/RegisterSSLCerts.cpp
+++ b/src/libxrpl/net/RegisterSSLCerts.cpp
@@ -79,6 +79,7 @@ registerSSLCerts(boost::asio::ssl::context& ctx, boost::system::error_code& ec,
     SSL_CTX_set_cert_store(ctx.native_handle(), store.release());
 
 #else
+    // NOLINTNEXTLINE(bugprone-unused-return-value)
     ctx.set_default_verify_paths(ec);
 #endif
 }
diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp
index ed7753f68e..98fe78c489 100644
--- a/src/libxrpl/nodestore/BatchWriter.cpp
+++ b/src/libxrpl/nodestore/BatchWriter.cpp
@@ -75,7 +75,7 @@ BatchWriter::writeBatch()
             }
         }
 
-        BatchWriteReport report;
+        BatchWriteReport report{};
         report.writeCount = set.size();
         auto const before = std::chrono::steady_clock::now();
 
diff --git a/src/libxrpl/nodestore/DatabaseNodeImp.cpp b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
index d1452dba86..a24379aea9 100644
--- a/src/libxrpl/nodestore/DatabaseNodeImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
@@ -29,7 +29,7 @@ DatabaseNodeImp::fetchNodeObject(
     bool duplicate)
 {
     std::shared_ptr<NodeObject> nodeObject = nullptr;
-    Status status;
+    Status status = ok;
 
     try
     {
diff --git a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
index e058fa76ac..6cf51fbf31 100644
--- a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
@@ -101,7 +101,7 @@ DatabaseRotatingImp::fetchNodeObject(
     bool duplicate)
 {
     auto fetch = [&](std::shared_ptr<Backend> const& backend) {
-        Status status;
+        Status status = ok;
         std::shared_ptr<NodeObject> nodeObject;
         try
         {
diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
index 4d7e7be668..229bf8b67b 100644
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -83,7 +83,7 @@ public:
             // close can throw and we don't want the destructor to throw.
             close();
         }
-        catch (nudb::system_error const&)
+        catch (nudb::system_error const&)  // NOLINT(bugprone-empty-catch)
         {
             // Don't allow exceptions to propagate out of destructors.
             // close() has already logged the error.
@@ -181,7 +181,7 @@ public:
     Status
     fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pno) override
     {
-        Status status;
+        Status status = ok;
         pno->reset();
         nudb::error_code ec;
         db_.fetch(
@@ -239,7 +239,7 @@ public:
     void
     store(std::shared_ptr<NodeObject> const& no) override
     {
-        BatchWriteReport report;
+        BatchWriteReport report{};
         report.writeCount = 1;
         auto const start = std::chrono::steady_clock::now();
         do_insert(no);
@@ -251,7 +251,7 @@ public:
     void
     storeBatch(Batch const& batch) override
     {
-        BatchWriteReport report;
+        BatchWriteReport report{};
         report.writeCount = batch.size();
         auto const start = std::chrono::steady_clock::now();
         for (auto const& e : batch)
diff --git a/src/libxrpl/protocol/BuildInfo.cpp b/src/libxrpl/protocol/BuildInfo.cpp
index 32b3431798..7d9a2047a9 100644
--- a/src/libxrpl/protocol/BuildInfo.cpp
+++ b/src/libxrpl/protocol/BuildInfo.cpp
@@ -1,7 +1,9 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/core/LexicalCast.h>
 #include <xrpl/beast/core/SemanticVersion.h>
+#include <xrpl/git/Git.h>
 #include <xrpl/protocol/BuildInfo.h>
+#include <xrpl/protocol/SystemParameters.h>
 
 #include <boost/preprocessor/stringize.hpp>
 
@@ -14,44 +16,60 @@ namespace xrpl {
 
 namespace BuildInfo {
 
+namespace {
+
 //--------------------------------------------------------------------------
 //  The build version number. You must edit this for each release
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
 char const* const versionString = "3.2.0-b0"
-// clang-format on
-
-#if defined(DEBUG) || defined(SANITIZERS)
-    "+"
-#ifdef GIT_COMMIT_HASH
-    GIT_COMMIT_HASH
-    "."
-#endif
-#ifdef DEBUG
-    "DEBUG"
-#ifdef SANITIZERS
-    "."
-#endif
-#endif
-
-#ifdef SANITIZERS
-    BOOST_PP_STRINGIZE(SANITIZERS)  // cspell: disable-line
-#endif
-#endif
-
-    //--------------------------------------------------------------------------
+    // clang-format on
     ;
 
 //
 // Don't touch anything below this line
 //
 
+std::string
+buildVersionString()
+{
+    std::string version = versionString;
+
+#if defined(DEBUG) || defined(SANITIZERS)
+    std::string metadata;
+
+    std::string const& commitHash = xrpl::git::getCommitHash();
+    if (!commitHash.empty())
+        metadata += commitHash + ".";
+
+#ifdef DEBUG
+    metadata += "DEBUG";
+#endif
+
+#if defined(DEBUG) && defined(SANITIZERS)
+    metadata += ".";
+#endif
+
+#ifdef SANITIZERS
+    metadata += BOOST_PP_STRINGIZE(SANITIZERS);  // cspell: disable-line
+#endif
+
+    if (!metadata.empty())
+        version += "+" + metadata;
+#endif
+
+    return version;
+}
+
+}  // namespace
+
 std::string const&
 getVersionString()
 {
     static std::string const value = [] {
-        std::string const s = versionString;
+        std::string const s = buildVersionString();
+
         beast::SemanticVersion v;
         if (!v.parse(s) || v.print() != s)
             LogicError(s + ": Bad server version string");
@@ -63,7 +81,7 @@ getVersionString()
 std::string const&
 getFullVersionString()
 {
-    static std::string const value = "rippled-" + getVersionString();
+    static std::string const value = systemName() + "-" + getVersionString();
     return value;
 }
 
@@ -71,13 +89,13 @@ static constexpr std::uint64_t implementationVersionIdentifier = 0x183B'0000'000
 static constexpr std::uint64_t implementationVersionIdentifierMask = 0xFFFF'0000'0000'0000LLU;
 
 std::uint64_t
-encodeSoftwareVersion(char const* const versionStr)
+encodeSoftwareVersion(std::string_view versionStr)
 {
     std::uint64_t c = implementationVersionIdentifier;
 
     beast::SemanticVersion v;
 
-    if (v.parse(std::string(versionStr)))
+    if (v.parse(versionStr))
     {
         if (v.majorVersion >= 0 && v.majorVersion <= 255)
             c |= static_cast<std::uint64_t>(v.majorVersion) << 40;
@@ -137,7 +155,7 @@ encodeSoftwareVersion(char const* const versionStr)
 std::uint64_t
 getEncodedVersion()
 {
-    static std::uint64_t const cookie = {encodeSoftwareVersion(versionString)};
+    static std::uint64_t const cookie = {encodeSoftwareVersion(getVersionString())};
     return cookie;
 }
 
diff --git a/src/libxrpl/protocol/Feature.cpp b/src/libxrpl/protocol/Feature.cpp
index 28ff1547df..4d904a5e43 100644
--- a/src/libxrpl/protocol/Feature.cpp
+++ b/src/libxrpl/protocol/Feature.cpp
@@ -395,10 +395,20 @@ featureToName(uint256 const& f)
 #pragma push_macro("XRPL_RETIRE_FIX")
 #undef XRPL_RETIRE_FIX
 
+consteval auto
+enforceValidFeatureName(auto fn) -> char const*
+{
+    static_assert(validFeatureName(fn), "Invalid feature name");
+    static_assert(validFeatureNameSize(fn), "Invalid feature name size");
+    return fn();
+}
+
 #define XRPL_FEATURE(name, supported, vote) \
-    uint256 const feature##name = registerFeature(#name, supported, vote);
+    uint256 const feature##name =           \
+        registerFeature(enforceValidFeatureName([] { return #name; }), supported, vote);
 #define XRPL_FIX(name, supported, vote) \
-    uint256 const fix##name = registerFeature("fix" #name, supported, vote);
+    uint256 const fix##name =           \
+        registerFeature(enforceValidFeatureName([] { return "fix" #name; }), supported, vote);
 
 // clang-format off
 #define XRPL_RETIRE_FEATURE(name)                                       \
diff --git a/src/libxrpl/protocol/LedgerFormats.cpp b/src/libxrpl/protocol/LedgerFormats.cpp
index 2056cfab7b..30725f44a9 100644
--- a/src/libxrpl/protocol/LedgerFormats.cpp
+++ b/src/libxrpl/protocol/LedgerFormats.cpp
@@ -3,19 +3,23 @@
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/jss.h>
 
-#include <initializer_list>
+#include <vector>
 
 namespace xrpl {
 
-LedgerFormats::LedgerFormats()
+std::vector<SOElement> const&
+LedgerFormats::getCommonFields()
 {
-    // Fields shared by all ledger formats:
-    static std::initializer_list<SOElement> const commonFields{
+    static auto const commonFields = std::vector<SOElement>{
         {sfLedgerIndex, soeOPTIONAL},
         {sfLedgerEntryType, soeREQUIRED},
         {sfFlags, soeREQUIRED},
     };
+    return commonFields;
+}
 
+LedgerFormats::LedgerFormats()
+{
 #pragma push_macro("UNWRAP")
 #undef UNWRAP
 #pragma push_macro("LEDGER_ENTRY")
@@ -23,7 +27,7 @@ LedgerFormats::LedgerFormats()
 
 #define UNWRAP(...) __VA_ARGS__
 #define LEDGER_ENTRY(tag, value, name, rpcName, fields) \
-    add(jss::name, tag, UNWRAP fields, commonFields);
+    add(jss::name, tag, UNWRAP fields, getCommonFields());
 
 #include <xrpl/protocol/detail/ledger_entries.macro>
 
diff --git a/src/libxrpl/protocol/Permissions.cpp b/src/libxrpl/protocol/Permissions.cpp
index 991f9d4d82..cce7ab5058 100644
--- a/src/libxrpl/protocol/Permissions.cpp
+++ b/src/libxrpl/protocol/Permissions.cpp
@@ -86,7 +86,7 @@ Permission::getPermissionName(std::uint32_t const value) const
 {
     auto const permissionValue = static_cast<GranularPermissionType>(value);
     if (auto const granular = getGranularName(permissionValue))
-        return *granular;
+        return granular;
 
     // not a granular permission, check if it maps to a transaction type
     auto const txType = permissionToTxType(value);
diff --git a/src/libxrpl/protocol/SOTemplate.cpp b/src/libxrpl/protocol/SOTemplate.cpp
index 46edf98710..b90bff6192 100644
--- a/src/libxrpl/protocol/SOTemplate.cpp
+++ b/src/libxrpl/protocol/SOTemplate.cpp
@@ -2,23 +2,32 @@
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/SOTemplate.h>
 
+#include <algorithm>
 #include <cstddef>
 #include <initializer_list>
+#include <iterator>
 #include <stdexcept>
+#include <vector>
 
 namespace xrpl {
 
 SOTemplate::SOTemplate(
     std::initializer_list<SOElement> uniqueFields,
     std::initializer_list<SOElement> commonFields)
+    : SOTemplate(std::vector(uniqueFields), std::vector(commonFields))
+{
+}
+
+SOTemplate::SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields)
     : indices_(SField::getNumFields() + 1, -1)  // Unmapped indices == -1
 {
     // Add all SOElements.
-    elements_.reserve(uniqueFields.size() + commonFields.size());
-    elements_.assign(uniqueFields);
-    elements_.insert(elements_.end(), commonFields);
+    //
+    elements_ = std::move(uniqueFields);
+    std::ranges::move(commonFields, std::back_inserter(elements_));
 
     // Validate and index elements_.
+    //
     for (std::size_t i = 0; i < elements_.size(); ++i)
     {
         SField const& sField{elements_[i].sField()};
diff --git a/src/libxrpl/protocol/STAccount.cpp b/src/libxrpl/protocol/STAccount.cpp
index b85341daf3..9570191273 100644
--- a/src/libxrpl/protocol/STAccount.cpp
+++ b/src/libxrpl/protocol/STAccount.cpp
@@ -24,7 +24,7 @@ STAccount::STAccount(SField const& n) : STBase(n), value_(beast::zero), default_
 {
 }
 
-STAccount::STAccount(SField const& n, Buffer&& v) : STAccount(n)
+STAccount::STAccount(SField const& n, Buffer const& v) : STAccount(n)
 {
     if (v.empty())
         return;  // Zero is a valid size for a defaulted STAccount.
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 650cc4369d..5990e1d7d4 100644
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -181,7 +181,7 @@ STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name)
 }
 
 STAmount::STAmount(SField const& name, std::int64_t mantissa)
-    : STBase(name), mAsset(xrpIssue()), mOffset(0)
+    : STBase(name), mAsset(xrpIssue()), mValue(0), mOffset(0), mIsNegative(false)
 {
     set(mantissa);
 }
@@ -443,6 +443,7 @@ getRate(STAmount const& offerOut, STAmount const& offerIn)
 {
     if (offerOut == beast::zero)
         return 0;
+
     try
     {
         STAmount r = divide(offerIn, offerOut, noIssue());
@@ -454,12 +455,11 @@ getRate(STAmount const& offerOut, STAmount const& offerIn)
         std::uint64_t ret = r.exponent() + 100;
         return (ret << (64 - 8)) | r.mantissa();
     }
-    catch (std::exception const&)
+    catch (...)
     {
+        // overflow -- very bad offer
+        return 0;
     }
-
-    // overflow -- very bad offer
-    return 0;
 }
 
 /**
diff --git a/src/libxrpl/protocol/STArray.cpp b/src/libxrpl/protocol/STArray.cpp
index 8e7827cccc..91acc9ddd3 100644
--- a/src/libxrpl/protocol/STArray.cpp
+++ b/src/libxrpl/protocol/STArray.cpp
@@ -44,7 +44,7 @@ STArray::STArray(SerialIter& sit, SField const& f, int depth) : STBase(f)
 {
     while (!sit.empty())
     {
-        int type, field;
+        int type = 0, field = 0;
         sit.getFieldID(type, field);
 
         if ((type == STI_ARRAY) && (field == 1))
diff --git a/src/libxrpl/protocol/STBase.cpp b/src/libxrpl/protocol/STBase.cpp
index f6b1dcec58..3c5c34ae4e 100644
--- a/src/libxrpl/protocol/STBase.cpp
+++ b/src/libxrpl/protocol/STBase.cpp
@@ -23,6 +23,9 @@ STBase::STBase(SField const& n) : fName(&n)
 STBase&
 STBase::operator=(STBase const& t)
 {
+    if (this == &t)
+        return *this;
+
     if (!fName->isUseful())
         fName = t.fName;
     return *this;
diff --git a/src/libxrpl/protocol/STIssue.cpp b/src/libxrpl/protocol/STIssue.cpp
index 5887b5c21f..1d37554251 100644
--- a/src/libxrpl/protocol/STIssue.cpp
+++ b/src/libxrpl/protocol/STIssue.cpp
@@ -100,7 +100,7 @@ STIssue::add(Serializer& s) const
         auto const& issue = asset_.get<MPTIssue>();
         s.addBitString(issue.getIssuer());
         s.addBitString(noAccount());
-        std::uint32_t sequence;
+        std::uint32_t sequence = 0;
         memcpy(&sequence, issue.getMptID().data(), sizeof(sequence));
         s.add32(sequence);
     }
diff --git a/src/libxrpl/protocol/STLedgerEntry.cpp b/src/libxrpl/protocol/STLedgerEntry.cpp
index 8d0d56a737..09993583be 100644
--- a/src/libxrpl/protocol/STLedgerEntry.cpp
+++ b/src/libxrpl/protocol/STLedgerEntry.cpp
@@ -43,14 +43,14 @@ STLedgerEntry::STLedgerEntry(Keylet const& k) : STObject(sfLedgerEntry), key_(k.
 }
 
 STLedgerEntry::STLedgerEntry(SerialIter& sit, uint256 const& index)
-    : STObject(sfLedgerEntry), key_(index)
+    : STObject(sfLedgerEntry), key_(index), type_(ltANY)
 {
     set(sit);
     setSLEType();
 }
 
 STLedgerEntry::STLedgerEntry(STObject const& object, uint256 const& index)
-    : STObject(object), key_(index)
+    : STObject(object), key_(index), type_(ltANY)
 {
     setSLEType();
 }
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index cdee274f67..6d382bee9c 100644
--- a/src/libxrpl/protocol/STNumber.cpp
+++ b/src/libxrpl/protocol/STNumber.cpp
@@ -179,8 +179,8 @@ partsFromString(std::string const& number)
 
     bool negative = (match[1].matched && (match[1] == "-"));
 
-    std::uint64_t mantissa;
-    int exponent;
+    std::uint64_t mantissa = 0;
+    int exponent = 0;
 
     if (!match[4].matched)  // integer only
     {
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index 829f8eaeef..05d4d12503 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -46,7 +46,7 @@ STObject::STObject(STObject&& other)
 {
 }
 
-STObject::STObject(SField const& name) : STBase(name), mType(nullptr)
+STObject::STObject(SField const& name) : STBase(name)
 {
 }
 
@@ -62,8 +62,7 @@ STObject::STObject(SOTemplate const& type, SerialIter& sit, SField const& name)
     applyTemplate(type);  // May throw
 }
 
-STObject::STObject(SerialIter& sit, SField const& name, int depth) noexcept(false)
-    : STBase(name), mType(nullptr)
+STObject::STObject(SerialIter& sit, SField const& name, int depth) noexcept(false) : STBase(name)
 {
     if (depth > 10)
         Throw<std::runtime_error>("Maximum nesting depth of STObject exceeded");
@@ -216,8 +215,8 @@ STObject::set(SerialIter& sit, int depth)
     // Consume data in the pipe until we run out or reach the end
     while (!sit.empty())
     {
-        int type;
-        int field;
+        int type = 0;
+        int field = 0;
 
         // Get the metadata for the next field
         sit.getFieldID(type, field);
diff --git a/src/libxrpl/protocol/STParsedJSON.cpp b/src/libxrpl/protocol/STParsedJSON.cpp
index d72db32282..b246daf48e 100644
--- a/src/libxrpl/protocol/STParsedJSON.cpp
+++ b/src/libxrpl/protocol/STParsedJSON.cpp
@@ -449,7 +449,7 @@ parseLeaf(
                 {
                     auto const str = value.asString();
 
-                    std::uint64_t val;
+                    std::uint64_t val = 0;
 
                     bool const useBase10 = field.shouldMeta(SField::sMD_BaseTen);
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index a3b79f775f..2ab5deb66d 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -214,6 +214,20 @@ STTx::getSeqValue() const
     return getSeqProxy().value();
 }
 
+AccountID
+STTx::getFeePayer() const
+{
+    // If sfDelegate is present, the delegate account is the payer
+    // note: if a delegate is specified, its authorization to act on behalf of the account is
+    // enforced in `Transactor::checkPermission`
+    // cryptographic signature validity is checked separately (e.g., in `Transactor::checkSign`)
+    if (isFieldPresent(sfDelegate))
+        return getAccountID(sfDelegate);
+
+    // Default payer
+    return getAccountID(sfAccount);
+}
+
 void
 STTx::sign(
     PublicKey const& publicKey,
@@ -249,10 +263,10 @@ STTx::checkSign(Rules const& rules, STObject const& sigObject) const
         return signingPubKey.empty() ? checkMultiSign(rules, sigObject)
                                      : checkSingleSign(sigObject);
     }
-    catch (std::exception const&)
+    catch (...)
     {
+        return Unexpected("Internal signature check failure.");
     }
-    return Unexpected("Internal signature check failure.");
 }
 
 Expected<void, std::string>
@@ -355,7 +369,7 @@ STTx::getMetaSQL(std::uint32_t inLedger, std::string const& escapedMetaData) con
 {
     Serializer s;
     add(s);
-    return getMetaSQL(s, inLedger, txnSqlValidated, escapedMetaData);
+    return getMetaSQL(s, inLedger, TxnSql::txnSqlValidated, escapedMetaData);
 }
 
 // VFALCO This could be a free function elsewhere
@@ -363,7 +377,7 @@ std::string
 STTx::getMetaSQL(
     Serializer rawTxn,
     std::uint32_t inLedger,
-    char status,
+    TxnSql status,
     std::string const& escapedMetaData) const
 {
     static boost::format bfTrans("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)");
@@ -374,8 +388,8 @@ STTx::getMetaSQL(
 
     return str(
         boost::format(bfTrans) % to_string(getTransactionID()) % format->getName() %
-        toBase58(getAccountID(sfAccount)) % getFieldU32(sfSequence) % inLedger % status % rTxn %
-        escapedMetaData);
+        toBase58(getAccountID(sfAccount)) % getFieldU32(sfSequence) % inLedger %
+        safe_cast<char>(status) % rTxn % escapedMetaData);
 }
 
 static Expected<void, std::string>
@@ -682,9 +696,9 @@ invalidMPTAmountInTx(STObject const& tx)
             {
                 if (auto const& field = tx.peekAtField(e.sField());
                     (field.getSType() == STI_AMOUNT &&
-                     static_cast<STAmount const&>(field).holds<MPTIssue>()) ||
+                     safe_downcast<STAmount const&>(field).holds<MPTIssue>()) ||
                     (field.getSType() == STI_ISSUE &&
-                     static_cast<STIssue const&>(field).holds<MPTIssue>()))
+                     safe_downcast<STIssue const&>(field).holds<MPTIssue>()))
                 {
                     if (e.supportMPT() != soeMPTSupported)
                         return true;
diff --git a/src/libxrpl/protocol/STVar.cpp b/src/libxrpl/protocol/STVar.cpp
index 994077da56..6218bb6db6 100644
--- a/src/libxrpl/protocol/STVar.cpp
+++ b/src/libxrpl/protocol/STVar.cpp
@@ -133,9 +133,9 @@ STVar::constructST(SerializedTypeID id, int depth, Args&&... args)
         {
             construct<T>(std::forward<Args>(args)...);
         }
-        else if constexpr (std::is_same_v<
-                               std::tuple<std::remove_cvref_t<Args>...>,
-                               std::tuple<SerialIter, SField>>)
+        else if constexpr (
+            std::
+                is_same_v<std::tuple<std::remove_cvref_t<Args>...>, std::tuple<SerialIter, SField>>)
         {
             construct<T>(std::forward<Args>(args)..., depth);
         }
diff --git a/src/libxrpl/protocol/SecretKey.cpp b/src/libxrpl/protocol/SecretKey.cpp
index 4f0963e72d..aa398e9fe1 100644
--- a/src/libxrpl/protocol/SecretKey.cpp
+++ b/src/libxrpl/protocol/SecretKey.cpp
@@ -74,7 +74,7 @@ deriveDeterministicRootKey(Seed const& seed)
     // buf  |----------------|----|
     //      |      seed      | seq|
 
-    std::array<std::uint8_t, 20> buf;
+    std::array<std::uint8_t, 20> buf{};
     std::copy(seed.begin(), seed.end(), buf.begin());
 
     // The odds that this loop executes more than once are negligible
@@ -119,7 +119,7 @@ class Generator
 {
 private:
     uint256 root_;
-    std::array<std::uint8_t, 33> generator_;
+    std::array<std::uint8_t, 33> generator_{};
 
     uint256
     calculateTweak(std::uint32_t seq) const
@@ -133,7 +133,7 @@ private:
         // buf  |---------------------------------|----|----|
         //      |            generator            | seq| cnt|
 
-        std::array<std::uint8_t, 41> buf;
+        std::array<std::uint8_t, 41> buf{};
         std::copy(generator_.begin(), generator_.end(), buf.begin());
         copy_uint32(buf.data() + 33, seq);
 
diff --git a/src/libxrpl/protocol/Seed.cpp b/src/libxrpl/protocol/Seed.cpp
index 0e0bb7fb2b..8aa1d8b67d 100644
--- a/src/libxrpl/protocol/Seed.cpp
+++ b/src/libxrpl/protocol/Seed.cpp
@@ -46,7 +46,7 @@ Seed::Seed(uint128 const& seed)
 Seed
 randomSeed()
 {
-    std::array<std::uint8_t, 16> buffer;
+    std::array<std::uint8_t, 16> buffer{};
     beast::rngfill(buffer.data(), buffer.size(), crypto_prng());
     Seed seed(makeSlice(buffer));
     secure_erase(buffer.data(), buffer.size());
diff --git a/src/libxrpl/protocol/Serializer.cpp b/src/libxrpl/protocol/Serializer.cpp
index 483e6b516f..4415f96484 100644
--- a/src/libxrpl/protocol/Serializer.cpp
+++ b/src/libxrpl/protocol/Serializer.cpp
@@ -206,7 +206,7 @@ Serializer::addVL(void const* ptr, int len)
 int
 Serializer::addEncoded(int length)
 {
-    std::array<std::uint8_t, 4> bytes;
+    std::array<std::uint8_t, 4> bytes{};
     int numBytes = 0;
 
     if (length <= 192)
@@ -466,7 +466,7 @@ int
 SerialIter::getVLDataLength()
 {
     int b1 = get8();
-    int datLen;
+    int datLen = 0;
     int lenLen = Serializer::decodeLengthLength(b1);
     if (lenLen == 1)
     {
diff --git a/src/libxrpl/protocol/TxFormats.cpp b/src/libxrpl/protocol/TxFormats.cpp
index 00a560de1b..4492ae271b 100644
--- a/src/libxrpl/protocol/TxFormats.cpp
+++ b/src/libxrpl/protocol/TxFormats.cpp
@@ -3,14 +3,14 @@
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/jss.h>
 
-#include <initializer_list>
+#include <vector>
 
 namespace xrpl {
 
-TxFormats::TxFormats()
+std::vector<SOElement> const&
+TxFormats::getCommonFields()
 {
-    // Fields shared by all txFormats:
-    static std::initializer_list<SOElement> const commonFields{
+    static auto const commonFields = std::vector<SOElement>{
         {sfTransactionType, soeREQUIRED},
         {sfFlags, soeOPTIONAL},
         {sfSourceTag, soeOPTIONAL},
@@ -29,7 +29,11 @@ TxFormats::TxFormats()
         {sfNetworkID, soeOPTIONAL},
         {sfDelegate, soeOPTIONAL},
     };
+    return commonFields;
+}
 
+TxFormats::TxFormats()
+{
 #pragma push_macro("UNWRAP")
 #undef UNWRAP
 #pragma push_macro("TRANSACTION")
@@ -37,7 +41,7 @@ TxFormats::TxFormats()
 
 #define UNWRAP(...) __VA_ARGS__
 #define TRANSACTION(tag, value, name, delegable, amendment, privileges, fields) \
-    add(jss::name, tag, UNWRAP fields, commonFields);
+    add(jss::name, tag, UNWRAP fields, getCommonFields());
 
 #include <xrpl/protocol/detail/transactions.macro>
 
diff --git a/src/libxrpl/protocol/tokens.cpp b/src/libxrpl/protocol/tokens.cpp
index 867c69a802..868c45e46c 100644
--- a/src/libxrpl/protocol/tokens.cpp
+++ b/src/libxrpl/protocol/tokens.cpp
@@ -329,7 +329,7 @@ decodeBase58Token(std::string const& s, TokenType type)
         return {};
 
     // And the checksum must as well.
-    std::array<char, 4> guard;
+    std::array<char, 4> guard{};
     checksum(guard.data(), ret.data(), ret.size() - guard.size());
     if (!std::equal(guard.rbegin(), guard.rend(), ret.rbegin()))
         return {};
@@ -610,7 +610,7 @@ encodeBase58Token(
     std::span<std::uint8_t> out)
 {
     constexpr std::size_t tmpBufSize = 128;
-    std::array<std::uint8_t, tmpBufSize> buf;
+    std::array<std::uint8_t, tmpBufSize> buf{};
     if (input.size() > tmpBufSize - 5)
     {
         return Unexpected(TokenCodecErrc::inputTooLarge);
@@ -637,7 +637,7 @@ encodeBase58Token(
 B58Result<std::span<std::uint8_t>>
 decodeBase58Token(TokenType type, std::string_view s, std::span<std::uint8_t> outBuf)
 {
-    std::array<std::uint8_t, 64> tmpBuf;
+    std::array<std::uint8_t, 64> tmpBuf{};
     auto const decodeResult = detail::b58_to_b256_be(s, std::span(tmpBuf.data(), tmpBuf.size()));
 
     if (!decodeResult)
@@ -654,7 +654,7 @@ decodeBase58Token(TokenType type, std::string_view s, std::span<std::uint8_t> ou
         return Unexpected(TokenCodecErrc::mismatchedTokenType);
 
     // And the checksum must as well.
-    std::array<std::uint8_t, 4> guard;
+    std::array<std::uint8_t, 4> guard{};
     checksum(guard.data(), ret.data(), ret.size() - guard.size());
     if (!std::equal(guard.rbegin(), guard.rend(), ret.rbegin()))
     {
diff --git a/src/libxrpl/resource/Consumer.cpp b/src/libxrpl/resource/Consumer.cpp
index 11c23b1044..e9435bd340 100644
--- a/src/libxrpl/resource/Consumer.cpp
+++ b/src/libxrpl/resource/Consumer.cpp
@@ -39,6 +39,9 @@ Consumer::~Consumer()
 Consumer&
 Consumer::operator=(Consumer const& other)
 {
+    if (this == &other)
+        return *this;
+
     // remove old ref
     if (m_logic && m_entry)
         m_logic->release(*m_entry);
diff --git a/src/libxrpl/server/JSONRPCUtil.cpp b/src/libxrpl/server/JSONRPCUtil.cpp
index d32a579d8d..db2ea450a2 100644
--- a/src/libxrpl/server/JSONRPCUtil.cpp
+++ b/src/libxrpl/server/JSONRPCUtil.cpp
@@ -17,7 +17,7 @@ getHTTPHeaderTimestamp()
     //         sense. There's no point in doing all this work if this function
     //         gets called multiple times a second.
     char buffer[96];
-    time_t now;
+    time_t now = 0;
     time(&now);
     struct tm now_gmt{};
 #ifndef _MSC_VER
@@ -68,6 +68,7 @@ HTTPReply(int nStatus, std::string const& content, Json::Output const& output, b
         return;
     }
 
+    // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
     switch (nStatus)
     {
         case 200:
diff --git a/src/libxrpl/server/Port.cpp b/src/libxrpl/server/Port.cpp
index 9e73d9f007..0cef9bed90 100644
--- a/src/libxrpl/server/Port.cpp
+++ b/src/libxrpl/server/Port.cpp
@@ -98,7 +98,7 @@ populate(
     while (std::getline(ss, ip, ','))
     {
         boost::algorithm::trim(ip);
-        bool v4;
+        bool v4 = false;
         boost::asio::ip::network_v4 v4Net;
         boost::asio::ip::network_v6 v6Net;
 
diff --git a/src/libxrpl/server/State.cpp b/src/libxrpl/server/State.cpp
index f41a0c61b3..371f2b4d0a 100644
--- a/src/libxrpl/server/State.cpp
+++ b/src/libxrpl/server/State.cpp
@@ -54,7 +54,7 @@ initStateDB(soci::session& session, BasicConfig const& config, std::string const
 LedgerIndex
 getCanDelete(soci::session& session)
 {
-    LedgerIndex seq;
+    LedgerIndex seq = 0;
     session << "SELECT CanDeleteSeq FROM CanDelete WHERE Key = 1;", soci::into(seq);
     ;
     return seq;
diff --git a/src/libxrpl/server/Vacuum.cpp b/src/libxrpl/server/Vacuum.cpp
index cb31c6fa7a..89764b777a 100644
--- a/src/libxrpl/server/Vacuum.cpp
+++ b/src/libxrpl/server/Vacuum.cpp
@@ -25,7 +25,7 @@ doVacuumDB(DatabaseCon::Setup const& setup, beast::Journal j)
 
     auto txnDB = std::make_unique<DatabaseCon>(setup, TxDBName, setup.txPragma, TxDBInit, j);
     auto& session = txnDB->getSession();
-    std::uint32_t pageSize;
+    std::uint32_t pageSize = 0;
 
     // Only the most trivial databases will fit in memory on typical
     // (recommended) hardware. Force temp files to be written to disk
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index 15457b2d2e..d5fa67fdac 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -1,5 +1,6 @@
 #include <xrpl/basics/TaggedCache.ipp>
 #include <xrpl/basics/contract.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapAccountStateLeafNode.h>
 #include <xrpl/shamap/SHAMapNodeID.h>
@@ -122,7 +123,7 @@ SHAMap::walkTowardsKey(uint256 const& id, SharedPtrNodeStack* stack) const
 
     if (stack != nullptr)
         stack->push({inNode, nodeID});
-    return static_cast<SHAMapLeafNode*>(inNode.get());
+    return safe_downcast<SHAMapLeafNode*>(inNode.get());
 }
 
 SHAMapLeafNode*
@@ -471,7 +472,7 @@ SHAMap::onlyBelow(SHAMapTreeNode* node) const
     while (!node->isLeaf())
     {
         SHAMapTreeNode* nextNode = nullptr;
-        auto inner = static_cast<SHAMapInnerNode*>(node);
+        auto inner = safe_downcast<SHAMapInnerNode*>(node);
         for (int i = 0; i < branchFactor; ++i)
         {
             if (!inner->isEmptyBranch(i))
@@ -496,7 +497,7 @@ SHAMap::onlyBelow(SHAMapTreeNode* node) const
 
     // An inner node must have at least one leaf
     // below it, unless it's the root_
-    auto const leaf = static_cast<SHAMapLeafNode const*>(node);
+    auto const leaf = safe_downcast<SHAMapLeafNode const*>(node);
     XRPL_ASSERT(
         leaf->peekItem() || (leaf == root_.get()), "xrpl::SHAMap::onlyBelow : valid inner node");
     return leaf->peekItem();
@@ -578,7 +579,7 @@ SHAMap::upper_bound(uint256 const& id) const
         auto [node, nodeID] = stack.top();
         if (node->isLeaf())
         {
-            auto leaf = static_cast<SHAMapLeafNode*>(node.get());
+            auto leaf = safe_downcast<SHAMapLeafNode*>(node.get());
             if (leaf->peekItem()->key() > id)
                 return const_iterator(this, leaf->peekItem().get(), std::move(stack));
         }
@@ -611,7 +612,7 @@ SHAMap::lower_bound(uint256 const& id) const
         auto [node, nodeID] = stack.top();
         if (node->isLeaf())
         {
-            auto leaf = static_cast<SHAMapLeafNode*>(node.get());
+            auto leaf = safe_downcast<SHAMapLeafNode*>(node.get());
             if (leaf->peekItem()->key() < id)
                 return const_iterator(this, leaf->peekItem().get(), std::move(stack));
         }
@@ -662,9 +663,10 @@ SHAMap::delItem(uint256 const& id)
 
     SHAMapNodeType type = leaf->getType();
 
-    // What gets attached to the end of the chain
-    // (For now, nothing, since we deleted the leaf)
-    intr_ptr::SharedPtr<SHAMapTreeNode> prevNode;
+    using TreeNodeType = intr_ptr::SharedPtr<SHAMapTreeNode>;
+
+    // What gets attached to the end of the chain (For now, nothing, since we deleted the leaf)
+    TreeNodeType prevNode;
 
     while (!stack.empty())
     {
@@ -673,7 +675,12 @@ SHAMap::delItem(uint256 const& id)
         stack.pop();
 
         node = unshareNode(std::move(node), nodeID);
-        node->setChild(selectBranch(nodeID, id), std::move(prevNode));
+        node->setChild(
+            selectBranch(nodeID, id), std::move(prevNode));  // NOLINT(bugprone-use-after-move)
+
+        XRPL_ASSERT(
+            not prevNode,  // NOLINT(bugprone-use-after-move)
+            "xrpl::SHAMap::delItem : prevNode should be nullptr after std::move");
 
         if (!nodeID.isRoot())
         {
@@ -683,7 +690,9 @@ SHAMap::delItem(uint256 const& id)
             if (bc == 0)
             {
                 // no children below this branch
-                prevNode.reset();
+                //
+                // Note: This is unnecessary due to the std::move above but left here for safety
+                prevNode = TreeNodeType{};
             }
             else if (bc == 1)
             {
@@ -696,7 +705,7 @@ SHAMap::delItem(uint256 const& id)
                     {
                         if (!node->isEmptyBranch(i))
                         {
-                            node->setChild(i, intr_ptr::SharedPtr<SHAMapTreeNode>{});
+                            node->setChild(i, TreeNodeType{});
                             break;
                         }
                     }
@@ -764,7 +773,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
 
         node = intr_ptr::make_shared<SHAMapInnerNode>(node->cowid());
 
-        unsigned int b1, b2;
+        unsigned int b1 = 0, b2 = 0;
 
         while ((b1 = selectBranch(nodeID, tag)) == (b2 = selectBranch(nodeID, otherItem->key())))
         {
@@ -779,7 +788,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
         // we can add the two leaf nodes here
         XRPL_ASSERT(node->isInner(), "xrpl::SHAMap::addGiveItem : node is inner");
 
-        auto inner = static_cast<SHAMapInnerNode*>(node.get());
+        auto inner = safe_downcast<SHAMapInnerNode*>(node.get());
         inner->setChild(b1, makeTypedLeaf(type, std::move(item), cowid_));
         inner->setChild(b2, makeTypedLeaf(type, std::move(otherItem), cowid_));
     }
@@ -1088,7 +1097,7 @@ SHAMap::dump(bool hash) const
 
         if (node->isInner())
         {
-            auto inner = static_cast<SHAMapInnerNode*>(node);
+            auto inner = safe_downcast<SHAMapInnerNode*>(node);
             for (int i = 0; i < branchFactor; ++i)
             {
                 if (!inner->isEmptyBranch(i))
diff --git a/src/libxrpl/shamap/SHAMapDelta.cpp b/src/libxrpl/shamap/SHAMapDelta.cpp
index 9a6342343f..7ef78d51c3 100644
--- a/src/libxrpl/shamap/SHAMapDelta.cpp
+++ b/src/libxrpl/shamap/SHAMapDelta.cpp
@@ -1,5 +1,6 @@
 #include <xrpl/basics/IntrusivePointer.ipp>
 #include <xrpl/basics/contract.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/shamap/SHAMap.h>
 
 #include <array>
@@ -39,7 +40,7 @@ SHAMap::walkBranch(
         if (node->isInner())
         {
             // This is an inner node, add all non-empty branches
-            auto inner = static_cast<SHAMapInnerNode*>(node);
+            auto inner = safe_downcast<SHAMapInnerNode*>(node);
             for (int i = 0; i < 16; ++i)
                 if (!inner->isEmptyBranch(i))
                     nodeStack.push({descendThrow(inner, i)});
@@ -47,7 +48,7 @@ SHAMap::walkBranch(
         else
         {
             // This is a leaf node, process its item
-            auto item = static_cast<SHAMapLeafNode*>(node)->peekItem();
+            auto item = safe_downcast<SHAMapLeafNode*>(node)->peekItem();
 
             if (emptyBranch || (item->key() != otherMapItem->key()))
             {
@@ -132,8 +133,8 @@ SHAMap::compare(SHAMap const& otherMap, Delta& differences, int maxCount) const
         if (ourNode->isLeaf() && otherNode->isLeaf())
         {
             // two leaves
-            auto ours = static_cast<SHAMapLeafNode*>(ourNode);
-            auto other = static_cast<SHAMapLeafNode*>(otherNode);
+            auto ours = safe_downcast<SHAMapLeafNode*>(ourNode);
+            auto other = safe_downcast<SHAMapLeafNode*>(otherNode);
             if (ours->peekItem()->key() == other->peekItem()->key())
             {
                 if (ours->peekItem()->slice() != other->peekItem()->slice())
@@ -161,22 +162,22 @@ SHAMap::compare(SHAMap const& otherMap, Delta& differences, int maxCount) const
         }
         else if (ourNode->isInner() && otherNode->isLeaf())
         {
-            auto ours = static_cast<SHAMapInnerNode*>(ourNode);
-            auto other = static_cast<SHAMapLeafNode*>(otherNode);
+            auto ours = safe_downcast<SHAMapInnerNode*>(ourNode);
+            auto other = safe_downcast<SHAMapLeafNode*>(otherNode);
             if (!walkBranch(ours, other->peekItem(), true, differences, maxCount))
                 return false;
         }
         else if (ourNode->isLeaf() && otherNode->isInner())
         {
-            auto ours = static_cast<SHAMapLeafNode*>(ourNode);
-            auto other = static_cast<SHAMapInnerNode*>(otherNode);
+            auto ours = safe_downcast<SHAMapLeafNode*>(ourNode);
+            auto other = safe_downcast<SHAMapInnerNode*>(otherNode);
             if (!otherMap.walkBranch(other, ours->peekItem(), false, differences, maxCount))
                 return false;
         }
         else if (ourNode->isInner() && otherNode->isInner())
         {
-            auto ours = static_cast<SHAMapInnerNode*>(ourNode);
-            auto other = static_cast<SHAMapInnerNode*>(otherNode);
+            auto ours = safe_downcast<SHAMapInnerNode*>(ourNode);
+            auto other = safe_downcast<SHAMapInnerNode*>(otherNode);
             for (int i = 0; i < 16; ++i)
                 if (ours->getChildHash(i) != other->getChildHash(i))
                 {
diff --git a/src/libxrpl/shamap/SHAMapInnerNode.cpp b/src/libxrpl/shamap/SHAMapInnerNode.cpp
index 7c344d9264..695e35c75d 100644
--- a/src/libxrpl/shamap/SHAMapInnerNode.cpp
+++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp
@@ -20,7 +20,7 @@ SHAMapInnerNode::~SHAMapInnerNode() = default;
 void
 SHAMapInnerNode::partialDestructor()
 {
-    intr_ptr::SharedPtr<SHAMapTreeNode>* children;
+    intr_ptr::SharedPtr<SHAMapTreeNode>* children = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, std::ignore, children) = hashesAndChildren_.getHashesAndChildren();
     iterNonEmptyChildIndexes([&](auto branchNum, auto indexNum) { children[indexNum].reset(); });
@@ -61,8 +61,8 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     p->hash_ = hash_;
     p->isBranch_ = isBranch_;
     p->fullBelowGen_ = fullBelowGen_;
-    SHAMapHash *cloneHashes, *thisHashes;
-    intr_ptr::SharedPtr<SHAMapTreeNode>*cloneChildren, *thisChildren;
+    SHAMapHash *cloneHashes = nullptr, *thisHashes = nullptr;
+    intr_ptr::SharedPtr<SHAMapTreeNode>*cloneChildren = nullptr, *thisChildren = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, cloneHashes, cloneChildren) =
         p->hashesAndChildren_.getHashesAndChildren();
@@ -185,8 +185,8 @@ SHAMapInnerNode::updateHash()
 void
 SHAMapInnerNode::updateHashDeep()
 {
-    SHAMapHash* hashes;
-    intr_ptr::SharedPtr<SHAMapTreeNode>* children;
+    SHAMapHash* hashes = nullptr;
+    intr_ptr::SharedPtr<SHAMapTreeNode>* children = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, hashes, children) = hashesAndChildren_.getHashesAndChildren();
     iterNonEmptyChildIndexes([&](auto branchNum, auto indexNum) {
diff --git a/src/libxrpl/shamap/SHAMapSync.cpp b/src/libxrpl/shamap/SHAMapSync.cpp
index d80ddb1e43..948d972c18 100644
--- a/src/libxrpl/shamap/SHAMapSync.cpp
+++ b/src/libxrpl/shamap/SHAMapSync.cpp
@@ -1,4 +1,5 @@
 #include <xrpl/basics/random.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapLeafNode.h>
 #include <xrpl/shamap/SHAMapSyncFilter.h>
@@ -12,7 +13,7 @@ SHAMap::visitLeaves(
 {
     visitNodes([&leafFunction](SHAMapTreeNode& node) {
         if (!node.isInner())
-            leafFunction(static_cast<SHAMapLeafNode&>(node).peekItem());
+            leafFunction(safe_downcast<SHAMapLeafNode&>(node).peekItem());
         return true;
     });
 }
@@ -104,7 +105,7 @@ SHAMap::visitDifferences(
     using StackEntry = std::pair<SHAMapInnerNode*, SHAMapNodeID>;
     std::stack<StackEntry, std::vector<StackEntry>> stack;
 
-    stack.push({static_cast<SHAMapInnerNode*>(root_.get()), SHAMapNodeID{}});
+    stack.push({safe_downcast<SHAMapInnerNode*>(root_.get()), SHAMapNodeID{}});
 
     while (!stack.empty())
     {
@@ -127,12 +128,12 @@ SHAMap::visitDifferences(
                 if (next->isInner())
                 {
                     if (!have || !have->hasInnerNode(childID, childHash))
-                        stack.push({static_cast<SHAMapInnerNode*>(next), childID});
+                        stack.push({safe_downcast<SHAMapInnerNode*>(next), childID});
                 }
                 else if (
                     !have ||
                     !have->hasLeafNode(
-                        static_cast<SHAMapLeafNode*>(next)->peekItem()->key(), childHash))
+                        safe_downcast<SHAMapLeafNode*>(next)->peekItem()->key(), childHash))
                 {
                     if (!function(*next))
                         return;
@@ -201,12 +202,13 @@ SHAMap::gmn_ProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se)
                 if (--mn.max_ <= 0)
                     return;
             }
-            else if (d->isInner() && !static_cast<SHAMapInnerNode*>(d)->isFullBelow(mn.generation_))
+            else if (
+                d->isInner() && !safe_downcast<SHAMapInnerNode*>(d)->isFullBelow(mn.generation_))
             {
                 mn.stack_.push(se);
 
                 // Switch to processing the child node
-                node = static_cast<SHAMapInnerNode*>(d);
+                node = safe_downcast<SHAMapInnerNode*>(d);
                 nodeID = nodeID.getChildNodeID(branch);
                 firstChild = rand_int(255);
                 currentChild = 0;
@@ -305,7 +307,7 @@ SHAMap::getMissingNodes(int max, SHAMapSyncFilter* filter)
     // that the two threads will produce different request sets (which is
     // more efficient than sending identical requests).
     MissingNodes::StackEntry pos{
-        static_cast<SHAMapInnerNode*>(root_.get()), SHAMapNodeID(), rand_int(255), 0, true};
+        safe_downcast<SHAMapInnerNode*>(root_.get()), SHAMapNodeID(), rand_int(255), 0, true};
     auto& node = std::get<0>(pos);
     auto& nextChild = std::get<3>(pos);
     auto& fullBelow = std::get<4>(pos);
@@ -399,7 +401,7 @@ SHAMap::getNodeFat(
     while (node && node->isInner() && (nodeID.getDepth() < wanted.getDepth()))
     {
         int branch = selectBranch(nodeID, wanted.getNodeID());
-        auto inner = static_cast<SHAMapInnerNode*>(node);
+        auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;
         node = descendThrow(inner, branch);
@@ -413,7 +415,7 @@ SHAMap::getNodeFat(
         return false;
     }
 
-    if (node->isInner() && static_cast<SHAMapInnerNode*>(node)->isEmpty())
+    if (node->isInner() && safe_downcast<SHAMapInnerNode*>(node)->isEmpty())
     {
         JLOG(journal_.warn()) << "peer requests empty node";
         return false;
@@ -438,7 +440,7 @@ SHAMap::getNodeFat(
         {
             // We descend inner nodes with only a single child
             // without decrementing the depth
-            auto inner = static_cast<SHAMapInnerNode*>(node);
+            auto inner = safe_downcast<SHAMapInnerNode*>(node);
             int bc = inner->getBranchCount();
 
             if ((depth > 0) || (bc == 1))
@@ -530,12 +532,12 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF
     auto currNode = root_.get();
 
     while (currNode->isInner() &&
-           !static_cast<SHAMapInnerNode*>(currNode)->isFullBelow(generation) &&
+           !safe_downcast<SHAMapInnerNode*>(currNode)->isFullBelow(generation) &&
            (currNodeID.getDepth() < node.getDepth()))
     {
         int const branch = selectBranch(currNodeID, node.getNodeID());
         XRPL_ASSERT(branch >= 0, "xrpl::SHAMap::addKnownNode : valid branch");
-        auto inner = static_cast<SHAMapInnerNode*>(currNode);
+        auto inner = safe_downcast<SHAMapInnerNode*>(currNode);
         if (inner->isEmptyBranch(branch))
         {
             JLOG(journal_.warn()) << "Add known node for empty branch" << node;
@@ -570,7 +572,7 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF
         if (newNode->isLeaf())
         {
             auto const& actualKey =
-                static_cast<SHAMapLeafNode const*>(newNode.get())->peekItem()->key();
+                safe_downcast<SHAMapLeafNode const*>(newNode.get())->peekItem()->key();
 
             // Validate that this leaf belongs at the target position
             auto const expectedNodeID = SHAMapNodeID::createID(node.getDepth(), actualKey);
@@ -652,8 +654,8 @@ SHAMap::deepCompare(SHAMap& other) const
         {
             if (!otherNode->isLeaf())
                 return false;
-            auto& nodePeek = static_cast<SHAMapLeafNode*>(node)->peekItem();
-            auto& otherNodePeek = static_cast<SHAMapLeafNode*>(otherNode)->peekItem();
+            auto& nodePeek = safe_downcast<SHAMapLeafNode*>(node)->peekItem();
+            auto& otherNodePeek = safe_downcast<SHAMapLeafNode*>(otherNode)->peekItem();
             if (nodePeek->key() != otherNodePeek->key())
                 return false;
             if (nodePeek->slice() != otherNodePeek->slice())
@@ -663,8 +665,8 @@ SHAMap::deepCompare(SHAMap& other) const
         {
             if (!otherNode->isInner())
                 return false;
-            auto node_inner = static_cast<SHAMapInnerNode*>(node);
-            auto other_inner = static_cast<SHAMapInnerNode*>(otherNode);
+            auto node_inner = safe_downcast<SHAMapInnerNode*>(node);
+            auto other_inner = safe_downcast<SHAMapInnerNode*>(otherNode);
             for (int i = 0; i < 16; ++i)
             {
                 if (node_inner->isEmptyBranch(i))
@@ -704,7 +706,7 @@ SHAMap::hasInnerNode(SHAMapNodeID const& targetNodeID, SHAMapHash const& targetN
     while (node->isInner() && (nodeID.getDepth() < targetNodeID.getDepth()))
     {
         int branch = selectBranch(nodeID, targetNodeID.getNodeID());
-        auto inner = static_cast<SHAMapInnerNode*>(node);
+        auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;
 
@@ -729,7 +731,7 @@ SHAMap::hasLeafNode(uint256 const& tag, SHAMapHash const& targetNodeHash) const
     do
     {
         int branch = selectBranch(nodeID, tag);
-        auto inner = static_cast<SHAMapInnerNode*>(node);
+        auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;  // Dead end, node must not be here
 
@@ -800,7 +802,7 @@ SHAMap::verifyProofPath(uint256 const& rootHash, uint256 const& key, std::vector
             if (node->isInner())
             {
                 auto nodeId = SHAMapNodeID::createID(depth, key);
-                hash = static_cast<SHAMapInnerNode*>(node.get())
+                hash = safe_downcast<SHAMapInnerNode*>(node.get())
                            ->getChildHash(selectBranch(nodeId, key));
             }
             else
diff --git a/src/libxrpl/tx/ApplyContext.cpp b/src/libxrpl/tx/ApplyContext.cpp
index a8eca09ff2..f62c63d1e6 100644
--- a/src/libxrpl/tx/ApplyContext.cpp
+++ b/src/libxrpl/tx/ApplyContext.cpp
@@ -1,8 +1,9 @@
+#include <xrpl/tx/ApplyContext.h>
+//
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/to_string.h>
-#include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/InvariantCheck.h>
+#include <xrpl/tx/invariants/InvariantCheck.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/InvariantCheck.cpp b/src/libxrpl/tx/InvariantCheck.cpp
deleted file mode 100644
index b94f11100b..0000000000
--- a/src/libxrpl/tx/InvariantCheck.cpp
+++ /dev/null
@@ -1,3483 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/MPTIssue.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STArray.h>
-#include <xrpl/protocol/STNumber.h>
-#include <xrpl/protocol/SystemParameters.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFormats.h>
-#include <xrpl/protocol/Units.h>
-#include <xrpl/protocol/nftPageMask.h>
-#include <xrpl/tx/InvariantCheck.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
-#include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
-
-#include <cstdint>
-#include <optional>
-
-namespace xrpl {
-
-/*
-assert(enforce)
-
-There are several asserts (or XRPL_ASSERTs) in this file that check a variable
-named `enforce` when an invariant fails. At first glance, those asserts may look
-incorrect, but they are not.
-
-Those asserts take advantage of two facts:
-1. `asserts` are not (normally) executed in release builds.
-2. Invariants should *never* fail, except in tests that specifically modify
-   the open ledger to break them.
-
-This makes `assert(enforce)` sort of a second-layer of invariant enforcement
-aimed at _developers_. It's designed to fire if a developer writes code that
-violates an invariant, and runs it in unit tests or a develop build that _does
-not have the relevant amendments enabled_. It's intentionally a pain in the neck
-so that bad code gets caught and fixed as early as possible.
-*/
-
-enum Privilege {
-    noPriv = 0x0000,              // The transaction can not do any of the enumerated operations
-    createAcct = 0x0001,          // The transaction can create a new ACCOUNT_ROOT object.
-    createPseudoAcct = 0x0002,    // The transaction can create a pseudo account,
-                                  // which implies createAcct
-    mustDeleteAcct = 0x0004,      // The transaction must delete an ACCOUNT_ROOT object
-    mayDeleteAcct = 0x0008,       // The transaction may delete an ACCOUNT_ROOT
-                                  // object, but does not have to
-    overrideFreeze = 0x0010,      // The transaction can override some freeze rules
-    changeNFTCounts = 0x0020,     // The transaction can mint or burn an NFT
-    createMPTIssuance = 0x0040,   // The transaction can create a new MPT issuance
-    destroyMPTIssuance = 0x0080,  // The transaction can destroy an MPT issuance
-    mustAuthorizeMPT = 0x0100,    // The transaction MUST create or delete an MPT
-                                  // object (except by issuer)
-    mayAuthorizeMPT = 0x0200,     // The transaction MAY create or delete an MPT
-                                  // object (except by issuer)
-    mayDeleteMPT = 0x0400,        // The transaction MAY delete an MPT object. May not create.
-    mustModifyVault = 0x0800,     // The transaction must modify, delete or create, a vault
-    mayModifyVault = 0x1000,      // The transaction MAY modify, delete or create, a vault
-};
-constexpr Privilege
-operator|(Privilege lhs, Privilege rhs)
-{
-    return safe_cast<Privilege>(
-        safe_cast<std::underlying_type_t<Privilege>>(lhs) |
-        safe_cast<std::underlying_type_t<Privilege>>(rhs));
-}
-
-#pragma push_macro("TRANSACTION")
-#undef TRANSACTION
-
-#define TRANSACTION(tag, value, name, delegable, amendment, privileges, ...) \
-    case tag: {                                                              \
-        return (privileges) & priv;                                          \
-    }
-
-bool
-hasPrivilege(STTx const& tx, Privilege priv)
-{
-    switch (tx.getTxnType())
-    {
-#include <xrpl/protocol/detail/transactions.macro>
-
-        // Deprecated types
-        default:
-            return false;
-    }
-};
-
-#undef TRANSACTION
-#pragma pop_macro("TRANSACTION")
-
-void
-TransactionFeeCheck::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const&,
-    std::shared_ptr<SLE const> const&)
-{
-    // nothing to do
-}
-
-bool
-TransactionFeeCheck::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const fee,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    // We should never charge a negative fee
-    if (fee.drops() < 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: fee paid was negative: " << fee.drops();
-        return false;
-    }
-
-    // We should never charge a fee that's greater than or equal to the
-    // entire XRP supply.
-    if (fee >= INITIAL_XRP)
-    {
-        JLOG(j.fatal()) << "Invariant failed: fee paid exceeds system limit: " << fee.drops();
-        return false;
-    }
-
-    // We should never charge more for a transaction than the transaction
-    // authorizes. It's possible to charge less in some circumstances.
-    if (fee > tx.getFieldAmount(sfFee).xrp())
-    {
-        JLOG(j.fatal()) << "Invariant failed: fee paid is " << fee.drops()
-                        << " exceeds fee specified in transaction.";
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-XRPNotCreated::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    /* We go through all modified ledger entries, looking only at account roots,
-     * escrow payments, and payment channels. We remove from the total any
-     * previous XRP values and add to the total any new XRP values. The net
-     * balance of a payment channel is computed from two fields (amount and
-     * balance) and deletions are ignored for paychan and escrow because the
-     * amount fields have not been adjusted for those in the case of deletion.
-     */
-    if (before)
-    {
-        switch (before->getType())
-        {
-            case ltACCOUNT_ROOT:
-                drops_ -= (*before)[sfBalance].xrp().drops();
-                break;
-            case ltPAYCHAN:
-                drops_ -= ((*before)[sfAmount] - (*before)[sfBalance]).xrp().drops();
-                break;
-            case ltESCROW:
-                if (isXRP((*before)[sfAmount]))
-                    drops_ -= (*before)[sfAmount].xrp().drops();
-                break;
-            default:
-                break;
-        }
-    }
-
-    if (after)
-    {
-        switch (after->getType())
-        {
-            case ltACCOUNT_ROOT:
-                drops_ += (*after)[sfBalance].xrp().drops();
-                break;
-            case ltPAYCHAN:
-                if (!isDelete)
-                    drops_ += ((*after)[sfAmount] - (*after)[sfBalance]).xrp().drops();
-                break;
-            case ltESCROW:
-                if (!isDelete && isXRP((*after)[sfAmount]))
-                    drops_ += (*after)[sfAmount].xrp().drops();
-                break;
-            default:
-                break;
-        }
-    }
-}
-
-bool
-XRPNotCreated::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const fee,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    // The net change should never be positive, as this would mean that the
-    // transaction created XRP out of thin air. That's not possible.
-    if (drops_ > 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: XRP net change was positive: " << drops_;
-        return false;
-    }
-
-    // The negative of the net change should be equal to actual fee charged.
-    if (-drops_ != fee.drops())
-    {
-        JLOG(j.fatal()) << "Invariant failed: XRP net change of " << drops_ << " doesn't match fee "
-                        << fee.drops();
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-XRPBalanceChecks::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    auto isBad = [](STAmount const& balance) {
-        if (!balance.native())
-            return true;
-
-        auto const drops = balance.xrp();
-
-        // Can't have more than the number of drops instantiated
-        // in the genesis ledger.
-        if (drops > INITIAL_XRP)
-            return true;
-
-        // Can't have a negative balance (0 is OK)
-        if (drops < XRPAmount{0})
-            return true;
-
-        return false;
-    };
-
-    if (before && before->getType() == ltACCOUNT_ROOT)
-        bad_ |= isBad((*before)[sfBalance]);
-
-    if (after && after->getType() == ltACCOUNT_ROOT)
-        bad_ |= isBad((*after)[sfBalance]);
-}
-
-bool
-XRPBalanceChecks::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if (bad_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: incorrect account XRP balance";
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-NoBadOffers::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    auto isBad = [](STAmount const& pays, STAmount const& gets) {
-        // An offer should never be negative
-        if (pays < beast::zero)
-            return true;
-
-        if (gets < beast::zero)
-            return true;
-
-        // Can't have an XRP to XRP offer:
-        return pays.native() && gets.native();
-    };
-
-    if (before && before->getType() == ltOFFER)
-        bad_ |= isBad((*before)[sfTakerPays], (*before)[sfTakerGets]);
-
-    if (after && after->getType() == ltOFFER)
-        bad_ |= isBad((*after)[sfTakerPays], (*after)[sfTakerGets]);
-}
-
-bool
-NoBadOffers::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if (bad_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: offer with a bad amount";
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-NoZeroEscrow::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    auto isBad = [](STAmount const& amount) {
-        // XRP case
-        if (amount.native())
-        {
-            if (amount.xrp() <= XRPAmount{0})
-                return true;
-
-            if (amount.xrp() >= INITIAL_XRP)
-                return true;
-        }
-        else
-        {
-            // IOU case
-            if (amount.holds<Issue>())
-            {
-                if (amount <= beast::zero)
-                    return true;
-
-                if (badCurrency() == amount.getCurrency())
-                    return true;
-            }
-
-            // MPT case
-            if (amount.holds<MPTIssue>())
-            {
-                if (amount <= beast::zero)
-                    return true;
-
-                if (amount.mpt() > MPTAmount{maxMPTokenAmount})
-                    return true;  // LCOV_EXCL_LINE
-            }
-        }
-        return false;
-    };
-
-    if (before && before->getType() == ltESCROW)
-        bad_ |= isBad((*before)[sfAmount]);
-
-    if (after && after->getType() == ltESCROW)
-        bad_ |= isBad((*after)[sfAmount]);
-
-    auto checkAmount = [this](std::int64_t amount) {
-        if (amount > maxMPTokenAmount || amount < 0)
-            bad_ = true;
-    };
-
-    if (after && after->getType() == ltMPTOKEN_ISSUANCE)
-    {
-        auto const outstanding = (*after)[sfOutstandingAmount];
-        checkAmount(outstanding);
-        if (auto const locked = (*after)[~sfLockedAmount])
-        {
-            checkAmount(*locked);
-            bad_ = outstanding < *locked;
-        }
-    }
-
-    if (after && after->getType() == ltMPTOKEN)
-    {
-        auto const mptAmount = (*after)[sfMPTAmount];
-        checkAmount(mptAmount);
-        if (auto const locked = (*after)[~sfLockedAmount])
-        {
-            checkAmount(*locked);
-        }
-    }
-}
-
-bool
-NoZeroEscrow::finalize(
-    STTx const& txn,
-    TER const,
-    XRPAmount const,
-    ReadView const& rv,
-    beast::Journal const& j)
-{
-    if (bad_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: escrow specifies invalid amount";
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-AccountRootsNotDeleted::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const&)
-{
-    if (isDelete && before && before->getType() == ltACCOUNT_ROOT)
-        accountsDeleted_++;
-}
-
-bool
-AccountRootsNotDeleted::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    // AMM account root can be deleted as the result of AMM withdraw/delete
-    // transaction when the total AMM LP Tokens balance goes to 0.
-    // A successful AccountDelete or AMMDelete MUST delete exactly
-    // one account root.
-    if (hasPrivilege(tx, mustDeleteAcct) && result == tesSUCCESS)
-    {
-        if (accountsDeleted_ == 1)
-            return true;
-
-        if (accountsDeleted_ == 0)
-            JLOG(j.fatal()) << "Invariant failed: account deletion "
-                               "succeeded without deleting an account";
-        else
-            JLOG(j.fatal()) << "Invariant failed: account deletion "
-                               "succeeded but deleted multiple accounts!";
-        return false;
-    }
-
-    // A successful AMMWithdraw/AMMClawback MAY delete one account root
-    // when the total AMM LP Tokens balance goes to 0. Not every AMM withdraw
-    // deletes the AMM account, accountsDeleted_ is set if it is deleted.
-    if (hasPrivilege(tx, mayDeleteAcct) && result == tesSUCCESS && accountsDeleted_ == 1)
-        return true;
-
-    if (accountsDeleted_ == 0)
-        return true;
-
-    JLOG(j.fatal()) << "Invariant failed: an account root was deleted";
-    return false;
-}
-
-//------------------------------------------------------------------------------
-
-void
-AccountRootsDeletedClean::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (isDelete && before && before->getType() == ltACCOUNT_ROOT)
-        accountsDeleted_.emplace_back(before, after);
-}
-
-bool
-AccountRootsDeletedClean::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    // Always check for objects in the ledger, but to prevent differing
-    // transaction processing results, however unlikely, only fail if the
-    // feature is enabled. Enabled, or not, though, a fatal-level message will
-    // be logged
-    [[maybe_unused]] bool const enforce = view.rules().enabled(featureInvariantsV1_1) ||
-        view.rules().enabled(featureSingleAssetVault) ||
-        view.rules().enabled(featureLendingProtocol);
-
-    auto const objectExists = [&view, enforce, &j](auto const& keylet) {
-        (void)enforce;
-        if (auto const sle = view.read(keylet))
-        {
-            // Finding the object is bad
-            auto const typeName = [&sle]() {
-                auto item = LedgerFormats::getInstance().findByType(sle->getType());
-
-                if (item != nullptr)
-                    return item->getName();
-                return std::to_string(sle->getType());
-            }();
-
-            JLOG(j.fatal()) << "Invariant failed: account deletion left behind a " << typeName
-                            << " object";
-            // The comment above starting with "assert(enforce)" explains this
-            // assert.
-            XRPL_ASSERT(
-                enforce,
-                "xrpl::AccountRootsDeletedClean::finalize::objectExists : "
-                "account deletion left no objects behind");
-            return true;
-        }
-        return false;
-    };
-
-    for (auto const& [before, after] : accountsDeleted_)
-    {
-        auto const accountID = before->getAccountID(sfAccount);
-        // An account should not be deleted with a balance
-        if (after->at(sfBalance) != beast::zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: account deletion left "
-                               "behind a non-zero balance";
-            XRPL_ASSERT(
-                enforce,
-                "xrpl::AccountRootsDeletedClean::finalize : "
-                "deleted account has zero balance");
-            if (enforce)
-                return false;
-        }
-        // An account should not be deleted with a non-zero owner count
-        if (after->at(sfOwnerCount) != 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: account deletion left "
-                               "behind a non-zero owner count";
-            XRPL_ASSERT(
-                enforce,
-                "xrpl::AccountRootsDeletedClean::finalize : "
-                "deleted account has zero owner count");
-            if (enforce)
-                return false;
-        }
-        // Simple types
-        for (auto const& [keyletfunc, _, __] : directAccountKeylets)
-        {
-            if (objectExists(std::invoke(keyletfunc, accountID)) && enforce)
-                return false;
-        }
-
-        {
-            // NFT pages. nftpage_min and nftpage_max were already explicitly
-            // checked above as entries in directAccountKeylets. This uses
-            // view.succ() to check for any NFT pages in between the two
-            // endpoints.
-            Keylet const first = keylet::nftpage_min(accountID);
-            Keylet const last = keylet::nftpage_max(accountID);
-
-            std::optional<uint256> key = view.succ(first.key, last.key.next());
-
-            // current page
-            if (key && objectExists(Keylet{ltNFTOKEN_PAGE, *key}) && enforce)
-                return false;
-        }
-
-        // If the account is a pseudo account, then the linked object must
-        // also be deleted. e.g. AMM, Vault, etc.
-        for (auto const& field : getPseudoAccountFields())
-        {
-            if (before->isFieldPresent(*field))
-            {
-                auto const key = before->getFieldH256(*field);
-                if (objectExists(keylet::unchecked(key)) && enforce)
-                    return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-LedgerEntryTypesMatch::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (before && after && before->getType() != after->getType())
-        typeMismatch_ = true;
-
-    if (after)
-    {
-#pragma push_macro("LEDGER_ENTRY")
-#undef LEDGER_ENTRY
-
-#define LEDGER_ENTRY(tag, ...) case tag:
-
-        switch (after->getType())
-        {
-#include <xrpl/protocol/detail/ledger_entries.macro>
-
-            break;
-            default:
-                invalidTypeAdded_ = true;
-                break;
-        }
-
-#undef LEDGER_ENTRY
-#pragma pop_macro("LEDGER_ENTRY")
-    }
-}
-
-bool
-LedgerEntryTypesMatch::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if ((!typeMismatch_) && (!invalidTypeAdded_))
-        return true;
-
-    if (typeMismatch_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: ledger entry type mismatch";
-    }
-
-    if (invalidTypeAdded_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: invalid ledger entry type added";
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-
-void
-NoXRPTrustLines::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const&,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltRIPPLE_STATE)
-    {
-        // checking the issue directly here instead of
-        // relying on .native() just in case native somehow
-        // were systematically incorrect
-        xrpTrustLine_ = after->getFieldAmount(sfLowLimit).issue() == xrpIssue() ||
-            after->getFieldAmount(sfHighLimit).issue() == xrpIssue();
-    }
-}
-
-bool
-NoXRPTrustLines::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if (!xrpTrustLine_)
-        return true;
-
-    JLOG(j.fatal()) << "Invariant failed: an XRP trust line was created";
-    return false;
-}
-
-//------------------------------------------------------------------------------
-
-void
-NoDeepFreezeTrustLinesWithoutFreeze::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const&,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltRIPPLE_STATE)
-    {
-        std::uint32_t const uFlags = after->getFieldU32(sfFlags);
-        bool const lowFreeze = uFlags & lsfLowFreeze;
-        bool const lowDeepFreeze = uFlags & lsfLowDeepFreeze;
-
-        bool const highFreeze = uFlags & lsfHighFreeze;
-        bool const highDeepFreeze = uFlags & lsfHighDeepFreeze;
-
-        deepFreezeWithoutFreeze_ = (lowDeepFreeze && !lowFreeze) || (highDeepFreeze && !highFreeze);
-    }
-}
-
-bool
-NoDeepFreezeTrustLinesWithoutFreeze::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if (!deepFreezeWithoutFreeze_)
-        return true;
-
-    JLOG(j.fatal()) << "Invariant failed: a trust line with deep freeze flag "
-                       "without normal freeze was created";
-    return false;
-}
-
-//------------------------------------------------------------------------------
-
-void
-TransfersNotFrozen::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    /*
-     * A trust line freeze state alone doesn't determine if a transfer is
-     * frozen. The transfer must be examined "end-to-end" because both sides of
-     * the transfer may have different freeze states and freeze impact depends
-     * on the transfer direction. This is why first we need to track the
-     * transfers using IssuerChanges senders/receivers.
-     *
-     * Only in validateIssuerChanges, after we collected all changes can we
-     * determine if the transfer is valid.
-     */
-    if (!isValidEntry(before, after))
-    {
-        return;
-    }
-
-    auto const balanceChange = calculateBalanceChange(before, after, isDelete);
-    if (balanceChange.signum() == 0)
-    {
-        return;
-    }
-
-    recordBalanceChanges(after, balanceChange);
-}
-
-bool
-TransfersNotFrozen::finalize(
-    STTx const& tx,
-    TER const ter,
-    XRPAmount const fee,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    /*
-     * We check this invariant regardless of deep freeze amendment status,
-     * allowing for detection and logging of potential issues even when the
-     * amendment is disabled.
-     *
-     * If an exploit that allows moving frozen assets is discovered,
-     * we can alert operators who monitor fatal messages and trigger assert in
-     * debug builds for an early warning.
-     *
-     * In an unlikely event that an exploit is found, this early detection
-     * enables encouraging the UNL to expedite deep freeze amendment activation
-     * or deploy hotfixes via new amendments. In case of a new amendment, we'd
-     * only have to change this line setting 'enforce' variable.
-     * enforce = view.rules().enabled(featureDeepFreeze) ||
-     *           view.rules().enabled(fixFreezeExploit);
-     */
-    [[maybe_unused]] bool const enforce = view.rules().enabled(featureDeepFreeze);
-
-    for (auto const& [issue, changes] : balanceChanges_)
-    {
-        auto const issuerSle = findIssuer(issue.account, view);
-        // It should be impossible for the issuer to not be found, but check
-        // just in case so rippled doesn't crash in release.
-        if (!issuerSle)
-        {
-            // The comment above starting with "assert(enforce)" explains this
-            // assert.
-            XRPL_ASSERT(
-                enforce,
-                "xrpl::TransfersNotFrozen::finalize : enforce "
-                "invariant.");
-            if (enforce)
-            {
-                return false;
-            }
-            continue;
-        }
-
-        if (!validateIssuerChanges(issuerSle, changes, tx, j, enforce))
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-TransfersNotFrozen::isValidEntry(
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    // `after` can never be null, even if the trust line is deleted.
-    XRPL_ASSERT(after, "xrpl::TransfersNotFrozen::isValidEntry : valid after.");
-    if (!after)
-    {
-        return false;
-    }
-
-    if (after->getType() == ltACCOUNT_ROOT)
-    {
-        possibleIssuers_.emplace(after->at(sfAccount), after);
-        return false;
-    }
-
-    /* While LedgerEntryTypesMatch invariant also checks types, all invariants
-     * are processed regardless of previous failures.
-     *
-     * This type check is still necessary here because it prevents potential
-     * issues in subsequent processing.
-     */
-    return after->getType() == ltRIPPLE_STATE && (!before || before->getType() == ltRIPPLE_STATE);
-}
-
-STAmount
-TransfersNotFrozen::calculateBalanceChange(
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after,
-    bool isDelete)
-{
-    auto const getBalance = [](auto const& line, auto const& other, bool zero) {
-        STAmount amt = line ? line->at(sfBalance) : other->at(sfBalance).zeroed();
-        return zero ? amt.zeroed() : amt;
-    };
-
-    /* Trust lines can be created dynamically by other transactions such as
-     * Payment and OfferCreate that cross offers. Such trust line won't be
-     * created frozen, but the sender might be, so the starting balance must be
-     * treated as zero.
-     */
-    auto const balanceBefore = getBalance(before, after, false);
-
-    /* Same as above, trust lines can be dynamically deleted, and for frozen
-     * trust lines, payments not involving the issuer must be blocked. This is
-     * achieved by treating the final balance as zero when isDelete=true to
-     * ensure frozen line restrictions are enforced even during deletion.
-     */
-    auto const balanceAfter = getBalance(after, before, isDelete);
-
-    return balanceAfter - balanceBefore;
-}
-
-void
-TransfersNotFrozen::recordBalance(Issue const& issue, BalanceChange change)
-{
-    XRPL_ASSERT(
-        change.balanceChangeSign,
-        "xrpl::TransfersNotFrozen::recordBalance : valid trustline "
-        "balance sign.");
-    auto& changes = balanceChanges_[issue];
-    if (change.balanceChangeSign < 0)
-        changes.senders.emplace_back(std::move(change));
-    else
-        changes.receivers.emplace_back(std::move(change));
-}
-
-void
-TransfersNotFrozen::recordBalanceChanges(
-    std::shared_ptr<SLE const> const& after,
-    STAmount const& balanceChange)
-{
-    auto const balanceChangeSign = balanceChange.signum();
-    auto const currency = after->at(sfBalance).getCurrency();
-
-    // Change from low account's perspective, which is trust line default
-    recordBalance({currency, after->at(sfHighLimit).getIssuer()}, {after, balanceChangeSign});
-
-    // Change from high account's perspective, which reverses the sign.
-    recordBalance({currency, after->at(sfLowLimit).getIssuer()}, {after, -balanceChangeSign});
-}
-
-std::shared_ptr<SLE const>
-TransfersNotFrozen::findIssuer(AccountID const& issuerID, ReadView const& view)
-{
-    if (auto it = possibleIssuers_.find(issuerID); it != possibleIssuers_.end())
-    {
-        return it->second;
-    }
-
-    return view.read(keylet::account(issuerID));
-}
-
-bool
-TransfersNotFrozen::validateIssuerChanges(
-    std::shared_ptr<SLE const> const& issuer,
-    IssuerChanges const& changes,
-    STTx const& tx,
-    beast::Journal const& j,
-    bool enforce)
-{
-    if (!issuer)
-    {
-        return false;
-    }
-
-    bool const globalFreeze = issuer->isFlag(lsfGlobalFreeze);
-    if (changes.receivers.empty() || changes.senders.empty())
-    {
-        /* If there are no receivers, then the holder(s) are returning
-         * their tokens to the issuer. Likewise, if there are no
-         * senders, then the issuer is issuing tokens to the holder(s).
-         * This is allowed regardless of the issuer's freeze flags. (The
-         * holder may have contradicting freeze flags, but that will be
-         * checked when the holder is treated as issuer.)
-         */
-        return true;
-    }
-
-    for (auto const& actors : {changes.senders, changes.receivers})
-    {
-        for (auto const& change : actors)
-        {
-            bool const high = change.line->at(sfLowLimit).getIssuer() == issuer->at(sfAccount);
-
-            if (!validateFrozenState(change, high, tx, j, enforce, globalFreeze))
-            {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-bool
-TransfersNotFrozen::validateFrozenState(
-    BalanceChange const& change,
-    bool high,
-    STTx const& tx,
-    beast::Journal const& j,
-    bool enforce,
-    bool globalFreeze)
-{
-    bool const freeze =
-        change.balanceChangeSign < 0 && change.line->isFlag(high ? lsfLowFreeze : lsfHighFreeze);
-    bool const deepFreeze = change.line->isFlag(high ? lsfLowDeepFreeze : lsfHighDeepFreeze);
-    bool const frozen = globalFreeze || deepFreeze || freeze;
-
-    bool const isAMMLine = change.line->isFlag(lsfAMMNode);
-
-    if (!frozen)
-    {
-        return true;
-    }
-
-    // AMMClawbacks are allowed to override some freeze rules
-    if ((!isAMMLine || globalFreeze) && hasPrivilege(tx, overrideFreeze))
-    {
-        JLOG(j.debug()) << "Invariant check allowing funds to be moved "
-                        << (change.balanceChangeSign > 0 ? "to" : "from")
-                        << " a frozen trustline for AMMClawback " << tx.getTransactionID();
-        return true;
-    }
-
-    JLOG(j.fatal()) << "Invariant failed: Attempting to move frozen funds for "
-                    << tx.getTransactionID();
-    // The comment above starting with "assert(enforce)" explains this assert.
-    XRPL_ASSERT(
-        enforce,
-        "xrpl::TransfersNotFrozen::validateFrozenState : enforce "
-        "invariant.");
-
-    if (enforce)
-    {
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidNewAccountRoot::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (!before && after->getType() == ltACCOUNT_ROOT)
-    {
-        accountsCreated_++;
-        accountSeq_ = (*after)[sfSequence];
-        pseudoAccount_ = isPseudoAccount(after);
-        flags_ = after->getFlags();
-    }
-}
-
-bool
-ValidNewAccountRoot::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (accountsCreated_ == 0)
-        return true;
-
-    if (accountsCreated_ > 1)
-    {
-        JLOG(j.fatal()) << "Invariant failed: multiple accounts "
-                           "created in a single transaction";
-        return false;
-    }
-
-    // From this point on we know exactly one account was created.
-    if (hasPrivilege(tx, createAcct | createPseudoAcct) && result == tesSUCCESS)
-    {
-        bool const pseudoAccount =
-            (pseudoAccount_ &&
-             (view.rules().enabled(featureSingleAssetVault) ||
-              view.rules().enabled(featureLendingProtocol)));
-
-        if (pseudoAccount && !hasPrivilege(tx, createPseudoAcct))
-        {
-            JLOG(j.fatal()) << "Invariant failed: pseudo-account created by a "
-                               "wrong transaction type";
-            return false;
-        }
-
-        std::uint32_t const startingSeq = pseudoAccount ? 0 : view.seq();
-
-        if (accountSeq_ != startingSeq)
-        {
-            JLOG(j.fatal()) << "Invariant failed: account created with "
-                               "wrong starting sequence number";
-            return false;
-        }
-
-        if (pseudoAccount)
-        {
-            std::uint32_t const expected = (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth);
-            if (flags_ != expected)
-            {
-                JLOG(j.fatal()) << "Invariant failed: pseudo-account created with "
-                                   "wrong flags";
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    JLOG(j.fatal()) << "Invariant failed: account root created illegally";
-    return false;
-}  // namespace xrpl
-
-//------------------------------------------------------------------------------
-
-void
-ValidNFTokenPage::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    static constexpr uint256 const& pageBits = nft::pageMask;
-    static constexpr uint256 const accountBits = ~pageBits;
-
-    if ((before && before->getType() != ltNFTOKEN_PAGE) ||
-        (after && after->getType() != ltNFTOKEN_PAGE))
-        return;
-
-    auto check = [this, isDelete](std::shared_ptr<SLE const> const& sle) {
-        uint256 const account = sle->key() & accountBits;
-        uint256 const hiLimit = sle->key() & pageBits;
-        std::optional<uint256> const prev = (*sle)[~sfPreviousPageMin];
-
-        // Make sure that any page links...
-        //  1. Are properly associated with the owning account and
-        //  2. The page is correctly ordered between links.
-        if (prev)
-        {
-            if (account != (*prev & accountBits))
-                badLink_ = true;
-
-            if (hiLimit <= (*prev & pageBits))
-                badLink_ = true;
-        }
-
-        if (auto const next = (*sle)[~sfNextPageMin])
-        {
-            if (account != (*next & accountBits))
-                badLink_ = true;
-
-            if (hiLimit >= (*next & pageBits))
-                badLink_ = true;
-        }
-
-        {
-            auto const& nftokens = sle->getFieldArray(sfNFTokens);
-
-            // An NFTokenPage should never contain too many tokens or be empty.
-            if (std::size_t const nftokenCount = nftokens.size();
-                (!isDelete && nftokenCount == 0) || nftokenCount > dirMaxTokensPerPage)
-                invalidSize_ = true;
-
-            // If prev is valid, use it to establish a lower bound for
-            // page entries.  If prev is not valid the lower bound is zero.
-            uint256 const loLimit = prev ? *prev & pageBits : uint256(beast::zero);
-
-            // Also verify that all NFTokenIDs in the page are sorted.
-            uint256 loCmp = loLimit;
-            for (auto const& obj : nftokens)
-            {
-                uint256 const tokenID = obj[sfNFTokenID];
-                if (!nft::compareTokens(loCmp, tokenID))
-                    badSort_ = true;
-                loCmp = tokenID;
-
-                // None of the NFTs on this page should belong on lower or
-                // higher pages.
-                if (uint256 const tokenPageBits = tokenID & pageBits;
-                    tokenPageBits < loLimit || tokenPageBits >= hiLimit)
-                    badEntry_ = true;
-
-                if (auto uri = obj[~sfURI]; uri && uri->empty())
-                    badURI_ = true;
-            }
-        }
-    };
-
-    if (before)
-    {
-        check(before);
-
-        // While an account's NFToken directory contains any NFTokens, the last
-        // NFTokenPage (with 96 bits of 1 in the low part of the index) should
-        // never be deleted.
-        if (isDelete && (before->key() & nft::pageMask) == nft::pageMask &&
-            before->isFieldPresent(sfPreviousPageMin))
-        {
-            deletedFinalPage_ = true;
-        }
-    }
-
-    if (after)
-        check(after);
-
-    if (!isDelete && before && after)
-    {
-        // If the NFTokenPage
-        //  1. Has a NextMinPage field in before, but loses it in after, and
-        //  2. This is not the last page in the directory
-        // Then we have identified a corruption in the links between the
-        // NFToken pages in the NFToken directory.
-        if ((before->key() & nft::pageMask) != nft::pageMask &&
-            before->isFieldPresent(sfNextPageMin) && !after->isFieldPresent(sfNextPageMin))
-        {
-            deletedLink_ = true;
-        }
-    }
-}
-
-bool
-ValidNFTokenPage::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (badLink_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: NFT page is improperly linked.";
-        return false;
-    }
-
-    if (badEntry_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: NFT found in incorrect page.";
-        return false;
-    }
-
-    if (badSort_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: NFTs on page are not sorted.";
-        return false;
-    }
-
-    if (badURI_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: NFT contains empty URI.";
-        return false;
-    }
-
-    if (invalidSize_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: NFT page has invalid size.";
-        return false;
-    }
-
-    if (view.rules().enabled(fixNFTokenPageLinks))
-    {
-        if (deletedFinalPage_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Last NFT page deleted with "
-                               "non-empty directory.";
-            return false;
-        }
-        if (deletedLink_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Lost NextMinPage link.";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-void
-NFTokenCountTracking::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (before && before->getType() == ltACCOUNT_ROOT)
-    {
-        beforeMintedTotal += (*before)[~sfMintedNFTokens].value_or(0);
-        beforeBurnedTotal += (*before)[~sfBurnedNFTokens].value_or(0);
-    }
-
-    if (after && after->getType() == ltACCOUNT_ROOT)
-    {
-        afterMintedTotal += (*after)[~sfMintedNFTokens].value_or(0);
-        afterBurnedTotal += (*after)[~sfBurnedNFTokens].value_or(0);
-    }
-}
-
-bool
-NFTokenCountTracking::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (!hasPrivilege(tx, changeNFTCounts))
-    {
-        if (beforeMintedTotal != afterMintedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: the number of minted tokens "
-                               "changed without a mint transaction!";
-            return false;
-        }
-
-        if (beforeBurnedTotal != afterBurnedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: the number of burned tokens "
-                               "changed without a burn transaction!";
-            return false;
-        }
-
-        return true;
-    }
-
-    if (tx.getTxnType() == ttNFTOKEN_MINT)
-    {
-        if (result == tesSUCCESS && beforeMintedTotal >= afterMintedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: successful minting didn't increase "
-                               "the number of minted tokens.";
-            return false;
-        }
-
-        if (result != tesSUCCESS && beforeMintedTotal != afterMintedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: failed minting changed the "
-                               "number of minted tokens.";
-            return false;
-        }
-
-        if (beforeBurnedTotal != afterBurnedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: minting changed the number of "
-                               "burned tokens.";
-            return false;
-        }
-    }
-
-    if (tx.getTxnType() == ttNFTOKEN_BURN)
-    {
-        if (result == tesSUCCESS)
-        {
-            if (beforeBurnedTotal >= afterBurnedTotal)
-            {
-                JLOG(j.fatal()) << "Invariant failed: successful burning didn't increase "
-                                   "the number of burned tokens.";
-                return false;
-            }
-        }
-
-        if (result != tesSUCCESS && beforeBurnedTotal != afterBurnedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: failed burning changed the "
-                               "number of burned tokens.";
-            return false;
-        }
-
-        if (beforeMintedTotal != afterMintedTotal)
-        {
-            JLOG(j.fatal()) << "Invariant failed: burning changed the number of "
-                               "minted tokens.";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidClawback::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const&)
-{
-    if (before && before->getType() == ltRIPPLE_STATE)
-        trustlinesChanged++;
-
-    if (before && before->getType() == ltMPTOKEN)
-        mptokensChanged++;
-}
-
-bool
-ValidClawback::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (tx.getTxnType() != ttCLAWBACK)
-        return true;
-
-    if (result == tesSUCCESS)
-    {
-        if (trustlinesChanged > 1)
-        {
-            JLOG(j.fatal()) << "Invariant failed: more than one trustline changed.";
-            return false;
-        }
-
-        if (mptokensChanged > 1)
-        {
-            JLOG(j.fatal()) << "Invariant failed: more than one mptokens changed.";
-            return false;
-        }
-
-        if (trustlinesChanged == 1)
-        {
-            AccountID const issuer = tx.getAccountID(sfAccount);
-            STAmount const& amount = tx.getFieldAmount(sfAmount);
-            AccountID const& holder = amount.getIssuer();
-            STAmount const holderBalance =
-                accountHolds(view, holder, amount.getCurrency(), issuer, fhIGNORE_FREEZE, j);
-
-            if (holderBalance.signum() < 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: trustline balance is negative";
-                return false;
-            }
-        }
-    }
-    else
-    {
-        if (trustlinesChanged != 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: some trustlines were changed "
-                               "despite failure of the transaction.";
-            return false;
-        }
-
-        if (mptokensChanged != 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: some mptokens were changed "
-                               "despite failure of the transaction.";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidMPTIssuance::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltMPTOKEN_ISSUANCE)
-    {
-        if (isDelete)
-            mptIssuancesDeleted_++;
-        else if (!before)
-            mptIssuancesCreated_++;
-    }
-
-    if (after && after->getType() == ltMPTOKEN)
-    {
-        if (isDelete)
-            mptokensDeleted_++;
-        else if (!before)
-        {
-            mptokensCreated_++;
-            MPTIssue const mptIssue{after->at(sfMPTokenIssuanceID)};
-            if (mptIssue.getIssuer() == after->at(sfAccount))
-                mptCreatedByIssuer_ = true;
-        }
-    }
-}
-
-bool
-ValidMPTIssuance::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const _fee,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (result == tesSUCCESS)
-    {
-        auto const& rules = view.rules();
-        [[maybe_unused]]
-        bool enforceCreatedByIssuer =
-            rules.enabled(featureSingleAssetVault) || rules.enabled(featureLendingProtocol);
-        if (mptCreatedByIssuer_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: MPToken created for the MPT issuer";
-            // The comment above starting with "assert(enforce)" explains this
-            // assert.
-            XRPL_ASSERT_PARTS(
-                enforceCreatedByIssuer, "xrpl::ValidMPTIssuance::finalize", "no issuer MPToken");
-            if (enforceCreatedByIssuer)
-                return false;
-        }
-
-        auto const txnType = tx.getTxnType();
-        if (hasPrivilege(tx, createMPTIssuance))
-        {
-            if (mptIssuancesCreated_ == 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: transaction "
-                                   "succeeded without creating a MPT issuance";
-            }
-            else if (mptIssuancesDeleted_ != 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: transaction "
-                                   "succeeded while removing MPT issuances";
-            }
-            else if (mptIssuancesCreated_ > 1)
-            {
-                JLOG(j.fatal()) << "Invariant failed: transaction "
-                                   "succeeded but created multiple issuances";
-            }
-
-            return mptIssuancesCreated_ == 1 && mptIssuancesDeleted_ == 0;
-        }
-
-        if (hasPrivilege(tx, destroyMPTIssuance))
-        {
-            if (mptIssuancesDeleted_ == 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
-                                   "succeeded without removing a MPT issuance";
-            }
-            else if (mptIssuancesCreated_ > 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
-                                   "succeeded while creating MPT issuances";
-            }
-            else if (mptIssuancesDeleted_ > 1)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
-                                   "succeeded but deleted multiple issuances";
-            }
-
-            return mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 1;
-        }
-
-        bool const lendingProtocolEnabled = view.rules().enabled(featureLendingProtocol);
-        // ttESCROW_FINISH may authorize an MPT, but it can't have the
-        // mayAuthorizeMPT privilege, because that may cause
-        // non-amendment-gated side effects.
-        bool const enforceEscrowFinish = (txnType == ttESCROW_FINISH) &&
-            (view.rules().enabled(featureSingleAssetVault) || lendingProtocolEnabled);
-        if (hasPrivilege(tx, mustAuthorizeMPT | mayAuthorizeMPT) || enforceEscrowFinish)
-        {
-            bool const submittedByIssuer = tx.isFieldPresent(sfHolder);
-
-            if (mptIssuancesCreated_ > 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize "
-                                   "succeeded but created MPT issuances";
-                return false;
-            }
-            else if (mptIssuancesDeleted_ > 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize "
-                                   "succeeded but deleted issuances";
-                return false;
-            }
-            else if (lendingProtocolEnabled && mptokensCreated_ + mptokensDeleted_ > 1)
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize succeeded "
-                                   "but created/deleted bad number mptokens";
-                return false;
-            }
-            else if (submittedByIssuer && (mptokensCreated_ > 0 || mptokensDeleted_ > 0))
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by issuer "
-                                   "succeeded but created/deleted mptokens";
-                return false;
-            }
-            else if (
-                !submittedByIssuer && hasPrivilege(tx, mustAuthorizeMPT) &&
-                (mptokensCreated_ + mptokensDeleted_ != 1))
-            {
-                // if the holder submitted this tx, then a mptoken must be
-                // either created or deleted.
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by holder "
-                                   "succeeded but created/deleted bad number of mptokens";
-                return false;
-            }
-
-            return true;
-        }
-        if (txnType == ttESCROW_FINISH)
-        {
-            // ttESCROW_FINISH may authorize an MPT, but it can't have the
-            // mayAuthorizeMPT privilege, because that may cause
-            // non-amendment-gated side effects.
-            XRPL_ASSERT_PARTS(
-                !enforceEscrowFinish, "xrpl::ValidMPTIssuance::finalize", "not escrow finish tx");
-            return true;
-        }
-
-        if (hasPrivilege(tx, mayDeleteMPT) && mptokensDeleted_ == 1 && mptokensCreated_ == 0 &&
-            mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 0)
-            return true;
-    }
-
-    if (mptIssuancesCreated_ != 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: a MPT issuance was created";
-    }
-    else if (mptIssuancesDeleted_ != 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: a MPT issuance was deleted";
-    }
-    else if (mptokensCreated_ != 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: a MPToken was created";
-    }
-    else if (mptokensDeleted_ != 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: a MPToken was deleted";
-    }
-
-    return mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 0 && mptokensCreated_ == 0 &&
-        mptokensDeleted_ == 0;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidPermissionedDomain::visitEntry(
-    bool isDel,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (before && before->getType() != ltPERMISSIONED_DOMAIN)
-        return;
-    if (after && after->getType() != ltPERMISSIONED_DOMAIN)
-        return;
-
-    auto check = [isDel](std::vector<SleStatus>& sleStatus, std::shared_ptr<SLE const> const& sle) {
-        auto const& credentials = sle->getFieldArray(sfAcceptedCredentials);
-        auto const sorted = credentials::makeSorted(credentials);
-
-        SleStatus ss{credentials.size(), false, !sorted.empty(), isDel};
-
-        // If array have duplicates then all the other checks are invalid
-        if (ss.isUnique_)
-        {
-            unsigned i = 0;
-            for (auto const& cred : sorted)
-            {
-                auto const& credTx = credentials[i++];
-                ss.isSorted_ =
-                    (cred.first == credTx[sfIssuer]) && (cred.second == credTx[sfCredentialType]);
-                if (!ss.isSorted_)
-                    break;
-            }
-        }
-        sleStatus.emplace_back(std::move(ss));
-    };
-
-    if (after)
-        check(sleStatus_, after);
-}
-
-bool
-ValidPermissionedDomain::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    auto check = [](SleStatus const& sleStatus, beast::Journal const& j) {
-        if (!sleStatus.credentialsSize_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: permissioned domain with "
-                               "no rules.";
-            return false;
-        }
-
-        if (sleStatus.credentialsSize_ > maxPermissionedDomainCredentialsArraySize)
-        {
-            JLOG(j.fatal()) << "Invariant failed: permissioned domain bad "
-                               "credentials size "
-                            << sleStatus.credentialsSize_;
-            return false;
-        }
-
-        if (!sleStatus.isUnique_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: permissioned domain credentials "
-                               "aren't unique";
-            return false;
-        }
-
-        if (!sleStatus.isSorted_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: permissioned domain credentials "
-                               "aren't sorted";
-            return false;
-        }
-
-        return true;
-    };
-
-    if (view.rules().enabled(fixPermissionedDomainInvariant))
-    {
-        // No permissioned domains should be affected if the transaction failed
-        if (result != tesSUCCESS)
-            // If nothing changed, all is good. If there were changes, that's
-            // bad.
-            return sleStatus_.empty();
-
-        if (sleStatus_.size() > 1)
-        {
-            JLOG(j.fatal()) << "Invariant failed: transaction affected more "
-                               "than 1 permissioned domain entry.";
-            return false;
-        }
-
-        switch (tx.getTxnType())
-        {
-            case ttPERMISSIONED_DOMAIN_SET: {
-                if (sleStatus_.empty())
-                {
-                    JLOG(j.fatal()) << "Invariant failed: no domain objects affected by "
-                                       "PermissionedDomainSet";
-                    return false;
-                }
-
-                auto const& sleStatus = sleStatus_[0];
-                if (sleStatus.isDelete_)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: domain object "
-                                       "deleted by PermissionedDomainSet";
-                    return false;
-                }
-                return check(sleStatus, j);
-            }
-            case ttPERMISSIONED_DOMAIN_DELETE: {
-                if (sleStatus_.empty())
-                {
-                    JLOG(j.fatal()) << "Invariant failed: no domain objects affected by "
-                                       "PermissionedDomainDelete";
-                    return false;
-                }
-
-                if (!sleStatus_[0].isDelete_)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: domain object "
-                                       "modified, but not deleted by "
-                                       "PermissionedDomainDelete";
-                    return false;
-                }
-                return true;
-            }
-            default: {
-                if (!sleStatus_.empty())
-                {
-                    JLOG(j.fatal()) << "Invariant failed: " << sleStatus_.size()
-                                    << " domain object(s) affected by an "
-                                       "unauthorized transaction. "
-                                    << tx.getTxnType();
-                    return false;
-                }
-                return true;
-            }
-        }
-    }
-    else
-    {
-        if (tx.getTxnType() != ttPERMISSIONED_DOMAIN_SET || result != tesSUCCESS ||
-            sleStatus_.empty())
-            return true;
-        return check(sleStatus_[0], j);
-    }
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidPseudoAccounts::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (isDelete)
-        // Deletion is ignored
-        return;
-
-    if (after && after->getType() == ltACCOUNT_ROOT)
-    {
-        bool const isPseudo = [&]() {
-            // isPseudoAccount checks that any of the pseudo-account fields are
-            // set.
-            if (isPseudoAccount(after))
-                return true;
-            // Not all pseudo-accounts have a zero sequence, but all accounts
-            // with a zero sequence had better be pseudo-accounts.
-            if (after->at(sfSequence) == 0)
-                return true;
-
-            return false;
-        }();
-        if (isPseudo)
-        {
-            // Pseudo accounts must have the following properties:
-            // 1. Exactly one of the pseudo-account fields is set.
-            // 2. The sequence number is not changed.
-            // 3. The lsfDisableMaster, lsfDefaultRipple, and lsfDepositAuth
-            // flags are set.
-            // 4. The RegularKey is not set.
-            {
-                std::vector<SField const*> const& fields = getPseudoAccountFields();
-
-                auto const numFields =
-                    std::count_if(fields.begin(), fields.end(), [&after](SField const* sf) -> bool {
-                        return after->isFieldPresent(*sf);
-                    });
-                if (numFields != 1)
-                {
-                    std::stringstream error;
-                    error << "pseudo-account has " << numFields << " pseudo-account fields set";
-                    errors_.emplace_back(error.str());
-                }
-            }
-            if (before && before->at(sfSequence) != after->at(sfSequence))
-            {
-                errors_.emplace_back("pseudo-account sequence changed");
-            }
-            if (!after->isFlag(lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth))
-            {
-                errors_.emplace_back("pseudo-account flags are not set");
-            }
-            if (after->isFieldPresent(sfRegularKey))
-            {
-                errors_.emplace_back("pseudo-account has a regular key");
-            }
-        }
-    }
-}
-
-bool
-ValidPseudoAccounts::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    bool const enforce = view.rules().enabled(featureSingleAssetVault);
-    XRPL_ASSERT(
-        errors_.empty() || enforce,
-        "xrpl::ValidPseudoAccounts::finalize : no bad "
-        "changes or enforce invariant");
-    if (!errors_.empty())
-    {
-        for (auto const& error : errors_)
-        {
-            JLOG(j.fatal()) << "Invariant failed: " << error;
-        }
-        if (enforce)
-            return false;
-    }
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidPermissionedDEX::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltDIR_NODE)
-    {
-        if (after->isFieldPresent(sfDomainID))
-            domains_.insert(after->getFieldH256(sfDomainID));
-    }
-
-    if (after && after->getType() == ltOFFER)
-    {
-        if (after->isFieldPresent(sfDomainID))
-            domains_.insert(after->getFieldH256(sfDomainID));
-        else
-            regularOffers_ = true;
-
-        // if a hybrid offer is missing domain or additional book, there's
-        // something wrong
-        if (after->isFlag(lsfHybrid) &&
-            (!after->isFieldPresent(sfDomainID) || !after->isFieldPresent(sfAdditionalBooks) ||
-             after->getFieldArray(sfAdditionalBooks).size() > 1))
-            badHybrids_ = true;
-    }
-}
-
-bool
-ValidPermissionedDEX::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    auto const txType = tx.getTxnType();
-    if ((txType != ttPAYMENT && txType != ttOFFER_CREATE) || result != tesSUCCESS)
-        return true;
-
-    // For each offercreate transaction, check if
-    // permissioned offers are valid
-    if (txType == ttOFFER_CREATE && badHybrids_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: hybrid offer is malformed";
-        return false;
-    }
-
-    if (!tx.isFieldPresent(sfDomainID))
-        return true;
-
-    auto const domain = tx.getFieldH256(sfDomainID);
-
-    if (!view.exists(keylet::permissionedDomain(domain)))
-    {
-        JLOG(j.fatal()) << "Invariant failed: domain doesn't exist";
-        return false;
-    }
-
-    // for both payment and offercreate, there shouldn't be another domain
-    // that's different from the domain specified
-    for (auto const& d : domains_)
-    {
-        if (d != domain)
-        {
-            JLOG(j.fatal()) << "Invariant failed: transaction"
-                               " consumed wrong domains";
-            return false;
-        }
-    }
-
-    if (regularOffers_)
-    {
-        JLOG(j.fatal()) << "Invariant failed: domain transaction"
-                           " affected regular offers";
-        return false;
-    }
-
-    return true;
-}
-
-void
-ValidAMM::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (isDelete)
-        return;
-
-    if (after)
-    {
-        auto const type = after->getType();
-        // AMM object changed
-        if (type == ltAMM)
-        {
-            ammAccount_ = after->getAccountID(sfAccount);
-            lptAMMBalanceAfter_ = after->getFieldAmount(sfLPTokenBalance);
-        }
-        // AMM pool changed
-        else if (
-            (type == ltRIPPLE_STATE && after->getFlags() & lsfAMMNode) ||
-            (type == ltACCOUNT_ROOT && after->isFieldPresent(sfAMMID)))
-        {
-            ammPoolChanged_ = true;
-        }
-    }
-
-    if (before)
-    {
-        // AMM object changed
-        if (before->getType() == ltAMM)
-        {
-            lptAMMBalanceBefore_ = before->getFieldAmount(sfLPTokenBalance);
-        }
-    }
-}
-
-static bool
-validBalances(
-    STAmount const& amount,
-    STAmount const& amount2,
-    STAmount const& lptAMMBalance,
-    ValidAMM::ZeroAllowed zeroAllowed)
-{
-    bool const positive =
-        amount > beast::zero && amount2 > beast::zero && lptAMMBalance > beast::zero;
-    if (zeroAllowed == ValidAMM::ZeroAllowed::Yes)
-        return positive ||
-            (amount == beast::zero && amount2 == beast::zero && lptAMMBalance == beast::zero);
-    return positive;
-}
-
-bool
-ValidAMM::finalizeVote(bool enforce, beast::Journal const& j) const
-{
-    if (lptAMMBalanceAfter_ != lptAMMBalanceBefore_ || ammPoolChanged_)
-    {
-        // LPTokens and the pool can not change on vote
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMMVote invariant failed: " << lptAMMBalanceBefore_.value_or(STAmount{})
-                        << " " << lptAMMBalanceAfter_.value_or(STAmount{}) << " "
-                        << ammPoolChanged_;
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeBid(bool enforce, beast::Journal const& j) const
-{
-    if (ammPoolChanged_)
-    {
-        // The pool can not change on bid
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMMBid invariant failed: pool changed";
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-    // LPTokens are burnt, therefore there should be fewer LPTokens
-    else if (
-        lptAMMBalanceBefore_ && lptAMMBalanceAfter_ &&
-        (*lptAMMBalanceAfter_ > *lptAMMBalanceBefore_ || *lptAMMBalanceAfter_ <= beast::zero))
-    {
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMMBid invariant failed: " << *lptAMMBalanceBefore_ << " "
-                        << *lptAMMBalanceAfter_;
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeCreate(
-    STTx const& tx,
-    ReadView const& view,
-    bool enforce,
-    beast::Journal const& j) const
-{
-    if (!ammAccount_)
-    {
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMMCreate invariant failed: AMM object is not created";
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-    else
-    {
-        auto const [amount, amount2] = ammPoolHolds(
-            view,
-            *ammAccount_,
-            tx[sfAmount].get<Issue>(),
-            tx[sfAmount2].get<Issue>(),
-            fhIGNORE_FREEZE,
-            j);
-        // Create invariant:
-        // sqrt(amount * amount2) == LPTokens
-        // all balances are greater than zero
-        if (!validBalances(amount, amount2, *lptAMMBalanceAfter_, ZeroAllowed::No) ||
-            ammLPTokens(amount, amount2, lptAMMBalanceAfter_->issue()) != *lptAMMBalanceAfter_)
-        {
-            JLOG(j.error()) << "AMMCreate invariant failed: " << amount << " " << amount2 << " "
-                            << *lptAMMBalanceAfter_;
-            if (enforce)
-                return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeDelete(bool enforce, TER res, beast::Journal const& j) const
-{
-    if (ammAccount_)
-    {
-        // LCOV_EXCL_START
-        std::string const msg = (res == tesSUCCESS) ? "AMM object is not deleted on tesSUCCESS"
-                                                    : "AMM object is changed on tecINCOMPLETE";
-        JLOG(j.error()) << "AMMDelete invariant failed: " << msg;
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeDEX(bool enforce, beast::Journal const& j) const
-{
-    if (ammAccount_)
-    {
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMM swap invariant failed: AMM object changed";
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::generalInvariant(
-    xrpl::STTx const& tx,
-    xrpl::ReadView const& view,
-    ZeroAllowed zeroAllowed,
-    beast::Journal const& j) const
-{
-    auto const [amount, amount2] = ammPoolHolds(
-        view,
-        *ammAccount_,
-        tx[sfAsset].get<Issue>(),
-        tx[sfAsset2].get<Issue>(),
-        fhIGNORE_FREEZE,
-        j);
-    // Deposit and Withdrawal invariant:
-    // sqrt(amount * amount2) >= LPTokens
-    // all balances are greater than zero
-    // unless on last withdrawal
-    auto const poolProductMean = root2(amount * amount2);
-    bool const nonNegativeBalances =
-        validBalances(amount, amount2, *lptAMMBalanceAfter_, zeroAllowed);
-    bool const strongInvariantCheck = poolProductMean >= *lptAMMBalanceAfter_;
-    // Allow for a small relative error if strongInvariantCheck fails
-    auto weakInvariantCheck = [&]() {
-        return *lptAMMBalanceAfter_ != beast::zero &&
-            withinRelativeDistance(poolProductMean, Number{*lptAMMBalanceAfter_}, Number{1, -11});
-    };
-    if (!nonNegativeBalances || (!strongInvariantCheck && !weakInvariantCheck()))
-    {
-        JLOG(j.error()) << "AMM " << tx.getTxnType()
-                        << " invariant failed: " << tx.getHash(HashPrefix::transactionID) << " "
-                        << ammPoolChanged_ << " " << amount << " " << amount2 << " "
-                        << poolProductMean << " " << lptAMMBalanceAfter_->getText() << " "
-                        << ((*lptAMMBalanceAfter_ == beast::zero)
-                                ? Number{1}
-                                : ((*lptAMMBalanceAfter_ - poolProductMean) / poolProductMean));
-        return false;
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeDeposit(
-    xrpl::STTx const& tx,
-    xrpl::ReadView const& view,
-    bool enforce,
-    beast::Journal const& j) const
-{
-    if (!ammAccount_)
-    {
-        // LCOV_EXCL_START
-        JLOG(j.error()) << "AMMDeposit invariant failed: AMM object is deleted";
-        if (enforce)
-            return false;
-        // LCOV_EXCL_STOP
-    }
-    else if (!generalInvariant(tx, view, ZeroAllowed::No, j) && enforce)
-        return false;
-
-    return true;
-}
-
-bool
-ValidAMM::finalizeWithdraw(
-    xrpl::STTx const& tx,
-    xrpl::ReadView const& view,
-    bool enforce,
-    beast::Journal const& j) const
-{
-    if (!ammAccount_)
-    {
-        // Last Withdraw or Clawback deleted AMM
-    }
-    else if (!generalInvariant(tx, view, ZeroAllowed::Yes, j))
-    {
-        if (enforce)
-            return false;
-    }
-
-    return true;
-}
-
-bool
-ValidAMM::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    // Delete may return tecINCOMPLETE if there are too many
-    // trustlines to delete.
-    if (result != tesSUCCESS && result != tecINCOMPLETE)
-        return true;
-
-    bool const enforce = view.rules().enabled(fixAMMv1_3);
-
-    switch (tx.getTxnType())
-    {
-        case ttAMM_CREATE:
-            return finalizeCreate(tx, view, enforce, j);
-        case ttAMM_DEPOSIT:
-            return finalizeDeposit(tx, view, enforce, j);
-        case ttAMM_CLAWBACK:
-        case ttAMM_WITHDRAW:
-            return finalizeWithdraw(tx, view, enforce, j);
-        case ttAMM_BID:
-            return finalizeBid(enforce, j);
-        case ttAMM_VOTE:
-            return finalizeVote(enforce, j);
-        case ttAMM_DELETE:
-            return finalizeDelete(enforce, result, j);
-        case ttCHECK_CASH:
-        case ttOFFER_CREATE:
-        case ttPAYMENT:
-            return finalizeDEX(enforce, j);
-        default:
-            break;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-NoModifiedUnmodifiableFields::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (isDelete || !before)
-        // Creation and deletion are ignored
-        return;
-
-    changedEntries_.emplace(before, after);
-}
-
-bool
-NoModifiedUnmodifiableFields::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    static auto const fieldChanged = [](auto const& before, auto const& after, auto const& field) {
-        bool const beforeField = before->isFieldPresent(field);
-        bool const afterField = after->isFieldPresent(field);
-        return beforeField != afterField || (afterField && before->at(field) != after->at(field));
-    };
-    for (auto const& slePair : changedEntries_)
-    {
-        auto const& before = slePair.first;
-        auto const& after = slePair.second;
-        auto const type = after->getType();
-        bool bad = false;
-        [[maybe_unused]] bool enforce = false;
-        switch (type)
-        {
-            case ltLOAN_BROKER:
-                /*
-                 * We check this invariant regardless of lending protocol
-                 * amendment status, allowing for detection and logging of
-                 * potential issues even when the amendment is disabled.
-                 */
-                enforce = view.rules().enabled(featureLendingProtocol);
-                bad = fieldChanged(before, after, sfLedgerEntryType) ||
-                    fieldChanged(before, after, sfLedgerIndex) ||
-                    fieldChanged(before, after, sfSequence) ||
-                    fieldChanged(before, after, sfOwnerNode) ||
-                    fieldChanged(before, after, sfVaultNode) ||
-                    fieldChanged(before, after, sfVaultID) ||
-                    fieldChanged(before, after, sfAccount) ||
-                    fieldChanged(before, after, sfOwner) ||
-                    fieldChanged(before, after, sfManagementFeeRate) ||
-                    fieldChanged(before, after, sfCoverRateMinimum) ||
-                    fieldChanged(before, after, sfCoverRateLiquidation);
-                break;
-            case ltLOAN:
-                /*
-                 * We check this invariant regardless of lending protocol
-                 * amendment status, allowing for detection and logging of
-                 * potential issues even when the amendment is disabled.
-                 */
-                enforce = view.rules().enabled(featureLendingProtocol);
-                bad = fieldChanged(before, after, sfLedgerEntryType) ||
-                    fieldChanged(before, after, sfLedgerIndex) ||
-                    fieldChanged(before, after, sfSequence) ||
-                    fieldChanged(before, after, sfOwnerNode) ||
-                    fieldChanged(before, after, sfLoanBrokerNode) ||
-                    fieldChanged(before, after, sfLoanBrokerID) ||
-                    fieldChanged(before, after, sfBorrower) ||
-                    fieldChanged(before, after, sfLoanOriginationFee) ||
-                    fieldChanged(before, after, sfLoanServiceFee) ||
-                    fieldChanged(before, after, sfLatePaymentFee) ||
-                    fieldChanged(before, after, sfClosePaymentFee) ||
-                    fieldChanged(before, after, sfOverpaymentFee) ||
-                    fieldChanged(before, after, sfInterestRate) ||
-                    fieldChanged(before, after, sfLateInterestRate) ||
-                    fieldChanged(before, after, sfCloseInterestRate) ||
-                    fieldChanged(before, after, sfOverpaymentInterestRate) ||
-                    fieldChanged(before, after, sfStartDate) ||
-                    fieldChanged(before, after, sfPaymentInterval) ||
-                    fieldChanged(before, after, sfGracePeriod) ||
-                    fieldChanged(before, after, sfLoanScale);
-                break;
-            default:
-                /*
-                 * We check this invariant regardless of lending protocol
-                 * amendment status, allowing for detection and logging of
-                 * potential issues even when the amendment is disabled.
-                 *
-                 * We use the lending protocol as a gate, even though
-                 * all transactions are affected because that's when it
-                 * was added.
-                 */
-                enforce = view.rules().enabled(featureLendingProtocol);
-                bad = fieldChanged(before, after, sfLedgerEntryType) ||
-                    fieldChanged(before, after, sfLedgerIndex);
-        }
-        XRPL_ASSERT(
-            !bad || enforce,
-            "xrpl::NoModifiedUnmodifiableFields::finalize : no bad "
-            "changes or enforce invariant");
-        if (bad)
-        {
-            JLOG(j.fatal()) << "Invariant failed: changed an unchangeable field for "
-                            << tx.getTransactionID();
-            if (enforce)
-                return false;
-        }
-    }
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidLoanBroker::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after)
-    {
-        if (after->getType() == ltLOAN_BROKER)
-        {
-            auto& broker = brokers_[after->key()];
-            broker.brokerBefore = before;
-            broker.brokerAfter = after;
-        }
-        else if (after->getType() == ltACCOUNT_ROOT && after->isFieldPresent(sfLoanBrokerID))
-        {
-            auto const& loanBrokerID = after->at(sfLoanBrokerID);
-            // create an entry if one doesn't already exist
-            brokers_.emplace(loanBrokerID, BrokerInfo{});
-        }
-        else if (after->getType() == ltRIPPLE_STATE)
-        {
-            lines_.emplace_back(after);
-        }
-        else if (after->getType() == ltMPTOKEN)
-        {
-            mpts_.emplace_back(after);
-        }
-    }
-}
-
-bool
-ValidLoanBroker::goodZeroDirectory(
-    ReadView const& view,
-    SLE::const_ref dir,
-    beast::Journal const& j) const
-{
-    auto const next = dir->at(~sfIndexNext);
-    auto const prev = dir->at(~sfIndexPrevious);
-    if ((prev && *prev) || (next && *next))
-    {
-        JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
-                           "OwnerCount has multiple directory pages";
-        return false;
-    }
-    auto indexes = dir->getFieldV256(sfIndexes);
-    if (indexes.size() > 1)
-    {
-        JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
-                           "OwnerCount has multiple indexes in the Directory root";
-        return false;
-    }
-    if (indexes.size() == 1)
-    {
-        auto const index = indexes.value().front();
-        auto const sle = view.read(keylet::unchecked(index));
-        if (!sle)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker directory corrupt";
-            return false;
-        }
-        if (sle->getType() != ltRIPPLE_STATE && sle->getType() != ltMPTOKEN)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
-                               "OwnerCount has an unexpected entry in the directory";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-ValidLoanBroker::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    // Loan Brokers will not exist on ledger if the Lending Protocol amendment
-    // is not enabled, so there's no need to check it.
-
-    for (auto const& line : lines_)
-    {
-        for (auto const& field : {&sfLowLimit, &sfHighLimit})
-        {
-            auto const account = view.read(keylet::account(line->at(*field).getIssuer()));
-            // This Invariant doesn't know about the rules for Trust Lines, so
-            // if the account is missing, don't treat it as an error. This
-            // loop is only concerned with finding Broker pseudo-accounts
-            if (account && account->isFieldPresent(sfLoanBrokerID))
-            {
-                auto const& loanBrokerID = account->at(sfLoanBrokerID);
-                // create an entry if one doesn't already exist
-                brokers_.emplace(loanBrokerID, BrokerInfo{});
-            }
-        }
-    }
-    for (auto const& mpt : mpts_)
-    {
-        auto const account = view.read(keylet::account(mpt->at(sfAccount)));
-        // This Invariant doesn't know about the rules for MPTokens, so
-        // if the account is missing, don't treat is as an error. This
-        // loop is only concerned with finding Broker pseudo-accounts
-        if (account && account->isFieldPresent(sfLoanBrokerID))
-        {
-            auto const& loanBrokerID = account->at(sfLoanBrokerID);
-            // create an entry if one doesn't already exist
-            brokers_.emplace(loanBrokerID, BrokerInfo{});
-        }
-    }
-
-    for (auto const& [brokerID, broker] : brokers_)
-    {
-        auto const& after =
-            broker.brokerAfter ? broker.brokerAfter : view.read(keylet::loanbroker(brokerID));
-
-        if (!after)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker missing";
-            return false;
-        }
-
-        auto const& before = broker.brokerBefore;
-
-        // https://github.com/Tapanito/XRPL-Standards/blob/xls-66-lending-protocol/XLS-0066d-lending-protocol/README.md#3123-invariants
-        // If `LoanBroker.OwnerCount = 0` the `DirectoryNode` will have at most
-        // one node (the root), which will only hold entries for `RippleState`
-        // or `MPToken` objects.
-        if (after->at(sfOwnerCount) == 0)
-        {
-            auto const dir = view.read(keylet::ownerDir(after->at(sfAccount)));
-            if (dir)
-            {
-                if (!goodZeroDirectory(view, dir, j))
-                {
-                    return false;
-                }
-            }
-        }
-        if (before && before->at(sfLoanSequence) > after->at(sfLoanSequence))
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker sequence number "
-                               "decreased";
-            return false;
-        }
-        if (after->at(sfDebtTotal) < 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker debt total is negative";
-            return false;
-        }
-        if (after->at(sfCoverAvailable) < 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker cover available is negative";
-            return false;
-        }
-        auto const vault = view.read(keylet::vault(after->at(sfVaultID)));
-        if (!vault)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker vault ID is invalid";
-            return false;
-        }
-        auto const& vaultAsset = vault->at(sfAsset);
-        if (after->at(sfCoverAvailable) < accountHolds(
-                                              view,
-                                              after->at(sfAccount),
-                                              vaultAsset,
-                                              FreezeHandling::fhIGNORE_FREEZE,
-                                              AuthHandling::ahIGNORE_AUTH,
-                                              j))
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Broker cover available "
-                               "is less than pseudo-account asset balance";
-            return false;
-        }
-    }
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
-void
-ValidLoan::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltLOAN)
-    {
-        loans_.emplace_back(before, after);
-    }
-}
-
-bool
-ValidLoan::finalize(
-    STTx const& tx,
-    TER const,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    // Loans will not exist on ledger if the Lending Protocol amendment
-    // is not enabled, so there's no need to check it.
-
-    for (auto const& [before, after] : loans_)
-    {
-        // https://github.com/Tapanito/XRPL-Standards/blob/xls-66-lending-protocol/XLS-0066d-lending-protocol/README.md#3223-invariants
-        // If `Loan.PaymentRemaining = 0` then the loan MUST be fully paid off
-        if (after->at(sfPaymentRemaining) == 0 &&
-            (after->at(sfTotalValueOutstanding) != beast::zero ||
-             after->at(sfPrincipalOutstanding) != beast::zero ||
-             after->at(sfManagementFeeOutstanding) != beast::zero))
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan with zero payments "
-                               "remaining has not been paid off";
-            return false;
-        }
-        // If `Loan.PaymentRemaining != 0` then the loan MUST NOT be fully paid
-        // off
-        if (after->at(sfPaymentRemaining) != 0 &&
-            after->at(sfTotalValueOutstanding) == beast::zero &&
-            after->at(sfPrincipalOutstanding) == beast::zero &&
-            after->at(sfManagementFeeOutstanding) == beast::zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan with zero payments "
-                               "remaining has not been paid off";
-            return false;
-        }
-        if (before && (before->isFlag(lsfLoanOverpayment) != after->isFlag(lsfLoanOverpayment)))
-        {
-            JLOG(j.fatal()) << "Invariant failed: Loan Overpayment flag changed";
-            return false;
-        }
-        // Must not be negative - STNumber
-        for (auto const field :
-             {&sfLoanServiceFee,
-              &sfLatePaymentFee,
-              &sfClosePaymentFee,
-              &sfPrincipalOutstanding,
-              &sfTotalValueOutstanding,
-              &sfManagementFeeOutstanding})
-        {
-            if (after->at(*field) < 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: " << field->getName() << " is negative ";
-                return false;
-            }
-        }
-        // Must be positive - STNumber
-        for (auto const field : {
-                 &sfPeriodicPayment,
-             })
-        {
-            if (after->at(*field) <= 0)
-            {
-                JLOG(j.fatal()) << "Invariant failed: " << field->getName()
-                                << " is zero or negative ";
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-ValidVault::Vault
-ValidVault::Vault::make(SLE const& from)
-{
-    XRPL_ASSERT(from.getType() == ltVAULT, "ValidVault::Vault::make : from Vault object");
-
-    ValidVault::Vault self;
-    self.key = from.key();
-    self.asset = from.at(sfAsset);
-    self.pseudoId = from.getAccountID(sfAccount);
-    self.owner = from.at(sfOwner);
-    self.shareMPTID = from.getFieldH192(sfShareMPTID);
-    self.assetsTotal = from.at(sfAssetsTotal);
-    self.assetsAvailable = from.at(sfAssetsAvailable);
-    self.assetsMaximum = from.at(sfAssetsMaximum);
-    self.lossUnrealized = from.at(sfLossUnrealized);
-    return self;
-}
-
-ValidVault::Shares
-ValidVault::Shares::make(SLE const& from)
-{
-    XRPL_ASSERT(
-        from.getType() == ltMPTOKEN_ISSUANCE,
-        "ValidVault::Shares::make : from MPTokenIssuance object");
-
-    ValidVault::Shares self;
-    self.share = MPTIssue(makeMptID(from.getFieldU32(sfSequence), from.getAccountID(sfIssuer)));
-    self.sharesTotal = from.at(sfOutstandingAmount);
-    self.sharesMaximum = from[~sfMaximumAmount].value_or(maxMPTokenAmount);
-    return self;
-}
-
-void
-ValidVault::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    // If `before` is empty, this means an object is being created, in which
-    // case `isDelete` must be false. Otherwise `before` and `after` are set and
-    // `isDelete` indicates whether an object is being deleted or modified.
-    XRPL_ASSERT(
-        after != nullptr && (before != nullptr || !isDelete),
-        "xrpl::ValidVault::visitEntry : some object is available");
-
-    // Number balanceDelta will capture the difference (delta) between "before"
-    // state (zero if created) and "after" state (zero if destroyed), so the
-    // invariants can validate that the change in account balances matches the
-    // change in vault balances, stored to deltas_ at the end of this function.
-    Number balanceDelta{};
-
-    std::int8_t sign = 0;
-    if (before)
-    {
-        switch (before->getType())
-        {
-            case ltVAULT:
-                beforeVault_.push_back(Vault::make(*before));
-                break;
-            case ltMPTOKEN_ISSUANCE:
-                // At this moment we have no way of telling if this object holds
-                // vault shares or something else. Save it for finalize.
-                beforeMPTs_.push_back(Shares::make(*before));
-                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
-                sign = 1;
-                break;
-            case ltMPTOKEN:
-                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
-                sign = -1;
-                break;
-            case ltACCOUNT_ROOT:
-            case ltRIPPLE_STATE:
-                balanceDelta = before->getFieldAmount(sfBalance);
-                sign = -1;
-                break;
-            default:;
-        }
-    }
-
-    if (!isDelete && after)
-    {
-        switch (after->getType())
-        {
-            case ltVAULT:
-                afterVault_.push_back(Vault::make(*after));
-                break;
-            case ltMPTOKEN_ISSUANCE:
-                // At this moment we have no way of telling if this object holds
-                // vault shares or something else. Save it for finalize.
-                afterMPTs_.push_back(Shares::make(*after));
-                balanceDelta -=
-                    Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
-                sign = 1;
-                break;
-            case ltMPTOKEN:
-                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
-                sign = -1;
-                break;
-            case ltACCOUNT_ROOT:
-            case ltRIPPLE_STATE:
-                balanceDelta -= Number(after->getFieldAmount(sfBalance));
-                sign = -1;
-                break;
-            default:;
-        }
-    }
-
-    uint256 const key = (before ? before->key() : after->key());
-    // Append to deltas if sign is non-zero, i.e. an object of an interesting
-    // type has been updated. A transaction may update an object even when
-    // its balance has not changed, e.g. transaction fee equals the amount
-    // transferred to the account. We intentionally do not compare balanceDelta
-    // against zero, to avoid missing such updates.
-    if (sign != 0)
-        deltas_[key] = balanceDelta * sign;
-}
-
-bool
-ValidVault::finalize(
-    STTx const& tx,
-    TER const ret,
-    XRPAmount const fee,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    bool const enforce = view.rules().enabled(featureSingleAssetVault);
-
-    if (!isTesSuccess(ret))
-        return true;  // Do not perform checks
-
-    if (afterVault_.empty() && beforeVault_.empty())
-    {
-        if (hasPrivilege(tx, mustModifyVault))
-        {
-            JLOG(j.fatal()) <<  //
-                "Invariant failed: vault operation succeeded without modifying "
-                "a vault";
-            XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault noop invariant");
-            return !enforce;
-        }
-
-        return true;  // Not a vault operation
-    }
-    else if (!(hasPrivilege(tx, mustModifyVault) || hasPrivilege(tx, mayModifyVault)))
-    {
-        JLOG(j.fatal()) <<  //
-            "Invariant failed: vault updated by a wrong transaction type";
-        XRPL_ASSERT(
-            enforce,
-            "xrpl::ValidVault::finalize : illegal vault transaction "
-            "invariant");
-        return !enforce;  // Also not a vault operation
-    }
-
-    if (beforeVault_.size() > 1 || afterVault_.size() > 1)
-    {
-        JLOG(j.fatal()) <<  //
-            "Invariant failed: vault operation updated more than single vault";
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : single vault invariant");
-        return !enforce;  // That's all we can do here
-    }
-
-    auto const txnType = tx.getTxnType();
-
-    // We do special handling for ttVAULT_DELETE first, because it's the only
-    // vault-modifying transaction without an "after" state of the vault
-    if (afterVault_.empty())
-    {
-        if (txnType != ttVAULT_DELETE)
-        {
-            JLOG(j.fatal()) <<  //
-                "Invariant failed: vault deleted by a wrong transaction type";
-            XRPL_ASSERT(
-                enforce,
-                "xrpl::ValidVault::finalize : illegal vault deletion "
-                "invariant");
-            return !enforce;  // That's all we can do here
-        }
-
-        // Note, if afterVault_ is empty then we know that beforeVault_ is not
-        // empty, as enforced at the top of this function
-        auto const& beforeVault = beforeVault_[0];
-
-        // At this moment we only know a vault is being deleted and there
-        // might be some MPTokenIssuance objects which are deleted in the
-        // same transaction. Find the one matching this vault.
-        auto const deletedShares = [&]() -> std::optional<Shares> {
-            for (auto const& e : beforeMPTs_)
-            {
-                if (e.share.getMptID() == beforeVault.shareMPTID)
-                    return std::move(e);
-            }
-            return std::nullopt;
-        }();
-
-        if (!deletedShares)
-        {
-            JLOG(j.fatal()) << "Invariant failed: deleted vault must also "
-                               "delete shares";
-            XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : shares deletion invariant");
-            return !enforce;  // That's all we can do here
-        }
-
-        bool result = true;
-        if (deletedShares->sharesTotal != 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
-                               "shares outstanding";
-            result = false;
-        }
-        if (beforeVault.assetsTotal != zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
-                               "assets outstanding";
-            result = false;
-        }
-        if (beforeVault.assetsAvailable != zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
-                               "assets available";
-            result = false;
-        }
-
-        return result;
-    }
-    else if (txnType == ttVAULT_DELETE)
-    {
-        JLOG(j.fatal()) << "Invariant failed: vault deletion succeeded without "
-                           "deleting a vault";
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault deletion invariant");
-        return !enforce;  // That's all we can do here
-    }
-
-    // Note, `afterVault_.empty()` is handled above
-    auto const& afterVault = afterVault_[0];
-    XRPL_ASSERT(
-        beforeVault_.empty() || beforeVault_[0].key == afterVault.key,
-        "xrpl::ValidVault::finalize : single vault operation");
-
-    auto const updatedShares = [&]() -> std::optional<Shares> {
-        // At this moment we only know that a vault is being updated and there
-        // might be some MPTokenIssuance objects which are also updated in the
-        // same transaction. Find the one matching the shares to this vault.
-        // Note, we expect updatedMPTs collection to be extremely small. For
-        // such collections linear search is faster than lookup.
-        for (auto const& e : afterMPTs_)
-        {
-            if (e.share.getMptID() == afterVault.shareMPTID)
-                return e;
-        }
-
-        auto const sleShares = view.read(keylet::mptIssuance(afterVault.shareMPTID));
-
-        return sleShares ? std::optional<Shares>(Shares::make(*sleShares)) : std::nullopt;
-    }();
-
-    bool result = true;
-
-    // Universal transaction checks
-    if (!beforeVault_.empty())
-    {
-        auto const& beforeVault = beforeVault_[0];
-        if (afterVault.asset != beforeVault.asset || afterVault.pseudoId != beforeVault.pseudoId ||
-            afterVault.shareMPTID != beforeVault.shareMPTID)
-        {
-            JLOG(j.fatal()) << "Invariant failed: violation of vault immutable data";
-            result = false;
-        }
-    }
-
-    if (!updatedShares)
-    {
-        JLOG(j.fatal()) << "Invariant failed: updated vault must have shares";
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault has shares invariant");
-        return !enforce;  // That's all we can do here
-    }
-
-    if (updatedShares->sharesTotal == 0)
-    {
-        if (afterVault.assetsTotal != zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: updated zero sized "
-                               "vault must have no assets outstanding";
-            result = false;
-        }
-        if (afterVault.assetsAvailable != zero)
-        {
-            JLOG(j.fatal()) << "Invariant failed: updated zero sized "
-                               "vault must have no assets available";
-            result = false;
-        }
-    }
-    else if (updatedShares->sharesTotal > updatedShares->sharesMaximum)
-    {
-        JLOG(j.fatal())  //
-            << "Invariant failed: updated shares must not exceed maximum "
-            << updatedShares->sharesMaximum;
-        result = false;
-    }
-
-    if (afterVault.assetsAvailable < zero)
-    {
-        JLOG(j.fatal()) << "Invariant failed: assets available must be positive";
-        result = false;
-    }
-
-    if (afterVault.assetsAvailable > afterVault.assetsTotal)
-    {
-        JLOG(j.fatal()) << "Invariant failed: assets available must "
-                           "not be greater than assets outstanding";
-        result = false;
-    }
-    else if (afterVault.lossUnrealized > afterVault.assetsTotal - afterVault.assetsAvailable)
-    {
-        JLOG(j.fatal())  //
-            << "Invariant failed: loss unrealized must not exceed "
-               "the difference between assets outstanding and available";
-        result = false;
-    }
-
-    if (afterVault.assetsTotal < zero)
-    {
-        JLOG(j.fatal()) << "Invariant failed: assets outstanding must be positive";
-        result = false;
-    }
-
-    if (afterVault.assetsMaximum < zero)
-    {
-        JLOG(j.fatal()) << "Invariant failed: assets maximum must be positive";
-        result = false;
-    }
-
-    // Thanks to this check we can simply do `assert(!beforeVault_.empty()` when
-    // enforcing invariants on transaction types other than ttVAULT_CREATE
-    if (beforeVault_.empty() && txnType != ttVAULT_CREATE)
-    {
-        JLOG(j.fatal()) <<  //
-            "Invariant failed: vault created by a wrong transaction type";
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault creation invariant");
-        return !enforce;  // That's all we can do here
-    }
-
-    if (!beforeVault_.empty() && afterVault.lossUnrealized != beforeVault_[0].lossUnrealized &&
-        txnType != ttLOAN_MANAGE && txnType != ttLOAN_PAY)
-    {
-        JLOG(j.fatal()) <<  //
-            "Invariant failed: vault transaction must not change loss "
-            "unrealized";
-        result = false;
-    }
-
-    auto const beforeShares = [&]() -> std::optional<Shares> {
-        if (beforeVault_.empty())
-            return std::nullopt;
-        auto const& beforeVault = beforeVault_[0];
-
-        for (auto const& e : beforeMPTs_)
-        {
-            if (e.share.getMptID() == beforeVault.shareMPTID)
-                return std::move(e);
-        }
-        return std::nullopt;
-    }();
-
-    if (!beforeShares &&
-        (tx.getTxnType() == ttVAULT_DEPOSIT ||   //
-         tx.getTxnType() == ttVAULT_WITHDRAW ||  //
-         tx.getTxnType() == ttVAULT_CLAWBACK))
-    {
-        JLOG(j.fatal()) << "Invariant failed: vault operation succeeded "
-                           "without updating shares";
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : shares noop invariant");
-        return !enforce;  // That's all we can do here
-    }
-
-    auto const& vaultAsset = afterVault.asset;
-    auto const deltaAssets = [&](AccountID const& id) -> std::optional<Number> {
-        auto const get =  //
-            [&](auto const& it, std::int8_t sign = 1) -> std::optional<Number> {
-            if (it == deltas_.end())
-                return std::nullopt;
-
-            return it->second * sign;
-        };
-
-        return std::visit(
-            [&]<typename TIss>(TIss const& issue) {
-                if constexpr (std::is_same_v<TIss, Issue>)
-                {
-                    if (isXRP(issue))
-                        return get(deltas_.find(keylet::account(id).key));
-                    return get(
-                        deltas_.find(keylet::line(id, issue).key), id > issue.getIssuer() ? -1 : 1);
-                }
-                else if constexpr (std::is_same_v<TIss, MPTIssue>)
-                {
-                    return get(deltas_.find(keylet::mptoken(issue.getMptID(), id).key));
-                }
-            },
-            vaultAsset.value());
-    };
-    auto const deltaAssetsTxAccount = [&]() -> std::optional<Number> {
-        auto ret = deltaAssets(tx[sfAccount]);
-        // Nothing returned or not XRP transaction
-        if (!ret.has_value() || !vaultAsset.native())
-            return ret;
-
-        // Delegated transaction; no need to compensate for fees
-        if (auto const delegate = tx[~sfDelegate];
-            delegate.has_value() && *delegate != tx[sfAccount])
-            return ret;
-
-        *ret += fee.drops();
-        if (*ret == zero)
-            return std::nullopt;
-
-        return ret;
-    };
-    auto const deltaShares = [&](AccountID const& id) -> std::optional<Number> {
-        auto const it = [&]() {
-            if (id == afterVault.pseudoId)
-                return deltas_.find(keylet::mptIssuance(afterVault.shareMPTID).key);
-            return deltas_.find(keylet::mptoken(afterVault.shareMPTID, id).key);
-        }();
-
-        return it != deltas_.end() ? std::optional<Number>(it->second) : std::nullopt;
-    };
-
-    auto const vaultHoldsNoAssets = [&](Vault const& vault) {
-        return vault.assetsAvailable == 0 && vault.assetsTotal == 0;
-    };
-
-    // Technically this does not need to be a lambda, but it's more
-    // convenient thanks to early "return false"; the not-so-nice
-    // alternatives are several layers of nested if/else or more complex
-    // (i.e. brittle) if statements.
-    result &= [&]() {
-        switch (txnType)
-        {
-            case ttVAULT_CREATE: {
-                bool result = true;
-
-                if (!beforeVault_.empty())
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: create operation must not have "
-                           "updated a vault";
-                    result = false;
-                }
-
-                if (afterVault.assetsAvailable != zero || afterVault.assetsTotal != zero ||
-                    afterVault.lossUnrealized != zero || updatedShares->sharesTotal != 0)
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: created vault must be empty";
-                    result = false;
-                }
-
-                if (afterVault.pseudoId != updatedShares->share.getIssuer())
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: shares issuer and vault "
-                           "pseudo-account must be the same";
-                    result = false;
-                }
-
-                auto const sleSharesIssuer =
-                    view.read(keylet::account(updatedShares->share.getIssuer()));
-                if (!sleSharesIssuer)
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: shares issuer must exist";
-                    return false;
-                }
-
-                if (!isPseudoAccount(sleSharesIssuer))
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: shares issuer must be a "
-                           "pseudo-account";
-                    result = false;
-                }
-
-                if (auto const vaultId = (*sleSharesIssuer)[~sfVaultID];
-                    !vaultId || *vaultId != afterVault.key)
-                {
-                    JLOG(j.fatal())  //
-                        << "Invariant failed: shares issuer pseudo-account "
-                           "must point back to the vault";
-                    result = false;
-                }
-
-                return result;
-            }
-            case ttVAULT_SET: {
-                bool result = true;
-
-                XRPL_ASSERT(
-                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : set updated a vault");
-                auto const& beforeVault = beforeVault_[0];
-
-                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                if (vaultDeltaAssets)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: set must not change vault balance";
-                    result = false;
-                }
-
-                if (beforeVault.assetsTotal != afterVault.assetsTotal)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: set must not change assets "
-                        "outstanding";
-                    result = false;
-                }
-
-                if (afterVault.assetsMaximum > zero &&
-                    afterVault.assetsTotal > afterVault.assetsMaximum)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: set assets outstanding must not "
-                        "exceed assets maximum";
-                    result = false;
-                }
-
-                if (beforeVault.assetsAvailable != afterVault.assetsAvailable)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: set must not change assets "
-                        "available";
-                    result = false;
-                }
-
-                if (beforeShares && updatedShares &&
-                    beforeShares->sharesTotal != updatedShares->sharesTotal)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: set must not change shares "
-                        "outstanding";
-                    result = false;
-                }
-
-                return result;
-            }
-            case ttVAULT_DEPOSIT: {
-                bool result = true;
-
-                XRPL_ASSERT(
-                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : deposit updated a vault");
-                auto const& beforeVault = beforeVault_[0];
-
-                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-
-                if (!vaultDeltaAssets)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must change vault balance";
-                    return false;  // That's all we can do
-                }
-
-                if (*vaultDeltaAssets > tx[sfAmount])
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must not change vault "
-                        "balance by more than deposited amount";
-                    result = false;
-                }
-
-                if (*vaultDeltaAssets <= zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must increase vault balance";
-                    result = false;
-                }
-
-                // Any payments (including deposits) made by the issuer
-                // do not change their balance, but create funds instead.
-                bool const issuerDeposit = [&]() -> bool {
-                    if (vaultAsset.native())
-                        return false;
-                    return tx[sfAccount] == vaultAsset.getIssuer();
-                }();
-
-                if (!issuerDeposit)
-                {
-                    auto const accountDeltaAssets = deltaAssetsTxAccount();
-                    if (!accountDeltaAssets)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: deposit must change depositor "
-                            "balance";
-                        return false;
-                    }
-
-                    if (*accountDeltaAssets >= zero)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: deposit must decrease depositor "
-                            "balance";
-                        result = false;
-                    }
-
-                    if (*accountDeltaAssets * -1 != *vaultDeltaAssets)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: deposit must change vault and "
-                            "depositor balance by equal amount";
-                        result = false;
-                    }
-                }
-
-                if (afterVault.assetsMaximum > zero &&
-                    afterVault.assetsTotal > afterVault.assetsMaximum)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit assets outstanding must not "
-                        "exceed assets maximum";
-                    result = false;
-                }
-
-                auto const accountDeltaShares = deltaShares(tx[sfAccount]);
-                if (!accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must change depositor "
-                        "shares";
-                    return false;  // That's all we can do
-                }
-
-                if (*accountDeltaShares <= zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must increase depositor "
-                        "shares";
-                    result = false;
-                }
-
-                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                if (!vaultDeltaShares || *vaultDeltaShares == zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must change vault shares";
-                    return false;  // That's all we can do
-                }
-
-                if (*vaultDeltaShares * -1 != *accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: deposit must change depositor and "
-                        "vault shares by equal amount";
-                    result = false;
-                }
-
-                if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: deposit and assets "
-                                       "outstanding must add up";
-                    result = false;
-                }
-                if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: deposit and assets "
-                                       "available must add up";
-                    result = false;
-                }
-
-                return result;
-            }
-            case ttVAULT_WITHDRAW: {
-                bool result = true;
-
-                XRPL_ASSERT(
-                    !beforeVault_.empty(),
-                    "xrpl::ValidVault::finalize : withdrawal updated a "
-                    "vault");
-                auto const& beforeVault = beforeVault_[0];
-
-                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-
-                if (!vaultDeltaAssets)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: withdrawal must "
-                                       "change vault balance";
-                    return false;  // That's all we can do
-                }
-
-                if (*vaultDeltaAssets >= zero)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: withdrawal must "
-                                       "decrease vault balance";
-                    result = false;
-                }
-
-                // Any payments (including withdrawal) going to the issuer
-                // do not change their balance, but destroy funds instead.
-                bool const issuerWithdrawal = [&]() -> bool {
-                    if (vaultAsset.native())
-                        return false;
-                    auto const destination = tx[~sfDestination].value_or(tx[sfAccount]);
-                    return destination == vaultAsset.getIssuer();
-                }();
-
-                if (!issuerWithdrawal)
-                {
-                    auto const accountDeltaAssets = deltaAssetsTxAccount();
-                    auto const otherAccountDelta = [&]() -> std::optional<Number> {
-                        if (auto const destination = tx[~sfDestination];
-                            destination && *destination != tx[sfAccount])
-                            return deltaAssets(*destination);
-                        return std::nullopt;
-                    }();
-
-                    if (accountDeltaAssets.has_value() == otherAccountDelta.has_value())
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: withdrawal must change one "
-                            "destination balance";
-                        return false;
-                    }
-
-                    auto const destinationDelta =  //
-                        accountDeltaAssets ? *accountDeltaAssets : *otherAccountDelta;
-
-                    if (destinationDelta <= zero)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: withdrawal must increase "
-                            "destination balance";
-                        result = false;
-                    }
-
-                    if (*vaultDeltaAssets * -1 != destinationDelta)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: withdrawal must change vault "
-                            "and destination balance by equal amount";
-                        result = false;
-                    }
-                }
-
-                auto const accountDeltaShares = deltaShares(tx[sfAccount]);
-                if (!accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: withdrawal must change depositor "
-                        "shares";
-                    return false;
-                }
-
-                if (*accountDeltaShares >= zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: withdrawal must decrease depositor "
-                        "shares";
-                    result = false;
-                }
-
-                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                if (!vaultDeltaShares || *vaultDeltaShares == zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: withdrawal must change vault shares";
-                    return false;  // That's all we can do
-                }
-
-                if (*vaultDeltaShares * -1 != *accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: withdrawal must change depositor "
-                        "and vault shares by equal amount";
-                    result = false;
-                }
-
-                // Note, vaultBalance is negative (see check above)
-                if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: withdrawal and "
-                                       "assets outstanding must add up";
-                    result = false;
-                }
-
-                if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
-                {
-                    JLOG(j.fatal()) << "Invariant failed: withdrawal and "
-                                       "assets available must add up";
-                    result = false;
-                }
-
-                return result;
-            }
-            case ttVAULT_CLAWBACK: {
-                bool result = true;
-
-                XRPL_ASSERT(
-                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : clawback updated a vault");
-                auto const& beforeVault = beforeVault_[0];
-
-                if (vaultAsset.native() || vaultAsset.getIssuer() != tx[sfAccount])
-                {
-                    // The owner can use clawback to force-burn shares when the
-                    // vault is empty but there are outstanding shares
-                    if (!(beforeShares && beforeShares->sharesTotal > 0 &&
-                          vaultHoldsNoAssets(beforeVault) && beforeVault.owner == tx[sfAccount]))
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: clawback may only be performed "
-                            "by the asset issuer, or by the vault owner of an "
-                            "empty vault";
-                        return false;  // That's all we can do
-                    }
-                }
-
-                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                if (vaultDeltaAssets)
-                {
-                    if (*vaultDeltaAssets >= zero)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: clawback must decrease vault "
-                            "balance";
-                        result = false;
-                    }
-
-                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: clawback and assets outstanding "
-                            "must add up";
-                        result = false;
-                    }
-
-                    if (beforeVault.assetsAvailable + *vaultDeltaAssets !=
-                        afterVault.assetsAvailable)
-                    {
-                        JLOG(j.fatal()) <<  //
-                            "Invariant failed: clawback and assets available "
-                            "must add up";
-                        result = false;
-                    }
-                }
-                else if (!vaultHoldsNoAssets(beforeVault))
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: clawback must change vault balance";
-                    return false;  // That's all we can do
-                }
-
-                auto const accountDeltaShares = deltaShares(tx[sfHolder]);
-                if (!accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: clawback must change holder shares";
-                    return false;  // That's all we can do
-                }
-
-                if (*accountDeltaShares >= zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: clawback must decrease holder "
-                        "shares";
-                    result = false;
-                }
-
-                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                if (!vaultDeltaShares || *vaultDeltaShares == zero)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: clawback must change vault shares";
-                    return false;  // That's all we can do
-                }
-
-                if (*vaultDeltaShares * -1 != *accountDeltaShares)
-                {
-                    JLOG(j.fatal()) <<  //
-                        "Invariant failed: clawback must change holder and "
-                        "vault shares by equal amount";
-                    result = false;
-                }
-
-                return result;
-            }
-
-            case ttLOAN_SET:
-            case ttLOAN_MANAGE:
-            case ttLOAN_PAY: {
-                // TBD
-                return true;
-            }
-
-            default:
-                // LCOV_EXCL_START
-                UNREACHABLE("xrpl::ValidVault::finalize : unknown transaction type");
-                return false;
-                // LCOV_EXCL_STOP
-        }
-    }();
-
-    if (!result)
-    {
-        // The comment at the top of this file starting with "assert(enforce)"
-        // explains this assert.
-        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault invariants");
-        return !enforce;
-    }
-
-    return true;
-}
-
-}  // namespace xrpl
diff --git a/src/libxrpl/tx/Transactor.cpp b/src/libxrpl/tx/Transactor.cpp
index 25171b055a..5f2efc9e1c 100644
--- a/src/libxrpl/tx/Transactor.cpp
+++ b/src/libxrpl/tx/Transactor.cpp
@@ -14,8 +14,8 @@
 #include <xrpl/tx/SignerEntries.h>
 #include <xrpl/tx/Transactor.h>
 #include <xrpl/tx/apply.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
@@ -356,8 +356,7 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee)
     if (feePaid == beast::zero)
         return tesSUCCESS;
 
-    auto const id = ctx.tx.isFieldPresent(sfDelegate) ? ctx.tx.getAccountID(sfDelegate)
-                                                      : ctx.tx.getAccountID(sfAccount);
+    auto const id = ctx.tx.getFeePayer();
     auto const sle = ctx.view.read(keylet::account(id));
     if (!sle)
         return terNO_ACCOUNT;
@@ -386,32 +385,18 @@ Transactor::payFee()
 {
     auto const feePaid = ctx_.tx[sfFee].xrp();
 
-    if (ctx_.tx.isFieldPresent(sfDelegate))
-    {
-        // Delegated transactions are paid by the delegated account.
-        auto const delegate = ctx_.tx.getAccountID(sfDelegate);
-        auto const delegatedSle = view().peek(keylet::account(delegate));
-        if (!delegatedSle)
-            return tefINTERNAL;  // LCOV_EXCL_LINE
+    auto const feePayer = ctx_.tx.getFeePayer();
+    auto const sle = view().peek(keylet::account(feePayer));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
 
-        delegatedSle->setFieldAmount(sfBalance, delegatedSle->getFieldAmount(sfBalance) - feePaid);
-        view().update(delegatedSle);
-    }
-    else
-    {
-        auto const sle = view().peek(keylet::account(account_));
-        if (!sle)
-            return tefINTERNAL;  // LCOV_EXCL_LINE
-
-        // Deduct the fee, so it's not available during the transaction.
-        // Will only write the account back if the transaction succeeds.
-
-        mSourceBalance -= feePaid;
-        sle->setFieldAmount(sfBalance, mSourceBalance);
-
-        // VFALCO Should we call view().rawDestroyXRP() here as well?
-    }
+    // Deduct the fee, so it's not available during the transaction.
+    // Will only write the account back if the transaction succeeds.
+    sle->setFieldAmount(sfBalance, sle->getFieldAmount(sfBalance) - feePaid);
+    if (feePayer != account_)
+        view().update(sle);  // done in `apply()` for the account
 
+    // VFALCO Should we call view().rawDestroyXRP() here as well?
     return tesSUCCESS;
 }
 
@@ -610,8 +595,7 @@ Transactor::apply()
 
     if (sle)
     {
-        mPriorBalance = STAmount{(*sle)[sfBalance]}.xrp();
-        mSourceBalance = mPriorBalance;
+        preFeeBalance_ = STAmount{(*sle)[sfBalance]}.xrp();
 
         TER result = consumeSeqProxy(sle);
         if (result != tesSUCCESS)
@@ -983,9 +967,7 @@ Transactor::reset(XRPAmount fee)
     if (!txnAcct)
         return {tefINTERNAL, beast::zero};
 
-    auto const payerSle = ctx_.tx.isFieldPresent(sfDelegate)
-        ? view().peek(keylet::account(ctx_.tx.getAccountID(sfDelegate)))
-        : txnAcct;
+    auto const payerSle = view().peek(keylet::account(ctx_.tx.getFeePayer()));
     if (!payerSle)
         return {tefINTERNAL, beast::zero};  // LCOV_EXCL_LINE
 
diff --git a/src/libxrpl/tx/apply.cpp b/src/libxrpl/tx/apply.cpp
index 9ff1d4b473..91b5c9dd37 100644
--- a/src/libxrpl/tx/apply.cpp
+++ b/src/libxrpl/tx/apply.cpp
@@ -132,7 +132,7 @@ applyBatchTransactions(
     auto const parentBatchId = batchTxn.getTransactionID();
     auto const mode = batchTxn.getFlags();
 
-    auto applyOneTransaction = [&registry, &j, &parentBatchId, &batchView](STTx&& tx) {
+    auto applyOneTransaction = [&registry, &j, &parentBatchId, &batchView](STTx const& tx) {
         OpenView perTxBatchView(batch_view, batchView);
 
         auto const ret = apply(registry, perTxBatchView, parentBatchId, tx, tapBATCH, j);
diff --git a/src/libxrpl/tx/invariants/AMMInvariant.cpp b/src/libxrpl/tx/invariants/AMMInvariant.cpp
new file mode 100644
index 0000000000..60d05f298c
--- /dev/null
+++ b/src/libxrpl/tx/invariants/AMMInvariant.cpp
@@ -0,0 +1,305 @@
+#include <xrpl/tx/invariants/AMMInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
+
+namespace xrpl {
+
+void
+ValidAMM::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (isDelete)
+        return;
+
+    if (after)
+    {
+        auto const type = after->getType();
+        // AMM object changed
+        if (type == ltAMM)
+        {
+            ammAccount_ = after->getAccountID(sfAccount);
+            lptAMMBalanceAfter_ = after->getFieldAmount(sfLPTokenBalance);
+        }
+        // AMM pool changed
+        else if (
+            (type == ltRIPPLE_STATE && after->getFlags() & lsfAMMNode) ||
+            (type == ltACCOUNT_ROOT && after->isFieldPresent(sfAMMID)))
+        {
+            ammPoolChanged_ = true;
+        }
+    }
+
+    if (before)
+    {
+        // AMM object changed
+        if (before->getType() == ltAMM)
+        {
+            lptAMMBalanceBefore_ = before->getFieldAmount(sfLPTokenBalance);
+        }
+    }
+}
+
+static bool
+validBalances(
+    STAmount const& amount,
+    STAmount const& amount2,
+    STAmount const& lptAMMBalance,
+    ValidAMM::ZeroAllowed zeroAllowed)
+{
+    bool const positive =
+        amount > beast::zero && amount2 > beast::zero && lptAMMBalance > beast::zero;
+    if (zeroAllowed == ValidAMM::ZeroAllowed::Yes)
+        return positive ||
+            (amount == beast::zero && amount2 == beast::zero && lptAMMBalance == beast::zero);
+    return positive;
+}
+
+bool
+ValidAMM::finalizeVote(bool enforce, beast::Journal const& j) const
+{
+    if (lptAMMBalanceAfter_ != lptAMMBalanceBefore_ || ammPoolChanged_)
+    {
+        // LPTokens and the pool can not change on vote
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMMVote invariant failed: " << lptAMMBalanceBefore_.value_or(STAmount{})
+                        << " " << lptAMMBalanceAfter_.value_or(STAmount{}) << " "
+                        << ammPoolChanged_;
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeBid(bool enforce, beast::Journal const& j) const
+{
+    if (ammPoolChanged_)
+    {
+        // The pool can not change on bid
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMMBid invariant failed: pool changed";
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+    // LPTokens are burnt, therefore there should be fewer LPTokens
+    else if (
+        lptAMMBalanceBefore_ && lptAMMBalanceAfter_ &&
+        (*lptAMMBalanceAfter_ > *lptAMMBalanceBefore_ || *lptAMMBalanceAfter_ <= beast::zero))
+    {
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMMBid invariant failed: " << *lptAMMBalanceBefore_ << " "
+                        << *lptAMMBalanceAfter_;
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeCreate(
+    STTx const& tx,
+    ReadView const& view,
+    bool enforce,
+    beast::Journal const& j) const
+{
+    if (!ammAccount_)
+    {
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMMCreate invariant failed: AMM object is not created";
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+    else
+    {
+        auto const [amount, amount2] = ammPoolHolds(
+            view,
+            *ammAccount_,
+            tx[sfAmount].get<Issue>(),
+            tx[sfAmount2].get<Issue>(),
+            fhIGNORE_FREEZE,
+            j);
+        // Create invariant:
+        // sqrt(amount * amount2) == LPTokens
+        // all balances are greater than zero
+        if (!validBalances(amount, amount2, *lptAMMBalanceAfter_, ZeroAllowed::No) ||
+            ammLPTokens(amount, amount2, lptAMMBalanceAfter_->issue()) != *lptAMMBalanceAfter_)
+        {
+            JLOG(j.error()) << "AMMCreate invariant failed: " << amount << " " << amount2 << " "
+                            << *lptAMMBalanceAfter_;
+            if (enforce)
+                return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeDelete(bool enforce, TER res, beast::Journal const& j) const
+{
+    if (ammAccount_)
+    {
+        // LCOV_EXCL_START
+        std::string const msg = (res == tesSUCCESS) ? "AMM object is not deleted on tesSUCCESS"
+                                                    : "AMM object is changed on tecINCOMPLETE";
+        JLOG(j.error()) << "AMMDelete invariant failed: " << msg;
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeDEX(bool enforce, beast::Journal const& j) const
+{
+    if (ammAccount_)
+    {
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMM swap invariant failed: AMM object changed";
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::generalInvariant(
+    xrpl::STTx const& tx,
+    xrpl::ReadView const& view,
+    ZeroAllowed zeroAllowed,
+    beast::Journal const& j) const
+{
+    auto const [amount, amount2] = ammPoolHolds(
+        view,
+        *ammAccount_,
+        tx[sfAsset].get<Issue>(),
+        tx[sfAsset2].get<Issue>(),
+        fhIGNORE_FREEZE,
+        j);
+    // Deposit and Withdrawal invariant:
+    // sqrt(amount * amount2) >= LPTokens
+    // all balances are greater than zero
+    // unless on last withdrawal
+    auto const poolProductMean = root2(amount * amount2);
+    bool const nonNegativeBalances =
+        validBalances(amount, amount2, *lptAMMBalanceAfter_, zeroAllowed);
+    bool const strongInvariantCheck = poolProductMean >= *lptAMMBalanceAfter_;
+    // Allow for a small relative error if strongInvariantCheck fails
+    auto weakInvariantCheck = [&]() {
+        return *lptAMMBalanceAfter_ != beast::zero &&
+            withinRelativeDistance(poolProductMean, Number{*lptAMMBalanceAfter_}, Number{1, -11});
+    };
+    if (!nonNegativeBalances || (!strongInvariantCheck && !weakInvariantCheck()))
+    {
+        JLOG(j.error()) << "AMM " << tx.getTxnType()
+                        << " invariant failed: " << tx.getHash(HashPrefix::transactionID) << " "
+                        << ammPoolChanged_ << " " << amount << " " << amount2 << " "
+                        << poolProductMean << " " << lptAMMBalanceAfter_->getText() << " "
+                        << ((*lptAMMBalanceAfter_ == beast::zero)
+                                ? Number{1}
+                                : ((*lptAMMBalanceAfter_ - poolProductMean) / poolProductMean));
+        return false;
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeDeposit(
+    xrpl::STTx const& tx,
+    xrpl::ReadView const& view,
+    bool enforce,
+    beast::Journal const& j) const
+{
+    if (!ammAccount_)
+    {
+        // LCOV_EXCL_START
+        JLOG(j.error()) << "AMMDeposit invariant failed: AMM object is deleted";
+        if (enforce)
+            return false;
+        // LCOV_EXCL_STOP
+    }
+    else if (!generalInvariant(tx, view, ZeroAllowed::No, j) && enforce)
+        return false;
+
+    return true;
+}
+
+bool
+ValidAMM::finalizeWithdraw(
+    xrpl::STTx const& tx,
+    xrpl::ReadView const& view,
+    bool enforce,
+    beast::Journal const& j) const
+{
+    if (!ammAccount_)
+    {
+        // Last Withdraw or Clawback deleted AMM
+    }
+    else if (!generalInvariant(tx, view, ZeroAllowed::Yes, j))
+    {
+        if (enforce)
+            return false;
+    }
+
+    return true;
+}
+
+bool
+ValidAMM::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    // Delete may return tecINCOMPLETE if there are too many
+    // trustlines to delete.
+    if (result != tesSUCCESS && result != tecINCOMPLETE)
+        return true;
+
+    bool const enforce = view.rules().enabled(fixAMMv1_3);
+
+    switch (tx.getTxnType())
+    {
+        case ttAMM_CREATE:
+            return finalizeCreate(tx, view, enforce, j);
+        case ttAMM_DEPOSIT:
+            return finalizeDeposit(tx, view, enforce, j);
+        case ttAMM_CLAWBACK:
+        case ttAMM_WITHDRAW:
+            return finalizeWithdraw(tx, view, enforce, j);
+        case ttAMM_BID:
+            return finalizeBid(enforce, j);
+        case ttAMM_VOTE:
+            return finalizeVote(enforce, j);
+        case ttAMM_DELETE:
+            return finalizeDelete(enforce, result, j);
+        case ttCHECK_CASH:
+        case ttOFFER_CREATE:
+        case ttPAYMENT:
+            return finalizeDEX(enforce, j);
+        default:
+            break;
+    }
+
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/FreezeInvariant.cpp b/src/libxrpl/tx/invariants/FreezeInvariant.cpp
new file mode 100644
index 0000000000..858c4cdcb8
--- /dev/null
+++ b/src/libxrpl/tx/invariants/FreezeInvariant.cpp
@@ -0,0 +1,278 @@
+#include <xrpl/tx/invariants/FreezeInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
+
+namespace xrpl {
+
+void
+TransfersNotFrozen::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    /*
+     * A trust line freeze state alone doesn't determine if a transfer is
+     * frozen. The transfer must be examined "end-to-end" because both sides of
+     * the transfer may have different freeze states and freeze impact depends
+     * on the transfer direction. This is why first we need to track the
+     * transfers using IssuerChanges senders/receivers.
+     *
+     * Only in validateIssuerChanges, after we collected all changes can we
+     * determine if the transfer is valid.
+     */
+    if (!isValidEntry(before, after))
+    {
+        return;
+    }
+
+    auto const balanceChange = calculateBalanceChange(before, after, isDelete);
+    if (balanceChange.signum() == 0)
+    {
+        return;
+    }
+
+    recordBalanceChanges(after, balanceChange);
+}
+
+bool
+TransfersNotFrozen::finalize(
+    STTx const& tx,
+    TER const ter,
+    XRPAmount const fee,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    /*
+     * We check this invariant regardless of deep freeze amendment status,
+     * allowing for detection and logging of potential issues even when the
+     * amendment is disabled.
+     *
+     * If an exploit that allows moving frozen assets is discovered,
+     * we can alert operators who monitor fatal messages and trigger assert in
+     * debug builds for an early warning.
+     *
+     * In an unlikely event that an exploit is found, this early detection
+     * enables encouraging the UNL to expedite deep freeze amendment activation
+     * or deploy hotfixes via new amendments. In case of a new amendment, we'd
+     * only have to change this line setting 'enforce' variable.
+     * enforce = view.rules().enabled(featureDeepFreeze) ||
+     *           view.rules().enabled(fixFreezeExploit);
+     */
+    [[maybe_unused]] bool const enforce = view.rules().enabled(featureDeepFreeze);
+
+    for (auto const& [issue, changes] : balanceChanges_)
+    {
+        auto const issuerSle = findIssuer(issue.account, view);
+        // It should be impossible for the issuer to not be found, but check
+        // just in case so rippled doesn't crash in release.
+        if (!issuerSle)
+        {
+            // The comment above starting with "assert(enforce)" explains this
+            // assert.
+            XRPL_ASSERT(
+                enforce,
+                "xrpl::TransfersNotFrozen::finalize : enforce "
+                "invariant.");
+            if (enforce)
+            {
+                return false;
+            }
+            continue;
+        }
+
+        if (!validateIssuerChanges(issuerSle, changes, tx, j, enforce))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+TransfersNotFrozen::isValidEntry(
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    // `after` can never be null, even if the trust line is deleted.
+    XRPL_ASSERT(after, "xrpl::TransfersNotFrozen::isValidEntry : valid after.");
+    if (!after)
+    {
+        return false;
+    }
+
+    if (after->getType() == ltACCOUNT_ROOT)
+    {
+        possibleIssuers_.emplace(after->at(sfAccount), after);
+        return false;
+    }
+
+    /* While LedgerEntryTypesMatch invariant also checks types, all invariants
+     * are processed regardless of previous failures.
+     *
+     * This type check is still necessary here because it prevents potential
+     * issues in subsequent processing.
+     */
+    return after->getType() == ltRIPPLE_STATE && (!before || before->getType() == ltRIPPLE_STATE);
+}
+
+STAmount
+TransfersNotFrozen::calculateBalanceChange(
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after,
+    bool isDelete)
+{
+    auto const getBalance = [](auto const& line, auto const& other, bool zero) {
+        STAmount amt = line ? line->at(sfBalance) : other->at(sfBalance).zeroed();
+        return zero ? amt.zeroed() : amt;
+    };
+
+    /* Trust lines can be created dynamically by other transactions such as
+     * Payment and OfferCreate that cross offers. Such trust line won't be
+     * created frozen, but the sender might be, so the starting balance must be
+     * treated as zero.
+     */
+    auto const balanceBefore = getBalance(before, after, false);
+
+    /* Same as above, trust lines can be dynamically deleted, and for frozen
+     * trust lines, payments not involving the issuer must be blocked. This is
+     * achieved by treating the final balance as zero when isDelete=true to
+     * ensure frozen line restrictions are enforced even during deletion.
+     */
+    auto const balanceAfter = getBalance(after, before, isDelete);
+
+    return balanceAfter - balanceBefore;
+}
+
+void
+TransfersNotFrozen::recordBalance(Issue const& issue, BalanceChange change)
+{
+    XRPL_ASSERT(
+        change.balanceChangeSign,
+        "xrpl::TransfersNotFrozen::recordBalance : valid trustline "
+        "balance sign.");
+    auto& changes = balanceChanges_[issue];
+    if (change.balanceChangeSign < 0)
+        changes.senders.emplace_back(std::move(change));
+    else
+        changes.receivers.emplace_back(std::move(change));
+}
+
+void
+TransfersNotFrozen::recordBalanceChanges(
+    std::shared_ptr<SLE const> const& after,
+    STAmount const& balanceChange)
+{
+    auto const balanceChangeSign = balanceChange.signum();
+    auto const currency = after->at(sfBalance).getCurrency();
+
+    // Change from low account's perspective, which is trust line default
+    recordBalance({currency, after->at(sfHighLimit).getIssuer()}, {after, balanceChangeSign});
+
+    // Change from high account's perspective, which reverses the sign.
+    recordBalance({currency, after->at(sfLowLimit).getIssuer()}, {after, -balanceChangeSign});
+}
+
+std::shared_ptr<SLE const>
+TransfersNotFrozen::findIssuer(AccountID const& issuerID, ReadView const& view)
+{
+    if (auto it = possibleIssuers_.find(issuerID); it != possibleIssuers_.end())
+    {
+        return it->second;
+    }
+
+    return view.read(keylet::account(issuerID));
+}
+
+bool
+TransfersNotFrozen::validateIssuerChanges(
+    std::shared_ptr<SLE const> const& issuer,
+    IssuerChanges const& changes,
+    STTx const& tx,
+    beast::Journal const& j,
+    bool enforce)
+{
+    if (!issuer)
+    {
+        return false;
+    }
+
+    bool const globalFreeze = issuer->isFlag(lsfGlobalFreeze);
+    if (changes.receivers.empty() || changes.senders.empty())
+    {
+        /* If there are no receivers, then the holder(s) are returning
+         * their tokens to the issuer. Likewise, if there are no
+         * senders, then the issuer is issuing tokens to the holder(s).
+         * This is allowed regardless of the issuer's freeze flags. (The
+         * holder may have contradicting freeze flags, but that will be
+         * checked when the holder is treated as issuer.)
+         */
+        return true;
+    }
+
+    for (auto const& actors : {changes.senders, changes.receivers})
+    {
+        for (auto const& change : actors)
+        {
+            bool const high = change.line->at(sfLowLimit).getIssuer() == issuer->at(sfAccount);
+
+            if (!validateFrozenState(change, high, tx, j, enforce, globalFreeze))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool
+TransfersNotFrozen::validateFrozenState(
+    BalanceChange const& change,
+    bool high,
+    STTx const& tx,
+    beast::Journal const& j,
+    bool enforce,
+    bool globalFreeze)
+{
+    bool const freeze =
+        change.balanceChangeSign < 0 && change.line->isFlag(high ? lsfLowFreeze : lsfHighFreeze);
+    bool const deepFreeze = change.line->isFlag(high ? lsfLowDeepFreeze : lsfHighDeepFreeze);
+    bool const frozen = globalFreeze || deepFreeze || freeze;
+
+    bool const isAMMLine = change.line->isFlag(lsfAMMNode);
+
+    if (!frozen)
+    {
+        return true;
+    }
+
+    // AMMClawbacks are allowed to override some freeze rules
+    if ((!isAMMLine || globalFreeze) && hasPrivilege(tx, overrideFreeze))
+    {
+        JLOG(j.debug()) << "Invariant check allowing funds to be moved "
+                        << (change.balanceChangeSign > 0 ? "to" : "from")
+                        << " a frozen trustline for AMMClawback " << tx.getTransactionID();
+        return true;
+    }
+
+    JLOG(j.fatal()) << "Invariant failed: Attempting to move frozen funds for "
+                    << tx.getTransactionID();
+    // The comment above starting with "assert(enforce)" explains this assert.
+    XRPL_ASSERT(
+        enforce,
+        "xrpl::TransfersNotFrozen::validateFrozenState : enforce "
+        "invariant.");
+
+    if (enforce)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/InvariantCheck.cpp b/src/libxrpl/tx/invariants/InvariantCheck.cpp
new file mode 100644
index 0000000000..025d2d5fec
--- /dev/null
+++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp
@@ -0,0 +1,1010 @@
+#include <xrpl/tx/invariants/InvariantCheck.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STNumber.h>
+#include <xrpl/protocol/SystemParameters.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace xrpl {
+
+#pragma push_macro("TRANSACTION")
+#undef TRANSACTION
+
+#define TRANSACTION(tag, value, name, delegable, amendment, privileges, ...) \
+    case tag: {                                                              \
+        return (privileges) & priv;                                          \
+    }
+
+bool
+hasPrivilege(STTx const& tx, Privilege priv)
+{
+    switch (tx.getTxnType())
+    {
+#include <xrpl/protocol/detail/transactions.macro>
+
+        // Deprecated types
+        default:
+            return false;
+    }
+};
+
+#undef TRANSACTION
+#pragma pop_macro("TRANSACTION")
+
+void
+TransactionFeeCheck::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const&,
+    std::shared_ptr<SLE const> const&)
+{
+    // nothing to do
+}
+
+bool
+TransactionFeeCheck::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const fee,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    // We should never charge a negative fee
+    if (fee.drops() < 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: fee paid was negative: " << fee.drops();
+        return false;
+    }
+
+    // We should never charge a fee that's greater than or equal to the
+    // entire XRP supply.
+    if (fee >= INITIAL_XRP)
+    {
+        JLOG(j.fatal()) << "Invariant failed: fee paid exceeds system limit: " << fee.drops();
+        return false;
+    }
+
+    // We should never charge more for a transaction than the transaction
+    // authorizes. It's possible to charge less in some circumstances.
+    if (fee > tx.getFieldAmount(sfFee).xrp())
+    {
+        JLOG(j.fatal()) << "Invariant failed: fee paid is " << fee.drops()
+                        << " exceeds fee specified in transaction.";
+        return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+XRPNotCreated::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    /* We go through all modified ledger entries, looking only at account roots,
+     * escrow payments, and payment channels. We remove from the total any
+     * previous XRP values and add to the total any new XRP values. The net
+     * balance of a payment channel is computed from two fields (amount and
+     * balance) and deletions are ignored for paychan and escrow because the
+     * amount fields have not been adjusted for those in the case of deletion.
+     */
+    if (before)
+    {
+        switch (before->getType())
+        {
+            case ltACCOUNT_ROOT:
+                drops_ -= (*before)[sfBalance].xrp().drops();
+                break;
+            case ltPAYCHAN:
+                drops_ -= ((*before)[sfAmount] - (*before)[sfBalance]).xrp().drops();
+                break;
+            case ltESCROW:
+                if (isXRP((*before)[sfAmount]))
+                    drops_ -= (*before)[sfAmount].xrp().drops();
+                break;
+            default:
+                break;
+        }
+    }
+
+    if (after)
+    {
+        switch (after->getType())
+        {
+            case ltACCOUNT_ROOT:
+                drops_ += (*after)[sfBalance].xrp().drops();
+                break;
+            case ltPAYCHAN:
+                if (!isDelete)
+                    drops_ += ((*after)[sfAmount] - (*after)[sfBalance]).xrp().drops();
+                break;
+            case ltESCROW:
+                if (!isDelete && isXRP((*after)[sfAmount]))
+                    drops_ += (*after)[sfAmount].xrp().drops();
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+bool
+XRPNotCreated::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const fee,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    // The net change should never be positive, as this would mean that the
+    // transaction created XRP out of thin air. That's not possible.
+    if (drops_ > 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: XRP net change was positive: " << drops_;
+        return false;
+    }
+
+    // The negative of the net change should be equal to actual fee charged.
+    if (-drops_ != fee.drops())
+    {
+        JLOG(j.fatal()) << "Invariant failed: XRP net change of " << drops_ << " doesn't match fee "
+                        << fee.drops();
+        return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+XRPBalanceChecks::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    auto isBad = [](STAmount const& balance) {
+        if (!balance.native())
+            return true;
+
+        auto const drops = balance.xrp();
+
+        // Can't have more than the number of drops instantiated
+        // in the genesis ledger.
+        if (drops > INITIAL_XRP)
+            return true;
+
+        // Can't have a negative balance (0 is OK)
+        if (drops < XRPAmount{0})
+            return true;
+
+        return false;
+    };
+
+    if (before && before->getType() == ltACCOUNT_ROOT)
+        bad_ |= isBad((*before)[sfBalance]);
+
+    if (after && after->getType() == ltACCOUNT_ROOT)
+        bad_ |= isBad((*after)[sfBalance]);
+}
+
+bool
+XRPBalanceChecks::finalize(
+    STTx const&,
+    TER const,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    if (bad_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: incorrect account XRP balance";
+        return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+NoBadOffers::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    auto isBad = [](STAmount const& pays, STAmount const& gets) {
+        // An offer should never be negative
+        if (pays < beast::zero)
+            return true;
+
+        if (gets < beast::zero)
+            return true;
+
+        // Can't have an XRP to XRP offer:
+        return pays.native() && gets.native();
+    };
+
+    if (before && before->getType() == ltOFFER)
+        bad_ |= isBad((*before)[sfTakerPays], (*before)[sfTakerGets]);
+
+    if (after && after->getType() == ltOFFER)
+        bad_ |= isBad((*after)[sfTakerPays], (*after)[sfTakerGets]);
+}
+
+bool
+NoBadOffers::finalize(
+    STTx const&,
+    TER const,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    if (bad_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: offer with a bad amount";
+        return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+NoZeroEscrow::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    auto isBad = [](STAmount const& amount) {
+        // XRP case
+        if (amount.native())
+        {
+            if (amount.xrp() <= XRPAmount{0})
+                return true;
+
+            if (amount.xrp() >= INITIAL_XRP)
+                return true;
+        }
+        else
+        {
+            // IOU case
+            if (amount.holds<Issue>())
+            {
+                if (amount <= beast::zero)
+                    return true;
+
+                if (badCurrency() == amount.getCurrency())
+                    return true;
+            }
+
+            // MPT case
+            if (amount.holds<MPTIssue>())
+            {
+                if (amount <= beast::zero)
+                    return true;
+
+                if (amount.mpt() > MPTAmount{maxMPTokenAmount})
+                    return true;  // LCOV_EXCL_LINE
+            }
+        }
+        return false;
+    };
+
+    if (before && before->getType() == ltESCROW)
+        bad_ |= isBad((*before)[sfAmount]);
+
+    if (after && after->getType() == ltESCROW)
+        bad_ |= isBad((*after)[sfAmount]);
+
+    auto checkAmount = [this](std::int64_t amount) {
+        if (amount > maxMPTokenAmount || amount < 0)
+            bad_ = true;
+    };
+
+    if (after && after->getType() == ltMPTOKEN_ISSUANCE)
+    {
+        auto const outstanding = (*after)[sfOutstandingAmount];
+        checkAmount(outstanding);
+        if (auto const locked = (*after)[~sfLockedAmount])
+        {
+            checkAmount(*locked);
+            bad_ = outstanding < *locked;
+        }
+    }
+
+    if (after && after->getType() == ltMPTOKEN)
+    {
+        auto const mptAmount = (*after)[sfMPTAmount];
+        checkAmount(mptAmount);
+        if (auto const locked = (*after)[~sfLockedAmount])
+        {
+            checkAmount(*locked);
+        }
+    }
+}
+
+bool
+NoZeroEscrow::finalize(
+    STTx const& txn,
+    TER const,
+    XRPAmount const,
+    ReadView const& rv,
+    beast::Journal const& j)
+{
+    if (bad_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: escrow specifies invalid amount";
+        return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+AccountRootsNotDeleted::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const&)
+{
+    if (isDelete && before && before->getType() == ltACCOUNT_ROOT)
+        accountsDeleted_++;
+}
+
+bool
+AccountRootsNotDeleted::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    // AMM account root can be deleted as the result of AMM withdraw/delete
+    // transaction when the total AMM LP Tokens balance goes to 0.
+    // A successful AccountDelete or AMMDelete MUST delete exactly
+    // one account root.
+    if (hasPrivilege(tx, mustDeleteAcct) && result == tesSUCCESS)
+    {
+        if (accountsDeleted_ == 1)
+            return true;
+
+        if (accountsDeleted_ == 0)
+            JLOG(j.fatal()) << "Invariant failed: account deletion "
+                               "succeeded without deleting an account";
+        else
+            JLOG(j.fatal()) << "Invariant failed: account deletion "
+                               "succeeded but deleted multiple accounts!";
+        return false;
+    }
+
+    // A successful AMMWithdraw/AMMClawback MAY delete one account root
+    // when the total AMM LP Tokens balance goes to 0. Not every AMM withdraw
+    // deletes the AMM account, accountsDeleted_ is set if it is deleted.
+    if (hasPrivilege(tx, mayDeleteAcct) && result == tesSUCCESS && accountsDeleted_ == 1)
+        return true;
+
+    if (accountsDeleted_ == 0)
+        return true;
+
+    JLOG(j.fatal()) << "Invariant failed: an account root was deleted";
+    return false;
+}
+
+//------------------------------------------------------------------------------
+
+void
+AccountRootsDeletedClean::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (isDelete && before && before->getType() == ltACCOUNT_ROOT)
+        accountsDeleted_.emplace_back(before, after);
+}
+
+bool
+AccountRootsDeletedClean::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    // Always check for objects in the ledger, but to prevent differing
+    // transaction processing results, however unlikely, only fail if the
+    // feature is enabled. Enabled, or not, though, a fatal-level message will
+    // be logged
+    [[maybe_unused]] bool const enforce = view.rules().enabled(featureInvariantsV1_1) ||
+        view.rules().enabled(featureSingleAssetVault) ||
+        view.rules().enabled(featureLendingProtocol);
+
+    auto const objectExists = [&view, enforce, &j](auto const& keylet) {
+        (void)enforce;
+        if (auto const sle = view.read(keylet))
+        {
+            // Finding the object is bad
+            auto const typeName = [&sle]() {
+                auto item = LedgerFormats::getInstance().findByType(sle->getType());
+
+                if (item != nullptr)
+                    return item->getName();
+                return std::to_string(sle->getType());
+            }();
+
+            JLOG(j.fatal()) << "Invariant failed: account deletion left behind a " << typeName
+                            << " object";
+            // The comment above starting with "assert(enforce)" explains this
+            // assert.
+            XRPL_ASSERT(
+                enforce,
+                "xrpl::AccountRootsDeletedClean::finalize::objectExists : "
+                "account deletion left no objects behind");
+            return true;
+        }
+        return false;
+    };
+
+    for (auto const& [before, after] : accountsDeleted_)
+    {
+        auto const accountID = before->getAccountID(sfAccount);
+        // An account should not be deleted with a balance
+        if (after->at(sfBalance) != beast::zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: account deletion left "
+                               "behind a non-zero balance";
+            XRPL_ASSERT(
+                enforce,
+                "xrpl::AccountRootsDeletedClean::finalize : "
+                "deleted account has zero balance");
+            if (enforce)
+                return false;
+        }
+        // An account should not be deleted with a non-zero owner count
+        if (after->at(sfOwnerCount) != 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: account deletion left "
+                               "behind a non-zero owner count";
+            XRPL_ASSERT(
+                enforce,
+                "xrpl::AccountRootsDeletedClean::finalize : "
+                "deleted account has zero owner count");
+            if (enforce)
+                return false;
+        }
+        // Simple types
+        for (auto const& [keyletfunc, _1, _2] : directAccountKeylets)
+        {
+            // TODO: use '_' for both unused variables above once we are in C++26
+            if (objectExists(std::invoke(keyletfunc, accountID)) && enforce)
+                return false;
+        }
+
+        {
+            // NFT pages. nftpage_min and nftpage_max were already explicitly
+            // checked above as entries in directAccountKeylets. This uses
+            // view.succ() to check for any NFT pages in between the two
+            // endpoints.
+            Keylet const first = keylet::nftpage_min(accountID);
+            Keylet const last = keylet::nftpage_max(accountID);
+
+            std::optional<uint256> key = view.succ(first.key, last.key.next());
+
+            // current page
+            if (key && objectExists(Keylet{ltNFTOKEN_PAGE, *key}) && enforce)
+                return false;
+        }
+
+        // If the account is a pseudo account, then the linked object must
+        // also be deleted. e.g. AMM, Vault, etc.
+        for (auto const& field : getPseudoAccountFields())
+        {
+            if (before->isFieldPresent(*field))
+            {
+                auto const key = before->getFieldH256(*field);
+                if (objectExists(keylet::unchecked(key)) && enforce)
+                    return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+LedgerEntryTypesMatch::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (before && after && before->getType() != after->getType())
+        typeMismatch_ = true;
+
+    if (after)
+    {
+#pragma push_macro("LEDGER_ENTRY")
+#undef LEDGER_ENTRY
+
+#define LEDGER_ENTRY(tag, ...) case tag:
+
+        switch (after->getType())
+        {
+#include <xrpl/protocol/detail/ledger_entries.macro>
+
+            break;
+            default:
+                invalidTypeAdded_ = true;
+                break;
+        }
+
+#undef LEDGER_ENTRY
+#pragma pop_macro("LEDGER_ENTRY")
+    }
+}
+
+bool
+LedgerEntryTypesMatch::finalize(
+    STTx const&,
+    TER const,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    if ((!typeMismatch_) && (!invalidTypeAdded_))
+        return true;
+
+    if (typeMismatch_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: ledger entry type mismatch";
+    }
+
+    if (invalidTypeAdded_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: invalid ledger entry type added";
+    }
+
+    return false;
+}
+
+//------------------------------------------------------------------------------
+
+void
+NoXRPTrustLines::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const&,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after && after->getType() == ltRIPPLE_STATE)
+    {
+        // checking the issue directly here instead of
+        // relying on .native() just in case native somehow
+        // were systematically incorrect
+        xrpTrustLine_ = after->getFieldAmount(sfLowLimit).issue() == xrpIssue() ||
+            after->getFieldAmount(sfHighLimit).issue() == xrpIssue();
+    }
+}
+
+bool
+NoXRPTrustLines::finalize(
+    STTx const&,
+    TER const,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    if (!xrpTrustLine_)
+        return true;
+
+    JLOG(j.fatal()) << "Invariant failed: an XRP trust line was created";
+    return false;
+}
+
+//------------------------------------------------------------------------------
+
+void
+NoDeepFreezeTrustLinesWithoutFreeze::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const&,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after && after->getType() == ltRIPPLE_STATE)
+    {
+        std::uint32_t const uFlags = after->getFieldU32(sfFlags);
+        bool const lowFreeze = uFlags & lsfLowFreeze;
+        bool const lowDeepFreeze = uFlags & lsfLowDeepFreeze;
+
+        bool const highFreeze = uFlags & lsfHighFreeze;
+        bool const highDeepFreeze = uFlags & lsfHighDeepFreeze;
+
+        deepFreezeWithoutFreeze_ = (lowDeepFreeze && !lowFreeze) || (highDeepFreeze && !highFreeze);
+    }
+}
+
+bool
+NoDeepFreezeTrustLinesWithoutFreeze::finalize(
+    STTx const&,
+    TER const,
+    XRPAmount const,
+    ReadView const&,
+    beast::Journal const& j)
+{
+    if (!deepFreezeWithoutFreeze_)
+        return true;
+
+    JLOG(j.fatal()) << "Invariant failed: a trust line with deep freeze flag "
+                       "without normal freeze was created";
+    return false;
+}
+
+//------------------------------------------------------------------------------
+
+void
+ValidNewAccountRoot::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (!before && after->getType() == ltACCOUNT_ROOT)
+    {
+        accountsCreated_++;
+        accountSeq_ = (*after)[sfSequence];
+        pseudoAccount_ = isPseudoAccount(after);
+        flags_ = after->getFlags();
+    }
+}
+
+bool
+ValidNewAccountRoot::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    if (accountsCreated_ == 0)
+        return true;
+
+    if (accountsCreated_ > 1)
+    {
+        JLOG(j.fatal()) << "Invariant failed: multiple accounts "
+                           "created in a single transaction";
+        return false;
+    }
+
+    // From this point on we know exactly one account was created.
+    if (hasPrivilege(tx, createAcct | createPseudoAcct) && result == tesSUCCESS)
+    {
+        bool const pseudoAccount =
+            (pseudoAccount_ &&
+             (view.rules().enabled(featureSingleAssetVault) ||
+              view.rules().enabled(featureLendingProtocol)));
+
+        if (pseudoAccount && !hasPrivilege(tx, createPseudoAcct))
+        {
+            JLOG(j.fatal()) << "Invariant failed: pseudo-account created by a "
+                               "wrong transaction type";
+            return false;
+        }
+
+        std::uint32_t const startingSeq = pseudoAccount ? 0 : view.seq();
+
+        if (accountSeq_ != startingSeq)
+        {
+            JLOG(j.fatal()) << "Invariant failed: account created with "
+                               "wrong starting sequence number";
+            return false;
+        }
+
+        if (pseudoAccount)
+        {
+            std::uint32_t const expected = (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth);
+            if (flags_ != expected)
+            {
+                JLOG(j.fatal()) << "Invariant failed: pseudo-account created with "
+                                   "wrong flags";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    JLOG(j.fatal()) << "Invariant failed: account root created illegally";
+    return false;
+}  // namespace xrpl
+
+//------------------------------------------------------------------------------
+
+void
+ValidClawback::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const&)
+{
+    if (before && before->getType() == ltRIPPLE_STATE)
+        trustlinesChanged++;
+
+    if (before && before->getType() == ltMPTOKEN)
+        mptokensChanged++;
+}
+
+bool
+ValidClawback::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    if (tx.getTxnType() != ttCLAWBACK)
+        return true;
+
+    if (result == tesSUCCESS)
+    {
+        if (trustlinesChanged > 1)
+        {
+            JLOG(j.fatal()) << "Invariant failed: more than one trustline changed.";
+            return false;
+        }
+
+        if (mptokensChanged > 1)
+        {
+            JLOG(j.fatal()) << "Invariant failed: more than one mptokens changed.";
+            return false;
+        }
+
+        if (trustlinesChanged == 1)
+        {
+            AccountID const issuer = tx.getAccountID(sfAccount);
+            STAmount const& amount = tx.getFieldAmount(sfAmount);
+            AccountID const& holder = amount.getIssuer();
+            STAmount const holderBalance =
+                accountHolds(view, holder, amount.getCurrency(), issuer, fhIGNORE_FREEZE, j);
+
+            if (holderBalance.signum() < 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: trustline balance is negative";
+                return false;
+            }
+        }
+    }
+    else
+    {
+        if (trustlinesChanged != 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: some trustlines were changed "
+                               "despite failure of the transaction.";
+            return false;
+        }
+
+        if (mptokensChanged != 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: some mptokens were changed "
+                               "despite failure of the transaction.";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+ValidPseudoAccounts::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (isDelete)
+        // Deletion is ignored
+        return;
+
+    if (after && after->getType() == ltACCOUNT_ROOT)
+    {
+        bool const isPseudo = [&]() {
+            // isPseudoAccount checks that any of the pseudo-account fields are
+            // set.
+            if (isPseudoAccount(after))
+                return true;
+            // Not all pseudo-accounts have a zero sequence, but all accounts
+            // with a zero sequence had better be pseudo-accounts.
+            if (after->at(sfSequence) == 0)
+                return true;
+
+            return false;
+        }();
+        if (isPseudo)
+        {
+            // Pseudo accounts must have the following properties:
+            // 1. Exactly one of the pseudo-account fields is set.
+            // 2. The sequence number is not changed.
+            // 3. The lsfDisableMaster, lsfDefaultRipple, and lsfDepositAuth
+            // flags are set.
+            // 4. The RegularKey is not set.
+            {
+                std::vector<SField const*> const& fields = getPseudoAccountFields();
+
+                auto const numFields =
+                    std::count_if(fields.begin(), fields.end(), [&after](SField const* sf) -> bool {
+                        return after->isFieldPresent(*sf);
+                    });
+                if (numFields != 1)
+                {
+                    std::stringstream error;
+                    error << "pseudo-account has " << numFields << " pseudo-account fields set";
+                    errors_.emplace_back(error.str());
+                }
+            }
+            if (before && before->at(sfSequence) != after->at(sfSequence))
+            {
+                errors_.emplace_back("pseudo-account sequence changed");
+            }
+            if (!after->isFlag(lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth))
+            {
+                errors_.emplace_back("pseudo-account flags are not set");
+            }
+            if (after->isFieldPresent(sfRegularKey))
+            {
+                errors_.emplace_back("pseudo-account has a regular key");
+            }
+        }
+    }
+}
+
+bool
+ValidPseudoAccounts::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    bool const enforce = view.rules().enabled(featureSingleAssetVault);
+    XRPL_ASSERT(
+        errors_.empty() || enforce,
+        "xrpl::ValidPseudoAccounts::finalize : no bad "
+        "changes or enforce invariant");
+    if (!errors_.empty())
+    {
+        for (auto const& error : errors_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: " << error;
+        }
+        if (enforce)
+            return false;
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+NoModifiedUnmodifiableFields::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (isDelete || !before)
+        // Creation and deletion are ignored
+        return;
+
+    changedEntries_.emplace(before, after);
+}
+
+bool
+NoModifiedUnmodifiableFields::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    static auto const fieldChanged = [](auto const& before, auto const& after, auto const& field) {
+        bool const beforeField = before->isFieldPresent(field);
+        bool const afterField = after->isFieldPresent(field);
+        return beforeField != afterField || (afterField && before->at(field) != after->at(field));
+    };
+    for (auto const& slePair : changedEntries_)
+    {
+        auto const& before = slePair.first;
+        auto const& after = slePair.second;
+        auto const type = after->getType();
+        bool bad = false;
+        [[maybe_unused]] bool enforce = false;
+        switch (type)
+        {
+            case ltLOAN_BROKER:
+                /*
+                 * We check this invariant regardless of lending protocol
+                 * amendment status, allowing for detection and logging of
+                 * potential issues even when the amendment is disabled.
+                 */
+                enforce = view.rules().enabled(featureLendingProtocol);
+                bad = fieldChanged(before, after, sfLedgerEntryType) ||
+                    fieldChanged(before, after, sfLedgerIndex) ||
+                    fieldChanged(before, after, sfSequence) ||
+                    fieldChanged(before, after, sfOwnerNode) ||
+                    fieldChanged(before, after, sfVaultNode) ||
+                    fieldChanged(before, after, sfVaultID) ||
+                    fieldChanged(before, after, sfAccount) ||
+                    fieldChanged(before, after, sfOwner) ||
+                    fieldChanged(before, after, sfManagementFeeRate) ||
+                    fieldChanged(before, after, sfCoverRateMinimum) ||
+                    fieldChanged(before, after, sfCoverRateLiquidation);
+                break;
+            case ltLOAN:
+                /*
+                 * We check this invariant regardless of lending protocol
+                 * amendment status, allowing for detection and logging of
+                 * potential issues even when the amendment is disabled.
+                 */
+                enforce = view.rules().enabled(featureLendingProtocol);
+                bad = fieldChanged(before, after, sfLedgerEntryType) ||
+                    fieldChanged(before, after, sfLedgerIndex) ||
+                    fieldChanged(before, after, sfSequence) ||
+                    fieldChanged(before, after, sfOwnerNode) ||
+                    fieldChanged(before, after, sfLoanBrokerNode) ||
+                    fieldChanged(before, after, sfLoanBrokerID) ||
+                    fieldChanged(before, after, sfBorrower) ||
+                    fieldChanged(before, after, sfLoanOriginationFee) ||
+                    fieldChanged(before, after, sfLoanServiceFee) ||
+                    fieldChanged(before, after, sfLatePaymentFee) ||
+                    fieldChanged(before, after, sfClosePaymentFee) ||
+                    fieldChanged(before, after, sfOverpaymentFee) ||
+                    fieldChanged(before, after, sfInterestRate) ||
+                    fieldChanged(before, after, sfLateInterestRate) ||
+                    fieldChanged(before, after, sfCloseInterestRate) ||
+                    fieldChanged(before, after, sfOverpaymentInterestRate) ||
+                    fieldChanged(before, after, sfStartDate) ||
+                    fieldChanged(before, after, sfPaymentInterval) ||
+                    fieldChanged(before, after, sfGracePeriod) ||
+                    fieldChanged(before, after, sfLoanScale);
+                break;
+            default:
+                /*
+                 * We check this invariant regardless of lending protocol
+                 * amendment status, allowing for detection and logging of
+                 * potential issues even when the amendment is disabled.
+                 *
+                 * We use the lending protocol as a gate, even though
+                 * all transactions are affected because that's when it
+                 * was added.
+                 */
+                enforce = view.rules().enabled(featureLendingProtocol);
+                bad = fieldChanged(before, after, sfLedgerEntryType) ||
+                    fieldChanged(before, after, sfLedgerIndex);
+        }
+        XRPL_ASSERT(
+            !bad || enforce,
+            "xrpl::NoModifiedUnmodifiableFields::finalize : no bad "
+            "changes or enforce invariant");
+        if (bad)
+        {
+            JLOG(j.fatal()) << "Invariant failed: changed an unchangeable field for "
+                            << tx.getTransactionID();
+            if (enforce)
+                return false;
+        }
+    }
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/LoanInvariant.cpp b/src/libxrpl/tx/invariants/LoanInvariant.cpp
new file mode 100644
index 0000000000..01c4da46ac
--- /dev/null
+++ b/src/libxrpl/tx/invariants/LoanInvariant.cpp
@@ -0,0 +1,278 @@
+#include <xrpl/tx/invariants/LoanInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STNumber.h>
+#include <xrpl/protocol/TxFormats.h>
+
+namespace xrpl {
+
+void
+ValidLoanBroker::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after)
+    {
+        if (after->getType() == ltLOAN_BROKER)
+        {
+            auto& broker = brokers_[after->key()];
+            broker.brokerBefore = before;
+            broker.brokerAfter = after;
+        }
+        else if (after->getType() == ltACCOUNT_ROOT && after->isFieldPresent(sfLoanBrokerID))
+        {
+            auto const& loanBrokerID = after->at(sfLoanBrokerID);
+            // create an entry if one doesn't already exist
+            brokers_.emplace(loanBrokerID, BrokerInfo{});
+        }
+        else if (after->getType() == ltRIPPLE_STATE)
+        {
+            lines_.emplace_back(after);
+        }
+        else if (after->getType() == ltMPTOKEN)
+        {
+            mpts_.emplace_back(after);
+        }
+    }
+}
+
+bool
+ValidLoanBroker::goodZeroDirectory(
+    ReadView const& view,
+    SLE::const_ref dir,
+    beast::Journal const& j) const
+{
+    auto const next = dir->at(~sfIndexNext);
+    auto const prev = dir->at(~sfIndexPrevious);
+    if ((prev && *prev) || (next && *next))
+    {
+        JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
+                           "OwnerCount has multiple directory pages";
+        return false;
+    }
+    auto indexes = dir->getFieldV256(sfIndexes);
+    if (indexes.size() > 1)
+    {
+        JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
+                           "OwnerCount has multiple indexes in the Directory root";
+        return false;
+    }
+    if (indexes.size() == 1)
+    {
+        auto const index = indexes.value().front();
+        auto const sle = view.read(keylet::unchecked(index));
+        if (!sle)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker directory corrupt";
+            return false;
+        }
+        if (sle->getType() != ltRIPPLE_STATE && sle->getType() != ltMPTOKEN)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker with zero "
+                               "OwnerCount has an unexpected entry in the directory";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+ValidLoanBroker::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    // Loan Brokers will not exist on ledger if the Lending Protocol amendment
+    // is not enabled, so there's no need to check it.
+
+    for (auto const& line : lines_)
+    {
+        for (auto const& field : {&sfLowLimit, &sfHighLimit})
+        {
+            auto const account = view.read(keylet::account(line->at(*field).getIssuer()));
+            // This Invariant doesn't know about the rules for Trust Lines, so
+            // if the account is missing, don't treat it as an error. This
+            // loop is only concerned with finding Broker pseudo-accounts
+            if (account && account->isFieldPresent(sfLoanBrokerID))
+            {
+                auto const& loanBrokerID = account->at(sfLoanBrokerID);
+                // create an entry if one doesn't already exist
+                brokers_.emplace(loanBrokerID, BrokerInfo{});
+            }
+        }
+    }
+    for (auto const& mpt : mpts_)
+    {
+        auto const account = view.read(keylet::account(mpt->at(sfAccount)));
+        // This Invariant doesn't know about the rules for MPTokens, so
+        // if the account is missing, don't treat is as an error. This
+        // loop is only concerned with finding Broker pseudo-accounts
+        if (account && account->isFieldPresent(sfLoanBrokerID))
+        {
+            auto const& loanBrokerID = account->at(sfLoanBrokerID);
+            // create an entry if one doesn't already exist
+            brokers_.emplace(loanBrokerID, BrokerInfo{});
+        }
+    }
+
+    for (auto const& [brokerID, broker] : brokers_)
+    {
+        auto const& after =
+            broker.brokerAfter ? broker.brokerAfter : view.read(keylet::loanbroker(brokerID));
+
+        if (!after)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker missing";
+            return false;
+        }
+
+        auto const& before = broker.brokerBefore;
+
+        // https://github.com/Tapanito/XRPL-Standards/blob/xls-66-lending-protocol/XLS-0066d-lending-protocol/README.md#3123-invariants
+        // If `LoanBroker.OwnerCount = 0` the `DirectoryNode` will have at most
+        // one node (the root), which will only hold entries for `RippleState`
+        // or `MPToken` objects.
+        if (after->at(sfOwnerCount) == 0)
+        {
+            auto const dir = view.read(keylet::ownerDir(after->at(sfAccount)));
+            if (dir)
+            {
+                if (!goodZeroDirectory(view, dir, j))
+                {
+                    return false;
+                }
+            }
+        }
+        if (before && before->at(sfLoanSequence) > after->at(sfLoanSequence))
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker sequence number "
+                               "decreased";
+            return false;
+        }
+        if (after->at(sfDebtTotal) < 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker debt total is negative";
+            return false;
+        }
+        if (after->at(sfCoverAvailable) < 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker cover available is negative";
+            return false;
+        }
+        auto const vault = view.read(keylet::vault(after->at(sfVaultID)));
+        if (!vault)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker vault ID is invalid";
+            return false;
+        }
+        auto const& vaultAsset = vault->at(sfAsset);
+        if (after->at(sfCoverAvailable) < accountHolds(
+                                              view,
+                                              after->at(sfAccount),
+                                              vaultAsset,
+                                              FreezeHandling::fhIGNORE_FREEZE,
+                                              AuthHandling::ahIGNORE_AUTH,
+                                              j))
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Broker cover available "
+                               "is less than pseudo-account asset balance";
+            return false;
+        }
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+void
+ValidLoan::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after && after->getType() == ltLOAN)
+    {
+        loans_.emplace_back(before, after);
+    }
+}
+
+bool
+ValidLoan::finalize(
+    STTx const& tx,
+    TER const,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    // Loans will not exist on ledger if the Lending Protocol amendment
+    // is not enabled, so there's no need to check it.
+
+    for (auto const& [before, after] : loans_)
+    {
+        // https://github.com/Tapanito/XRPL-Standards/blob/xls-66-lending-protocol/XLS-0066d-lending-protocol/README.md#3223-invariants
+        // If `Loan.PaymentRemaining = 0` then the loan MUST be fully paid off
+        if (after->at(sfPaymentRemaining) == 0 &&
+            (after->at(sfTotalValueOutstanding) != beast::zero ||
+             after->at(sfPrincipalOutstanding) != beast::zero ||
+             after->at(sfManagementFeeOutstanding) != beast::zero))
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan with zero payments "
+                               "remaining has not been paid off";
+            return false;
+        }
+        // If `Loan.PaymentRemaining != 0` then the loan MUST NOT be fully paid
+        // off
+        if (after->at(sfPaymentRemaining) != 0 &&
+            after->at(sfTotalValueOutstanding) == beast::zero &&
+            after->at(sfPrincipalOutstanding) == beast::zero &&
+            after->at(sfManagementFeeOutstanding) == beast::zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan with zero payments "
+                               "remaining has not been paid off";
+            return false;
+        }
+        if (before && (before->isFlag(lsfLoanOverpayment) != after->isFlag(lsfLoanOverpayment)))
+        {
+            JLOG(j.fatal()) << "Invariant failed: Loan Overpayment flag changed";
+            return false;
+        }
+        // Must not be negative - STNumber
+        for (auto const field :
+             {&sfLoanServiceFee,
+              &sfLatePaymentFee,
+              &sfClosePaymentFee,
+              &sfPrincipalOutstanding,
+              &sfTotalValueOutstanding,
+              &sfManagementFeeOutstanding})
+        {
+            if (after->at(*field) < 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: " << field->getName() << " is negative ";
+                return false;
+            }
+        }
+        // Must be positive - STNumber
+        for (auto const field : {
+                 &sfPeriodicPayment,
+             })
+        {
+            if (after->at(*field) <= 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: " << field->getName()
+                                << " is zero or negative ";
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
new file mode 100644
index 0000000000..20957b8d43
--- /dev/null
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -0,0 +1,192 @@
+#include <xrpl/tx/invariants/MPTInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
+
+namespace xrpl {
+
+void
+ValidMPTIssuance::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after && after->getType() == ltMPTOKEN_ISSUANCE)
+    {
+        if (isDelete)
+            mptIssuancesDeleted_++;
+        else if (!before)
+            mptIssuancesCreated_++;
+    }
+
+    if (after && after->getType() == ltMPTOKEN)
+    {
+        if (isDelete)
+            mptokensDeleted_++;
+        else if (!before)
+        {
+            mptokensCreated_++;
+            MPTIssue const mptIssue{after->at(sfMPTokenIssuanceID)};
+            if (mptIssue.getIssuer() == after->at(sfAccount))
+                mptCreatedByIssuer_ = true;
+        }
+    }
+}
+
+bool
+ValidMPTIssuance::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const _fee,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    if (result == tesSUCCESS)
+    {
+        auto const& rules = view.rules();
+        [[maybe_unused]]
+        bool enforceCreatedByIssuer =
+            rules.enabled(featureSingleAssetVault) || rules.enabled(featureLendingProtocol);
+        if (mptCreatedByIssuer_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: MPToken created for the MPT issuer";
+            // The comment above starting with "assert(enforce)" explains this
+            // assert.
+            XRPL_ASSERT_PARTS(
+                enforceCreatedByIssuer, "xrpl::ValidMPTIssuance::finalize", "no issuer MPToken");
+            if (enforceCreatedByIssuer)
+                return false;
+        }
+
+        auto const txnType = tx.getTxnType();
+        if (hasPrivilege(tx, createMPTIssuance))
+        {
+            if (mptIssuancesCreated_ == 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: transaction "
+                                   "succeeded without creating a MPT issuance";
+            }
+            else if (mptIssuancesDeleted_ != 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: transaction "
+                                   "succeeded while removing MPT issuances";
+            }
+            else if (mptIssuancesCreated_ > 1)
+            {
+                JLOG(j.fatal()) << "Invariant failed: transaction "
+                                   "succeeded but created multiple issuances";
+            }
+
+            return mptIssuancesCreated_ == 1 && mptIssuancesDeleted_ == 0;
+        }
+
+        if (hasPrivilege(tx, destroyMPTIssuance))
+        {
+            if (mptIssuancesDeleted_ == 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
+                                   "succeeded without removing a MPT issuance";
+            }
+            else if (mptIssuancesCreated_ > 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
+                                   "succeeded while creating MPT issuances";
+            }
+            else if (mptIssuancesDeleted_ > 1)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
+                                   "succeeded but deleted multiple issuances";
+            }
+
+            return mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 1;
+        }
+
+        bool const lendingProtocolEnabled = view.rules().enabled(featureLendingProtocol);
+        // ttESCROW_FINISH may authorize an MPT, but it can't have the
+        // mayAuthorizeMPT privilege, because that may cause
+        // non-amendment-gated side effects.
+        bool const enforceEscrowFinish = (txnType == ttESCROW_FINISH) &&
+            (view.rules().enabled(featureSingleAssetVault) || lendingProtocolEnabled);
+        if (hasPrivilege(tx, mustAuthorizeMPT | mayAuthorizeMPT) || enforceEscrowFinish)
+        {
+            bool const submittedByIssuer = tx.isFieldPresent(sfHolder);
+
+            if (mptIssuancesCreated_ > 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT authorize "
+                                   "succeeded but created MPT issuances";
+                return false;
+            }
+            else if (mptIssuancesDeleted_ > 0)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT authorize "
+                                   "succeeded but deleted issuances";
+                return false;
+            }
+            else if (lendingProtocolEnabled && mptokensCreated_ + mptokensDeleted_ > 1)
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT authorize succeeded "
+                                   "but created/deleted bad number mptokens";
+                return false;
+            }
+            else if (submittedByIssuer && (mptokensCreated_ > 0 || mptokensDeleted_ > 0))
+            {
+                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by issuer "
+                                   "succeeded but created/deleted mptokens";
+                return false;
+            }
+            else if (
+                !submittedByIssuer && hasPrivilege(tx, mustAuthorizeMPT) &&
+                (mptokensCreated_ + mptokensDeleted_ != 1))
+            {
+                // if the holder submitted this tx, then a mptoken must be
+                // either created or deleted.
+                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by holder "
+                                   "succeeded but created/deleted bad number of mptokens";
+                return false;
+            }
+
+            return true;
+        }
+        if (txnType == ttESCROW_FINISH)
+        {
+            // ttESCROW_FINISH may authorize an MPT, but it can't have the
+            // mayAuthorizeMPT privilege, because that may cause
+            // non-amendment-gated side effects.
+            XRPL_ASSERT_PARTS(
+                !enforceEscrowFinish, "xrpl::ValidMPTIssuance::finalize", "not escrow finish tx");
+            return true;
+        }
+
+        if (hasPrivilege(tx, mayDeleteMPT) && mptokensDeleted_ == 1 && mptokensCreated_ == 0 &&
+            mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 0)
+            return true;
+    }
+
+    if (mptIssuancesCreated_ != 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: a MPT issuance was created";
+    }
+    else if (mptIssuancesDeleted_ != 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: a MPT issuance was deleted";
+    }
+    else if (mptokensCreated_ != 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: a MPToken was created";
+    }
+    else if (mptokensDeleted_ != 0)
+    {
+        JLOG(j.fatal()) << "Invariant failed: a MPToken was deleted";
+    }
+
+    return mptIssuancesCreated_ == 0 && mptIssuancesDeleted_ == 0 && mptokensCreated_ == 0 &&
+        mptokensDeleted_ == 0;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/NFTInvariant.cpp b/src/libxrpl/tx/invariants/NFTInvariant.cpp
new file mode 100644
index 0000000000..67f1e51231
--- /dev/null
+++ b/src/libxrpl/tx/invariants/NFTInvariant.cpp
@@ -0,0 +1,274 @@
+#include <xrpl/tx/invariants/NFTInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/nftPageMask.h>
+#include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+
+namespace xrpl {
+
+void
+ValidNFTokenPage::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    static constexpr uint256 const& pageBits = nft::pageMask;
+    static constexpr uint256 const accountBits = ~pageBits;
+
+    if ((before && before->getType() != ltNFTOKEN_PAGE) ||
+        (after && after->getType() != ltNFTOKEN_PAGE))
+        return;
+
+    auto check = [this, isDelete](std::shared_ptr<SLE const> const& sle) {
+        uint256 const account = sle->key() & accountBits;
+        uint256 const hiLimit = sle->key() & pageBits;
+        std::optional<uint256> const prev = (*sle)[~sfPreviousPageMin];
+
+        // Make sure that any page links...
+        //  1. Are properly associated with the owning account and
+        //  2. The page is correctly ordered between links.
+        if (prev)
+        {
+            if (account != (*prev & accountBits))
+                badLink_ = true;
+
+            if (hiLimit <= (*prev & pageBits))
+                badLink_ = true;
+        }
+
+        if (auto const next = (*sle)[~sfNextPageMin])
+        {
+            if (account != (*next & accountBits))
+                badLink_ = true;
+
+            if (hiLimit >= (*next & pageBits))
+                badLink_ = true;
+        }
+
+        {
+            auto const& nftokens = sle->getFieldArray(sfNFTokens);
+
+            // An NFTokenPage should never contain too many tokens or be empty.
+            if (std::size_t const nftokenCount = nftokens.size();
+                (!isDelete && nftokenCount == 0) || nftokenCount > dirMaxTokensPerPage)
+                invalidSize_ = true;
+
+            // If prev is valid, use it to establish a lower bound for
+            // page entries.  If prev is not valid the lower bound is zero.
+            uint256 const loLimit = prev ? *prev & pageBits : uint256(beast::zero);
+
+            // Also verify that all NFTokenIDs in the page are sorted.
+            uint256 loCmp = loLimit;
+            for (auto const& obj : nftokens)
+            {
+                uint256 const tokenID = obj[sfNFTokenID];
+                if (!nft::compareTokens(loCmp, tokenID))
+                    badSort_ = true;
+                loCmp = tokenID;
+
+                // None of the NFTs on this page should belong on lower or
+                // higher pages.
+                if (uint256 const tokenPageBits = tokenID & pageBits;
+                    tokenPageBits < loLimit || tokenPageBits >= hiLimit)
+                    badEntry_ = true;
+
+                if (auto uri = obj[~sfURI]; uri && uri->empty())
+                    badURI_ = true;
+            }
+        }
+    };
+
+    if (before)
+    {
+        check(before);
+
+        // While an account's NFToken directory contains any NFTokens, the last
+        // NFTokenPage (with 96 bits of 1 in the low part of the index) should
+        // never be deleted.
+        if (isDelete && (before->key() & nft::pageMask) == nft::pageMask &&
+            before->isFieldPresent(sfPreviousPageMin))
+        {
+            deletedFinalPage_ = true;
+        }
+    }
+
+    if (after)
+        check(after);
+
+    if (!isDelete && before && after)
+    {
+        // If the NFTokenPage
+        //  1. Has a NextMinPage field in before, but loses it in after, and
+        //  2. This is not the last page in the directory
+        // Then we have identified a corruption in the links between the
+        // NFToken pages in the NFToken directory.
+        if ((before->key() & nft::pageMask) != nft::pageMask &&
+            before->isFieldPresent(sfNextPageMin) && !after->isFieldPresent(sfNextPageMin))
+        {
+            deletedLink_ = true;
+        }
+    }
+}
+
+bool
+ValidNFTokenPage::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    if (badLink_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: NFT page is improperly linked.";
+        return false;
+    }
+
+    if (badEntry_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: NFT found in incorrect page.";
+        return false;
+    }
+
+    if (badSort_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: NFTs on page are not sorted.";
+        return false;
+    }
+
+    if (badURI_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: NFT contains empty URI.";
+        return false;
+    }
+
+    if (invalidSize_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: NFT page has invalid size.";
+        return false;
+    }
+
+    if (view.rules().enabled(fixNFTokenPageLinks))
+    {
+        if (deletedFinalPage_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Last NFT page deleted with "
+                               "non-empty directory.";
+            return false;
+        }
+        if (deletedLink_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: Lost NextMinPage link.";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+void
+NFTokenCountTracking::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (before && before->getType() == ltACCOUNT_ROOT)
+    {
+        beforeMintedTotal += (*before)[~sfMintedNFTokens].value_or(0);
+        beforeBurnedTotal += (*before)[~sfBurnedNFTokens].value_or(0);
+    }
+
+    if (after && after->getType() == ltACCOUNT_ROOT)
+    {
+        afterMintedTotal += (*after)[~sfMintedNFTokens].value_or(0);
+        afterBurnedTotal += (*after)[~sfBurnedNFTokens].value_or(0);
+    }
+}
+
+bool
+NFTokenCountTracking::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    if (!hasPrivilege(tx, changeNFTCounts))
+    {
+        if (beforeMintedTotal != afterMintedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: the number of minted tokens "
+                               "changed without a mint transaction!";
+            return false;
+        }
+
+        if (beforeBurnedTotal != afterBurnedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: the number of burned tokens "
+                               "changed without a burn transaction!";
+            return false;
+        }
+
+        return true;
+    }
+
+    if (tx.getTxnType() == ttNFTOKEN_MINT)
+    {
+        if (result == tesSUCCESS && beforeMintedTotal >= afterMintedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: successful minting didn't increase "
+                               "the number of minted tokens.";
+            return false;
+        }
+
+        if (result != tesSUCCESS && beforeMintedTotal != afterMintedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: failed minting changed the "
+                               "number of minted tokens.";
+            return false;
+        }
+
+        if (beforeBurnedTotal != afterBurnedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: minting changed the number of "
+                               "burned tokens.";
+            return false;
+        }
+    }
+
+    if (tx.getTxnType() == ttNFTOKEN_BURN)
+    {
+        if (result == tesSUCCESS)
+        {
+            if (beforeBurnedTotal >= afterBurnedTotal)
+            {
+                JLOG(j.fatal()) << "Invariant failed: successful burning didn't increase "
+                                   "the number of burned tokens.";
+                return false;
+            }
+        }
+
+        if (result != tesSUCCESS && beforeBurnedTotal != afterBurnedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: failed burning changed the "
+                               "number of burned tokens.";
+            return false;
+        }
+
+        if (beforeMintedTotal != afterMintedTotal)
+        {
+            JLOG(j.fatal()) << "Invariant failed: burning changed the number of "
+                               "minted tokens.";
+            return false;
+        }
+    }
+
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp
new file mode 100644
index 0000000000..2ece1f3fc0
--- /dev/null
+++ b/src/libxrpl/tx/invariants/PermissionedDEXInvariant.cpp
@@ -0,0 +1,93 @@
+#include <xrpl/tx/invariants/PermissionedDEXInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/TxFormats.h>
+
+namespace xrpl {
+
+void
+ValidPermissionedDEX::visitEntry(
+    bool,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (after && after->getType() == ltDIR_NODE)
+    {
+        if (after->isFieldPresent(sfDomainID))
+            domains_.insert(after->getFieldH256(sfDomainID));
+    }
+
+    if (after && after->getType() == ltOFFER)
+    {
+        if (after->isFieldPresent(sfDomainID))
+            domains_.insert(after->getFieldH256(sfDomainID));
+        else
+            regularOffers_ = true;
+
+        // if a hybrid offer is missing domain or additional book, there's
+        // something wrong
+        if (after->isFlag(lsfHybrid) &&
+            (!after->isFieldPresent(sfDomainID) || !after->isFieldPresent(sfAdditionalBooks) ||
+             after->getFieldArray(sfAdditionalBooks).size() > 1))
+            badHybrids_ = true;
+    }
+}
+
+bool
+ValidPermissionedDEX::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    auto const txType = tx.getTxnType();
+    if ((txType != ttPAYMENT && txType != ttOFFER_CREATE) || result != tesSUCCESS)
+        return true;
+
+    // For each offercreate transaction, check if
+    // permissioned offers are valid
+    if (txType == ttOFFER_CREATE && badHybrids_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: hybrid offer is malformed";
+        return false;
+    }
+
+    if (!tx.isFieldPresent(sfDomainID))
+        return true;
+
+    auto const domain = tx.getFieldH256(sfDomainID);
+
+    if (!view.exists(keylet::permissionedDomain(domain)))
+    {
+        JLOG(j.fatal()) << "Invariant failed: domain doesn't exist";
+        return false;
+    }
+
+    // for both payment and offercreate, there shouldn't be another domain
+    // that's different from the domain specified
+    for (auto const& d : domains_)
+    {
+        if (d != domain)
+        {
+            JLOG(j.fatal()) << "Invariant failed: transaction"
+                               " consumed wrong domains";
+            return false;
+        }
+    }
+
+    if (regularOffers_)
+    {
+        JLOG(j.fatal()) << "Invariant failed: domain transaction"
+                           " affected regular offers";
+        return false;
+    }
+
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp
new file mode 100644
index 0000000000..77acbe12c6
--- /dev/null
+++ b/src/libxrpl/tx/invariants/PermissionedDomainInvariant.cpp
@@ -0,0 +1,162 @@
+#include <xrpl/tx/invariants/PermissionedDomainInvariant.h>
+//
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/TxFormats.h>
+
+namespace xrpl {
+
+void
+ValidPermissionedDomain::visitEntry(
+    bool isDel,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    if (before && before->getType() != ltPERMISSIONED_DOMAIN)
+        return;
+    if (after && after->getType() != ltPERMISSIONED_DOMAIN)
+        return;
+
+    auto check = [isDel](std::vector<SleStatus>& sleStatus, std::shared_ptr<SLE const> const& sle) {
+        auto const& credentials = sle->getFieldArray(sfAcceptedCredentials);
+        auto const sorted = credentials::makeSorted(credentials);
+
+        SleStatus ss{credentials.size(), false, !sorted.empty(), isDel};
+
+        // If array have duplicates then all the other checks are invalid
+        if (ss.isUnique_)
+        {
+            unsigned i = 0;
+            for (auto const& cred : sorted)
+            {
+                auto const& credTx = credentials[i++];
+                ss.isSorted_ =
+                    (cred.first == credTx[sfIssuer]) && (cred.second == credTx[sfCredentialType]);
+                if (!ss.isSorted_)
+                    break;
+            }
+        }
+        sleStatus.emplace_back(std::move(ss));
+    };
+
+    if (after)
+        check(sleStatus_, after);
+}
+
+bool
+ValidPermissionedDomain::finalize(
+    STTx const& tx,
+    TER const result,
+    XRPAmount const,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    auto check = [](SleStatus const& sleStatus, beast::Journal const& j) {
+        if (!sleStatus.credentialsSize_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: permissioned domain with "
+                               "no rules.";
+            return false;
+        }
+
+        if (sleStatus.credentialsSize_ > maxPermissionedDomainCredentialsArraySize)
+        {
+            JLOG(j.fatal()) << "Invariant failed: permissioned domain bad "
+                               "credentials size "
+                            << sleStatus.credentialsSize_;
+            return false;
+        }
+
+        if (!sleStatus.isUnique_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: permissioned domain credentials "
+                               "aren't unique";
+            return false;
+        }
+
+        if (!sleStatus.isSorted_)
+        {
+            JLOG(j.fatal()) << "Invariant failed: permissioned domain credentials "
+                               "aren't sorted";
+            return false;
+        }
+
+        return true;
+    };
+
+    if (view.rules().enabled(fixPermissionedDomainInvariant))
+    {
+        // No permissioned domains should be affected if the transaction failed
+        if (result != tesSUCCESS)
+            // If nothing changed, all is good. If there were changes, that's
+            // bad.
+            return sleStatus_.empty();
+
+        if (sleStatus_.size() > 1)
+        {
+            JLOG(j.fatal()) << "Invariant failed: transaction affected more "
+                               "than 1 permissioned domain entry.";
+            return false;
+        }
+
+        switch (tx.getTxnType())
+        {
+            case ttPERMISSIONED_DOMAIN_SET: {
+                if (sleStatus_.empty())
+                {
+                    JLOG(j.fatal()) << "Invariant failed: no domain objects affected by "
+                                       "PermissionedDomainSet";
+                    return false;
+                }
+
+                auto const& sleStatus = sleStatus_[0];
+                if (sleStatus.isDelete_)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: domain object "
+                                       "deleted by PermissionedDomainSet";
+                    return false;
+                }
+                return check(sleStatus, j);
+            }
+            case ttPERMISSIONED_DOMAIN_DELETE: {
+                if (sleStatus_.empty())
+                {
+                    JLOG(j.fatal()) << "Invariant failed: no domain objects affected by "
+                                       "PermissionedDomainDelete";
+                    return false;
+                }
+
+                if (!sleStatus_[0].isDelete_)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: domain object "
+                                       "modified, but not deleted by "
+                                       "PermissionedDomainDelete";
+                    return false;
+                }
+                return true;
+            }
+            default: {
+                if (!sleStatus_.empty())
+                {
+                    JLOG(j.fatal()) << "Invariant failed: " << sleStatus_.size()
+                                    << " domain object(s) affected by an "
+                                       "unauthorized transaction. "
+                                    << tx.getTxnType();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+    else
+    {
+        if (tx.getTxnType() != ttPERMISSIONED_DOMAIN_SET || result != tesSUCCESS ||
+            sleStatus_.empty())
+            return true;
+        return check(sleStatus_[0], j);
+    }
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/invariants/VaultInvariant.cpp b/src/libxrpl/tx/invariants/VaultInvariant.cpp
new file mode 100644
index 0000000000..c3db3a563a
--- /dev/null
+++ b/src/libxrpl/tx/invariants/VaultInvariant.cpp
@@ -0,0 +1,926 @@
+#include <xrpl/tx/invariants/VaultInvariant.h>
+//
+#include <xrpl/basics/Log.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STNumber.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
+
+namespace xrpl {
+
+ValidVault::Vault
+ValidVault::Vault::make(SLE const& from)
+{
+    XRPL_ASSERT(from.getType() == ltVAULT, "ValidVault::Vault::make : from Vault object");
+
+    ValidVault::Vault self;
+    self.key = from.key();
+    self.asset = from.at(sfAsset);
+    self.pseudoId = from.getAccountID(sfAccount);
+    self.owner = from.at(sfOwner);
+    self.shareMPTID = from.getFieldH192(sfShareMPTID);
+    self.assetsTotal = from.at(sfAssetsTotal);
+    self.assetsAvailable = from.at(sfAssetsAvailable);
+    self.assetsMaximum = from.at(sfAssetsMaximum);
+    self.lossUnrealized = from.at(sfLossUnrealized);
+    return self;
+}
+
+ValidVault::Shares
+ValidVault::Shares::make(SLE const& from)
+{
+    XRPL_ASSERT(
+        from.getType() == ltMPTOKEN_ISSUANCE,
+        "ValidVault::Shares::make : from MPTokenIssuance object");
+
+    ValidVault::Shares self;
+    self.share = MPTIssue(makeMptID(from.getFieldU32(sfSequence), from.getAccountID(sfIssuer)));
+    self.sharesTotal = from.at(sfOutstandingAmount);
+    self.sharesMaximum = from[~sfMaximumAmount].value_or(maxMPTokenAmount);
+    return self;
+}
+
+void
+ValidVault::visitEntry(
+    bool isDelete,
+    std::shared_ptr<SLE const> const& before,
+    std::shared_ptr<SLE const> const& after)
+{
+    // If `before` is empty, this means an object is being created, in which
+    // case `isDelete` must be false. Otherwise `before` and `after` are set and
+    // `isDelete` indicates whether an object is being deleted or modified.
+    XRPL_ASSERT(
+        after != nullptr && (before != nullptr || !isDelete),
+        "xrpl::ValidVault::visitEntry : some object is available");
+
+    // Number balanceDelta will capture the difference (delta) between "before"
+    // state (zero if created) and "after" state (zero if destroyed), so the
+    // invariants can validate that the change in account balances matches the
+    // change in vault balances, stored to deltas_ at the end of this function.
+    Number balanceDelta{};
+
+    std::int8_t sign = 0;
+    if (before)
+    {
+        switch (before->getType())
+        {
+            case ltVAULT:
+                beforeVault_.push_back(Vault::make(*before));
+                break;
+            case ltMPTOKEN_ISSUANCE:
+                // At this moment we have no way of telling if this object holds
+                // vault shares or something else. Save it for finalize.
+                beforeMPTs_.push_back(Shares::make(*before));
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
+                sign = 1;
+                break;
+            case ltMPTOKEN:
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
+                sign = -1;
+                break;
+            case ltACCOUNT_ROOT:
+            case ltRIPPLE_STATE:
+                balanceDelta = before->getFieldAmount(sfBalance);
+                sign = -1;
+                break;
+            default:;
+        }
+    }
+
+    if (!isDelete && after)
+    {
+        switch (after->getType())
+        {
+            case ltVAULT:
+                afterVault_.push_back(Vault::make(*after));
+                break;
+            case ltMPTOKEN_ISSUANCE:
+                // At this moment we have no way of telling if this object holds
+                // vault shares or something else. Save it for finalize.
+                afterMPTs_.push_back(Shares::make(*after));
+                balanceDelta -=
+                    Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
+                sign = 1;
+                break;
+            case ltMPTOKEN:
+                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
+                sign = -1;
+                break;
+            case ltACCOUNT_ROOT:
+            case ltRIPPLE_STATE:
+                balanceDelta -= Number(after->getFieldAmount(sfBalance));
+                sign = -1;
+                break;
+            default:;
+        }
+    }
+
+    uint256 const key = (before ? before->key() : after->key());
+    // Append to deltas if sign is non-zero, i.e. an object of an interesting
+    // type has been updated. A transaction may update an object even when
+    // its balance has not changed, e.g. transaction fee equals the amount
+    // transferred to the account. We intentionally do not compare balanceDelta
+    // against zero, to avoid missing such updates.
+    if (sign != 0)
+        deltas_[key] = balanceDelta * sign;
+}
+
+bool
+ValidVault::finalize(
+    STTx const& tx,
+    TER const ret,
+    XRPAmount const fee,
+    ReadView const& view,
+    beast::Journal const& j)
+{
+    bool const enforce = view.rules().enabled(featureSingleAssetVault);
+
+    if (!isTesSuccess(ret))
+        return true;  // Do not perform checks
+
+    if (afterVault_.empty() && beforeVault_.empty())
+    {
+        if (hasPrivilege(tx, mustModifyVault))
+        {
+            JLOG(j.fatal()) <<  //
+                "Invariant failed: vault operation succeeded without modifying "
+                "a vault";
+            XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault noop invariant");
+            return !enforce;
+        }
+
+        return true;  // Not a vault operation
+    }
+    else if (!(hasPrivilege(tx, mustModifyVault) || hasPrivilege(tx, mayModifyVault)))
+    {
+        JLOG(j.fatal()) <<  //
+            "Invariant failed: vault updated by a wrong transaction type";
+        XRPL_ASSERT(
+            enforce,
+            "xrpl::ValidVault::finalize : illegal vault transaction "
+            "invariant");
+        return !enforce;  // Also not a vault operation
+    }
+
+    if (beforeVault_.size() > 1 || afterVault_.size() > 1)
+    {
+        JLOG(j.fatal()) <<  //
+            "Invariant failed: vault operation updated more than single vault";
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : single vault invariant");
+        return !enforce;  // That's all we can do here
+    }
+
+    auto const txnType = tx.getTxnType();
+
+    // We do special handling for ttVAULT_DELETE first, because it's the only
+    // vault-modifying transaction without an "after" state of the vault
+    if (afterVault_.empty())
+    {
+        if (txnType != ttVAULT_DELETE)
+        {
+            JLOG(j.fatal()) <<  //
+                "Invariant failed: vault deleted by a wrong transaction type";
+            XRPL_ASSERT(
+                enforce,
+                "xrpl::ValidVault::finalize : illegal vault deletion "
+                "invariant");
+            return !enforce;  // That's all we can do here
+        }
+
+        // Note, if afterVault_ is empty then we know that beforeVault_ is not
+        // empty, as enforced at the top of this function
+        auto const& beforeVault = beforeVault_[0];
+
+        // At this moment we only know a vault is being deleted and there
+        // might be some MPTokenIssuance objects which are deleted in the
+        // same transaction. Find the one matching this vault.
+        auto const deletedShares = [&]() -> std::optional<Shares> {
+            for (auto const& e : beforeMPTs_)
+            {
+                if (e.share.getMptID() == beforeVault.shareMPTID)
+                    return std::move(e);
+            }
+            return std::nullopt;
+        }();
+
+        if (!deletedShares)
+        {
+            JLOG(j.fatal()) << "Invariant failed: deleted vault must also "
+                               "delete shares";
+            XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : shares deletion invariant");
+            return !enforce;  // That's all we can do here
+        }
+
+        bool result = true;
+        if (deletedShares->sharesTotal != 0)
+        {
+            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
+                               "shares outstanding";
+            result = false;
+        }
+        if (beforeVault.assetsTotal != zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
+                               "assets outstanding";
+            result = false;
+        }
+        if (beforeVault.assetsAvailable != zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: deleted vault must have no "
+                               "assets available";
+            result = false;
+        }
+
+        return result;
+    }
+    else if (txnType == ttVAULT_DELETE)
+    {
+        JLOG(j.fatal()) << "Invariant failed: vault deletion succeeded without "
+                           "deleting a vault";
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault deletion invariant");
+        return !enforce;  // That's all we can do here
+    }
+
+    // Note, `afterVault_.empty()` is handled above
+    auto const& afterVault = afterVault_[0];
+    XRPL_ASSERT(
+        beforeVault_.empty() || beforeVault_[0].key == afterVault.key,
+        "xrpl::ValidVault::finalize : single vault operation");
+
+    auto const updatedShares = [&]() -> std::optional<Shares> {
+        // At this moment we only know that a vault is being updated and there
+        // might be some MPTokenIssuance objects which are also updated in the
+        // same transaction. Find the one matching the shares to this vault.
+        // Note, we expect updatedMPTs collection to be extremely small. For
+        // such collections linear search is faster than lookup.
+        for (auto const& e : afterMPTs_)
+        {
+            if (e.share.getMptID() == afterVault.shareMPTID)
+                return e;
+        }
+
+        auto const sleShares = view.read(keylet::mptIssuance(afterVault.shareMPTID));
+
+        return sleShares ? std::optional<Shares>(Shares::make(*sleShares)) : std::nullopt;
+    }();
+
+    bool result = true;
+
+    // Universal transaction checks
+    if (!beforeVault_.empty())
+    {
+        auto const& beforeVault = beforeVault_[0];
+        if (afterVault.asset != beforeVault.asset || afterVault.pseudoId != beforeVault.pseudoId ||
+            afterVault.shareMPTID != beforeVault.shareMPTID)
+        {
+            JLOG(j.fatal()) << "Invariant failed: violation of vault immutable data";
+            result = false;
+        }
+    }
+
+    if (!updatedShares)
+    {
+        JLOG(j.fatal()) << "Invariant failed: updated vault must have shares";
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault has shares invariant");
+        return !enforce;  // That's all we can do here
+    }
+
+    if (updatedShares->sharesTotal == 0)
+    {
+        if (afterVault.assetsTotal != zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: updated zero sized "
+                               "vault must have no assets outstanding";
+            result = false;
+        }
+        if (afterVault.assetsAvailable != zero)
+        {
+            JLOG(j.fatal()) << "Invariant failed: updated zero sized "
+                               "vault must have no assets available";
+            result = false;
+        }
+    }
+    else if (updatedShares->sharesTotal > updatedShares->sharesMaximum)
+    {
+        JLOG(j.fatal())  //
+            << "Invariant failed: updated shares must not exceed maximum "
+            << updatedShares->sharesMaximum;
+        result = false;
+    }
+
+    if (afterVault.assetsAvailable < zero)
+    {
+        JLOG(j.fatal()) << "Invariant failed: assets available must be positive";
+        result = false;
+    }
+
+    if (afterVault.assetsAvailable > afterVault.assetsTotal)
+    {
+        JLOG(j.fatal()) << "Invariant failed: assets available must "
+                           "not be greater than assets outstanding";
+        result = false;
+    }
+    else if (afterVault.lossUnrealized > afterVault.assetsTotal - afterVault.assetsAvailable)
+    {
+        JLOG(j.fatal())  //
+            << "Invariant failed: loss unrealized must not exceed "
+               "the difference between assets outstanding and available";
+        result = false;
+    }
+
+    if (afterVault.assetsTotal < zero)
+    {
+        JLOG(j.fatal()) << "Invariant failed: assets outstanding must be positive";
+        result = false;
+    }
+
+    if (afterVault.assetsMaximum < zero)
+    {
+        JLOG(j.fatal()) << "Invariant failed: assets maximum must be positive";
+        result = false;
+    }
+
+    // Thanks to this check we can simply do `assert(!beforeVault_.empty()` when
+    // enforcing invariants on transaction types other than ttVAULT_CREATE
+    if (beforeVault_.empty() && txnType != ttVAULT_CREATE)
+    {
+        JLOG(j.fatal()) <<  //
+            "Invariant failed: vault created by a wrong transaction type";
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault creation invariant");
+        return !enforce;  // That's all we can do here
+    }
+
+    if (!beforeVault_.empty() && afterVault.lossUnrealized != beforeVault_[0].lossUnrealized &&
+        txnType != ttLOAN_MANAGE && txnType != ttLOAN_PAY)
+    {
+        JLOG(j.fatal()) <<  //
+            "Invariant failed: vault transaction must not change loss "
+            "unrealized";
+        result = false;
+    }
+
+    auto const beforeShares = [&]() -> std::optional<Shares> {
+        if (beforeVault_.empty())
+            return std::nullopt;
+        auto const& beforeVault = beforeVault_[0];
+
+        for (auto const& e : beforeMPTs_)
+        {
+            if (e.share.getMptID() == beforeVault.shareMPTID)
+                return std::move(e);
+        }
+        return std::nullopt;
+    }();
+
+    if (!beforeShares &&
+        (tx.getTxnType() == ttVAULT_DEPOSIT ||   //
+         tx.getTxnType() == ttVAULT_WITHDRAW ||  //
+         tx.getTxnType() == ttVAULT_CLAWBACK))
+    {
+        JLOG(j.fatal()) << "Invariant failed: vault operation succeeded "
+                           "without updating shares";
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : shares noop invariant");
+        return !enforce;  // That's all we can do here
+    }
+
+    auto const& vaultAsset = afterVault.asset;
+    auto const deltaAssets = [&](AccountID const& id) -> std::optional<Number> {
+        auto const get =  //
+            [&](auto const& it, std::int8_t sign = 1) -> std::optional<Number> {
+            if (it == deltas_.end())
+                return std::nullopt;
+
+            return it->second * sign;
+        };
+
+        return std::visit(
+            [&]<typename TIss>(TIss const& issue) {
+                if constexpr (std::is_same_v<TIss, Issue>)
+                {
+                    if (isXRP(issue))
+                        return get(deltas_.find(keylet::account(id).key));
+                    return get(
+                        deltas_.find(keylet::line(id, issue).key), id > issue.getIssuer() ? -1 : 1);
+                }
+                else if constexpr (std::is_same_v<TIss, MPTIssue>)
+                {
+                    return get(deltas_.find(keylet::mptoken(issue.getMptID(), id).key));
+                }
+            },
+            vaultAsset.value());
+    };
+    auto const deltaAssetsTxAccount = [&]() -> std::optional<Number> {
+        auto ret = deltaAssets(tx[sfAccount]);
+        // Nothing returned or not XRP transaction
+        if (!ret.has_value() || !vaultAsset.native())
+            return ret;
+
+        // Delegated transaction; no need to compensate for fees
+        if (auto const delegate = tx[~sfDelegate];
+            delegate.has_value() && *delegate != tx[sfAccount])
+            return ret;
+
+        *ret += fee.drops();
+        if (*ret == zero)
+            return std::nullopt;
+
+        return ret;
+    };
+    auto const deltaShares = [&](AccountID const& id) -> std::optional<Number> {
+        auto const it = [&]() {
+            if (id == afterVault.pseudoId)
+                return deltas_.find(keylet::mptIssuance(afterVault.shareMPTID).key);
+            return deltas_.find(keylet::mptoken(afterVault.shareMPTID, id).key);
+        }();
+
+        return it != deltas_.end() ? std::optional<Number>(it->second) : std::nullopt;
+    };
+
+    auto const vaultHoldsNoAssets = [&](Vault const& vault) {
+        return vault.assetsAvailable == 0 && vault.assetsTotal == 0;
+    };
+
+    // Technically this does not need to be a lambda, but it's more
+    // convenient thanks to early "return false"; the not-so-nice
+    // alternatives are several layers of nested if/else or more complex
+    // (i.e. brittle) if statements.
+    result &= [&]() {
+        switch (txnType)
+        {
+            case ttVAULT_CREATE: {
+                bool result = true;
+
+                if (!beforeVault_.empty())
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: create operation must not have "
+                           "updated a vault";
+                    result = false;
+                }
+
+                if (afterVault.assetsAvailable != zero || afterVault.assetsTotal != zero ||
+                    afterVault.lossUnrealized != zero || updatedShares->sharesTotal != 0)
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: created vault must be empty";
+                    result = false;
+                }
+
+                if (afterVault.pseudoId != updatedShares->share.getIssuer())
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: shares issuer and vault "
+                           "pseudo-account must be the same";
+                    result = false;
+                }
+
+                auto const sleSharesIssuer =
+                    view.read(keylet::account(updatedShares->share.getIssuer()));
+                if (!sleSharesIssuer)
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: shares issuer must exist";
+                    return false;
+                }
+
+                if (!isPseudoAccount(sleSharesIssuer))
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: shares issuer must be a "
+                           "pseudo-account";
+                    result = false;
+                }
+
+                if (auto const vaultId = (*sleSharesIssuer)[~sfVaultID];
+                    !vaultId || *vaultId != afterVault.key)
+                {
+                    JLOG(j.fatal())  //
+                        << "Invariant failed: shares issuer pseudo-account "
+                           "must point back to the vault";
+                    result = false;
+                }
+
+                return result;
+            }
+            case ttVAULT_SET: {
+                bool result = true;
+
+                XRPL_ASSERT(
+                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : set updated a vault");
+                auto const& beforeVault = beforeVault_[0];
+
+                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                if (vaultDeltaAssets)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: set must not change vault balance";
+                    result = false;
+                }
+
+                if (beforeVault.assetsTotal != afterVault.assetsTotal)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: set must not change assets "
+                        "outstanding";
+                    result = false;
+                }
+
+                if (afterVault.assetsMaximum > zero &&
+                    afterVault.assetsTotal > afterVault.assetsMaximum)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: set assets outstanding must not "
+                        "exceed assets maximum";
+                    result = false;
+                }
+
+                if (beforeVault.assetsAvailable != afterVault.assetsAvailable)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: set must not change assets "
+                        "available";
+                    result = false;
+                }
+
+                if (beforeShares && updatedShares &&
+                    beforeShares->sharesTotal != updatedShares->sharesTotal)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: set must not change shares "
+                        "outstanding";
+                    result = false;
+                }
+
+                return result;
+            }
+            case ttVAULT_DEPOSIT: {
+                bool result = true;
+
+                XRPL_ASSERT(
+                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : deposit updated a vault");
+                auto const& beforeVault = beforeVault_[0];
+
+                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+
+                if (!vaultDeltaAssets)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must change vault balance";
+                    return false;  // That's all we can do
+                }
+
+                if (*vaultDeltaAssets > tx[sfAmount])
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must not change vault "
+                        "balance by more than deposited amount";
+                    result = false;
+                }
+
+                if (*vaultDeltaAssets <= zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must increase vault balance";
+                    result = false;
+                }
+
+                // Any payments (including deposits) made by the issuer
+                // do not change their balance, but create funds instead.
+                bool const issuerDeposit = [&]() -> bool {
+                    if (vaultAsset.native())
+                        return false;
+                    return tx[sfAccount] == vaultAsset.getIssuer();
+                }();
+
+                if (!issuerDeposit)
+                {
+                    auto const accountDeltaAssets = deltaAssetsTxAccount();
+                    if (!accountDeltaAssets)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: deposit must change depositor "
+                            "balance";
+                        return false;
+                    }
+
+                    if (*accountDeltaAssets >= zero)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: deposit must decrease depositor "
+                            "balance";
+                        result = false;
+                    }
+
+                    if (*accountDeltaAssets * -1 != *vaultDeltaAssets)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: deposit must change vault and "
+                            "depositor balance by equal amount";
+                        result = false;
+                    }
+                }
+
+                if (afterVault.assetsMaximum > zero &&
+                    afterVault.assetsTotal > afterVault.assetsMaximum)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit assets outstanding must not "
+                        "exceed assets maximum";
+                    result = false;
+                }
+
+                auto const accountDeltaShares = deltaShares(tx[sfAccount]);
+                if (!accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must change depositor "
+                        "shares";
+                    return false;  // That's all we can do
+                }
+
+                if (*accountDeltaShares <= zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must increase depositor "
+                        "shares";
+                    result = false;
+                }
+
+                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
+                if (!vaultDeltaShares || *vaultDeltaShares == zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must change vault shares";
+                    return false;  // That's all we can do
+                }
+
+                if (*vaultDeltaShares * -1 != *accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: deposit must change depositor and "
+                        "vault shares by equal amount";
+                    result = false;
+                }
+
+                if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: deposit and assets "
+                                       "outstanding must add up";
+                    result = false;
+                }
+                if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: deposit and assets "
+                                       "available must add up";
+                    result = false;
+                }
+
+                return result;
+            }
+            case ttVAULT_WITHDRAW: {
+                bool result = true;
+
+                XRPL_ASSERT(
+                    !beforeVault_.empty(),
+                    "xrpl::ValidVault::finalize : withdrawal updated a "
+                    "vault");
+                auto const& beforeVault = beforeVault_[0];
+
+                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+
+                if (!vaultDeltaAssets)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: withdrawal must "
+                                       "change vault balance";
+                    return false;  // That's all we can do
+                }
+
+                if (*vaultDeltaAssets >= zero)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: withdrawal must "
+                                       "decrease vault balance";
+                    result = false;
+                }
+
+                // Any payments (including withdrawal) going to the issuer
+                // do not change their balance, but destroy funds instead.
+                bool const issuerWithdrawal = [&]() -> bool {
+                    if (vaultAsset.native())
+                        return false;
+                    auto const destination = tx[~sfDestination].value_or(tx[sfAccount]);
+                    return destination == vaultAsset.getIssuer();
+                }();
+
+                if (!issuerWithdrawal)
+                {
+                    auto const accountDeltaAssets = deltaAssetsTxAccount();
+                    auto const otherAccountDelta = [&]() -> std::optional<Number> {
+                        if (auto const destination = tx[~sfDestination];
+                            destination && *destination != tx[sfAccount])
+                            return deltaAssets(*destination);
+                        return std::nullopt;
+                    }();
+
+                    if (accountDeltaAssets.has_value() == otherAccountDelta.has_value())
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: withdrawal must change one "
+                            "destination balance";
+                        return false;
+                    }
+
+                    auto const destinationDelta =  //
+                        accountDeltaAssets ? *accountDeltaAssets : *otherAccountDelta;
+
+                    if (destinationDelta <= zero)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: withdrawal must increase "
+                            "destination balance";
+                        result = false;
+                    }
+
+                    if (*vaultDeltaAssets * -1 != destinationDelta)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: withdrawal must change vault "
+                            "and destination balance by equal amount";
+                        result = false;
+                    }
+                }
+
+                auto const accountDeltaShares = deltaShares(tx[sfAccount]);
+                if (!accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: withdrawal must change depositor "
+                        "shares";
+                    return false;
+                }
+
+                if (*accountDeltaShares >= zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: withdrawal must decrease depositor "
+                        "shares";
+                    result = false;
+                }
+
+                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
+                if (!vaultDeltaShares || *vaultDeltaShares == zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: withdrawal must change vault shares";
+                    return false;  // That's all we can do
+                }
+
+                if (*vaultDeltaShares * -1 != *accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: withdrawal must change depositor "
+                        "and vault shares by equal amount";
+                    result = false;
+                }
+
+                // Note, vaultBalance is negative (see check above)
+                if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: withdrawal and "
+                                       "assets outstanding must add up";
+                    result = false;
+                }
+
+                if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
+                {
+                    JLOG(j.fatal()) << "Invariant failed: withdrawal and "
+                                       "assets available must add up";
+                    result = false;
+                }
+
+                return result;
+            }
+            case ttVAULT_CLAWBACK: {
+                bool result = true;
+
+                XRPL_ASSERT(
+                    !beforeVault_.empty(), "xrpl::ValidVault::finalize : clawback updated a vault");
+                auto const& beforeVault = beforeVault_[0];
+
+                if (vaultAsset.native() || vaultAsset.getIssuer() != tx[sfAccount])
+                {
+                    // The owner can use clawback to force-burn shares when the
+                    // vault is empty but there are outstanding shares
+                    if (!(beforeShares && beforeShares->sharesTotal > 0 &&
+                          vaultHoldsNoAssets(beforeVault) && beforeVault.owner == tx[sfAccount]))
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: clawback may only be performed "
+                            "by the asset issuer, or by the vault owner of an "
+                            "empty vault";
+                        return false;  // That's all we can do
+                    }
+                }
+
+                auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                if (vaultDeltaAssets)
+                {
+                    if (*vaultDeltaAssets >= zero)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: clawback must decrease vault "
+                            "balance";
+                        result = false;
+                    }
+
+                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: clawback and assets outstanding "
+                            "must add up";
+                        result = false;
+                    }
+
+                    if (beforeVault.assetsAvailable + *vaultDeltaAssets !=
+                        afterVault.assetsAvailable)
+                    {
+                        JLOG(j.fatal()) <<  //
+                            "Invariant failed: clawback and assets available "
+                            "must add up";
+                        result = false;
+                    }
+                }
+                else if (!vaultHoldsNoAssets(beforeVault))
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: clawback must change vault balance";
+                    return false;  // That's all we can do
+                }
+
+                auto const accountDeltaShares = deltaShares(tx[sfHolder]);
+                if (!accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: clawback must change holder shares";
+                    return false;  // That's all we can do
+                }
+
+                if (*accountDeltaShares >= zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: clawback must decrease holder "
+                        "shares";
+                    result = false;
+                }
+
+                auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
+                if (!vaultDeltaShares || *vaultDeltaShares == zero)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: clawback must change vault shares";
+                    return false;  // That's all we can do
+                }
+
+                if (*vaultDeltaShares * -1 != *accountDeltaShares)
+                {
+                    JLOG(j.fatal()) <<  //
+                        "Invariant failed: clawback must change holder and "
+                        "vault shares by equal amount";
+                    result = false;
+                }
+
+                return result;
+            }
+
+            case ttLOAN_SET:
+            case ttLOAN_MANAGE:
+            case ttLOAN_PAY: {
+                // TBD
+                return true;
+            }
+
+            default:
+                // LCOV_EXCL_START
+                UNREACHABLE("xrpl::ValidVault::finalize : unknown transaction type");
+                return false;
+                // LCOV_EXCL_STOP
+        }
+    }();
+
+    if (!result)
+    {
+        // The comment at the top of this file starting with "assert(enforce)"
+        // explains this assert.
+        XRPL_ASSERT(enforce, "xrpl::ValidVault::finalize : vault invariants");
+        return !enforce;
+    }
+
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/paths/Flow.cpp b/src/libxrpl/tx/paths/Flow.cpp
index 2178997049..3e9adca814 100644
--- a/src/libxrpl/tx/paths/Flow.cpp
+++ b/src/libxrpl/tx/paths/Flow.cpp
@@ -6,7 +6,7 @@
 #include <xrpl/tx/paths/detail/AmountSpec.h>
 #include <xrpl/tx/paths/detail/Steps.h>
 #include <xrpl/tx/paths/detail/StrandFlow.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp
index 9d2a94e3a8..596ae36b96 100644
--- a/src/libxrpl/tx/paths/OfferStream.cpp
+++ b/src/libxrpl/tx/paths/OfferStream.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/tx/paths/OfferStream.h>
-#include <xrpl/tx/transactors/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/dex/PermissionedDEXHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Credentials.cpp b/src/libxrpl/tx/transactors/Credentials.cpp
deleted file mode 100644
index ce95d8144c..0000000000
--- a/src/libxrpl/tx/transactors/Credentials.cpp
+++ /dev/null
@@ -1,341 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Credentials.h>
-
-#include <chrono>
-
-namespace xrpl {
-
-/*
-    Credentials
-    ======
-
-   A verifiable credentials (VC
-   https://en.wikipedia.org/wiki/Verifiable_credentials), as defined by the W3C
-   specification (https://www.w3.org/TR/vc-data-model-2.0/), is a
-   secure and tamper-evident way to represent information about a subject, such
-   as an individual, organization, or even an IoT device. These credentials are
-   issued by a trusted entity and can be verified by third parties without
-   directly involving the issuer at all.
-*/
-
-using namespace credentials;
-
-// ------- CREATE --------------------------
-
-std::uint32_t
-CredentialCreate::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialCreate::preflight(PreflightContext const& ctx)
-{
-    auto const& tx = ctx.tx;
-    auto& j = ctx.j;
-
-    if (!tx[sfSubject])
-    {
-        JLOG(j.trace()) << "Malformed transaction: Invalid Subject";
-        return temMALFORMED;
-    }
-
-    auto const uri = tx[~sfURI];
-    if (uri && (uri->empty() || (uri->size() > maxCredentialURILength)))
-    {
-        JLOG(j.trace()) << "Malformed transaction: invalid size of URI.";
-        return temMALFORMED;
-    }
-
-    auto const credType = tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialCreate::preclaim(PreclaimContext const& ctx)
-{
-    auto const credType(ctx.tx[sfCredentialType]);
-    auto const subject = ctx.tx[sfSubject];
-
-    if (!ctx.view.exists(keylet::account(subject)))
-    {
-        JLOG(ctx.j.trace()) << "Subject doesn't exist.";
-        return tecNO_TARGET;
-    }
-
-    if (ctx.view.exists(keylet::credential(subject, ctx.tx[sfAccount], credType)))
-    {
-        JLOG(ctx.j.trace()) << "Credential already exists.";
-        return tecDUPLICATE;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialCreate::doApply()
-{
-    auto const subject = ctx_.tx[sfSubject];
-    auto const credType(ctx_.tx[sfCredentialType]);
-    Keylet const credentialKey = keylet::credential(subject, account_, credType);
-
-    auto const sleCred = std::make_shared<SLE>(credentialKey);
-    if (!sleCred)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const optExp = ctx_.tx[~sfExpiration];
-    if (optExp)
-    {
-        std::uint32_t const closeTime =
-            ctx_.view().header().parentCloseTime.time_since_epoch().count();
-
-        if (closeTime > *optExp)
-        {
-            JLOG(j_.trace()) << "Malformed transaction: "
-                                "Expiration time is in the past.";
-            return tecEXPIRED;
-        }
-
-        sleCred->setFieldU32(sfExpiration, ctx_.tx.getFieldU32(sfExpiration));
-    }
-
-    auto const sleIssuer = view().peek(keylet::account(account_));
-    if (!sleIssuer)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        STAmount const reserve{
-            view().fees().accountReserve(sleIssuer->getFieldU32(sfOwnerCount) + 1)};
-        if (mPriorBalance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-    }
-
-    sleCred->setAccountID(sfSubject, subject);
-    sleCred->setAccountID(sfIssuer, account_);
-    sleCred->setFieldVL(sfCredentialType, credType);
-
-    if (ctx_.tx.isFieldPresent(sfURI))
-        sleCred->setFieldVL(sfURI, ctx_.tx.getFieldVL(sfURI));
-
-    {
-        auto const page =
-            view().dirInsert(keylet::ownerDir(account_), credentialKey, describeOwnerDir(account_));
-        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
-                         << ": " << (page ? "success" : "failure");
-        if (!page)
-            return tecDIR_FULL;
-        sleCred->setFieldU64(sfIssuerNode, *page);
-
-        adjustOwnerCount(view(), sleIssuer, 1, j_);
-    }
-
-    if (subject == account_)
-    {
-        sleCred->setFieldU32(sfFlags, lsfAccepted);
-    }
-    else
-    {
-        auto const page =
-            view().dirInsert(keylet::ownerDir(subject), credentialKey, describeOwnerDir(subject));
-        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
-                         << ": " << (page ? "success" : "failure");
-        if (!page)
-            return tecDIR_FULL;
-        sleCred->setFieldU64(sfSubjectNode, *page);
-        view().update(view().peek(keylet::account(subject)));
-    }
-
-    view().insert(sleCred);
-
-    return tesSUCCESS;
-}
-
-// ------- DELETE --------------------------
-
-std::uint32_t
-CredentialDelete::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialDelete::preflight(PreflightContext const& ctx)
-{
-    auto const subject = ctx.tx[~sfSubject];
-    auto const issuer = ctx.tx[~sfIssuer];
-
-    if (!subject && !issuer)
-    {
-        // Neither field is present, the transaction is malformed.
-        JLOG(ctx.j.trace()) << "Malformed transaction: "
-                               "No Subject or Issuer fields.";
-        return temMALFORMED;
-    }
-
-    // Make sure that the passed account is valid.
-    if ((subject && subject->isZero()) || (issuer && issuer->isZero()))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: Subject or Issuer "
-                               "field zeroed.";
-        return temINVALID_ACCOUNT_ID;
-    }
-
-    auto const credType = ctx.tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialDelete::preclaim(PreclaimContext const& ctx)
-{
-    AccountID const account{ctx.tx[sfAccount]};
-    auto const subject = ctx.tx[~sfSubject].value_or(account);
-    auto const issuer = ctx.tx[~sfIssuer].value_or(account);
-    auto const credType(ctx.tx[sfCredentialType]);
-
-    if (!ctx.view.exists(keylet::credential(subject, issuer, credType)))
-        return tecNO_ENTRY;
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialDelete::doApply()
-{
-    auto const subject = ctx_.tx[~sfSubject].value_or(account_);
-    auto const issuer = ctx_.tx[~sfIssuer].value_or(account_);
-
-    auto const credType(ctx_.tx[sfCredentialType]);
-    auto const sleCred = view().peek(keylet::credential(subject, issuer, credType));
-    if (!sleCred)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    if ((subject != account_) && (issuer != account_) &&
-        !checkExpired(sleCred, ctx_.view().header().parentCloseTime))
-    {
-        JLOG(j_.trace()) << "Can't delete non-expired credential.";
-        return tecNO_PERMISSION;
-    }
-
-    return deleteSLE(view(), sleCred, j_);
-}
-
-// ------- APPLY --------------------------
-
-std::uint32_t
-CredentialAccept::getFlagsMask(PreflightContext const& ctx)
-{
-    // 0 means "Allow any flags"
-    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
-}
-
-NotTEC
-CredentialAccept::preflight(PreflightContext const& ctx)
-{
-    if (!ctx.tx[sfIssuer])
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: Issuer field zeroed.";
-        return temINVALID_ACCOUNT_ID;
-    }
-
-    auto const credType = ctx.tx[sfCredentialType];
-    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
-    {
-        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
-        return temMALFORMED;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialAccept::preclaim(PreclaimContext const& ctx)
-{
-    AccountID const subject = ctx.tx[sfAccount];
-    AccountID const issuer = ctx.tx[sfIssuer];
-    auto const credType(ctx.tx[sfCredentialType]);
-
-    if (!ctx.view.exists(keylet::account(issuer)))
-    {
-        JLOG(ctx.j.warn()) << "No issuer: " << to_string(issuer);
-        return tecNO_ISSUER;
-    }
-
-    auto const sleCred = ctx.view.read(keylet::credential(subject, issuer, credType));
-    if (!sleCred)
-    {
-        JLOG(ctx.j.warn()) << "No credential: " << to_string(subject) << ", " << to_string(issuer)
-                           << ", " << credType;
-        return tecNO_ENTRY;
-    }
-
-    if (sleCred->getFieldU32(sfFlags) & lsfAccepted)
-    {
-        JLOG(ctx.j.warn()) << "Credential already accepted: " << to_string(subject) << ", "
-                           << to_string(issuer) << ", " << credType;
-        return tecDUPLICATE;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-CredentialAccept::doApply()
-{
-    AccountID const issuer{ctx_.tx[sfIssuer]};
-
-    // Both exist as credential object exist itself (checked in preclaim)
-    auto const sleSubject = view().peek(keylet::account(account_));
-    auto const sleIssuer = view().peek(keylet::account(issuer));
-
-    if (!sleSubject || !sleIssuer)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        STAmount const reserve{
-            view().fees().accountReserve(sleSubject->getFieldU32(sfOwnerCount) + 1)};
-        if (mPriorBalance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-    }
-
-    auto const credType(ctx_.tx[sfCredentialType]);
-    Keylet const credentialKey = keylet::credential(account_, issuer, credType);
-    auto const sleCred = view().peek(credentialKey);  // Checked in preclaim()
-
-    if (checkExpired(sleCred, view().header().parentCloseTime))
-    {
-        JLOG(j_.trace()) << "Credential is expired: " << sleCred->getText();
-        // delete expired credentials even if the transaction failed
-        auto const err = credentials::deleteSLE(view(), sleCred, j_);
-        return isTesSuccess(err) ? tecEXPIRED : err;
-    }
-
-    sleCred->setFieldU32(sfFlags, lsfAccepted);
-    view().update(sleCred);
-
-    adjustOwnerCount(view(), sleIssuer, -1, j_);
-    adjustOwnerCount(view(), sleSubject, 1, j_);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/Escrow.cpp b/src/libxrpl/tx/transactors/Escrow.cpp
deleted file mode 100644
index 8ea2de24d9..0000000000
--- a/src/libxrpl/tx/transactors/Escrow.cpp
+++ /dev/null
@@ -1,1262 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/conditions/Condition.h>
-#include <xrpl/conditions/Fulfillment.h>
-#include <xrpl/core/HashRouter.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/MPTAmount.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/tx/transactors/Escrow.h>
-#include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
-
-namespace xrpl {
-
-// During an EscrowFinish, the transaction must specify both
-// a condition and a fulfillment. We track whether that
-// fulfillment matches and validates the condition.
-constexpr HashRouterFlags SF_CF_INVALID = HashRouterFlags::PRIVATE5;
-constexpr HashRouterFlags SF_CF_VALID = HashRouterFlags::PRIVATE6;
-
-/*
-    Escrow
-    ======
-
-    Escrow is a feature of the XRP Ledger that allows you to send conditional
-    XRP payments. These conditional payments, called escrows, set aside XRP and
-    deliver it later when certain conditions are met. Conditions to successfully
-    finish an escrow include time-based unlocks and crypto-conditions. Escrows
-    can also be set to expire if not finished in time.
-
-    The XRP set aside in an escrow is locked up. No one can use or destroy the
-    XRP until the escrow has been successfully finished or canceled. Before the
-    expiration time, only the intended receiver can get the XRP. After the
-    expiration time, the XRP can only be returned to the sender.
-
-    For more details on escrow, including examples, diagrams and more please
-    visit https://xrpl.org/escrow.html
-
-    For details on specific transactions, including fields and validation rules
-    please see:
-
-    `EscrowCreate`
-    --------------
-        See: https://xrpl.org/escrowcreate.html
-
-    `EscrowFinish`
-    --------------
-        See: https://xrpl.org/escrowfinish.html
-
-    `EscrowCancel`
-    --------------
-        See: https://xrpl.org/escrowcancel.html
-*/
-
-//------------------------------------------------------------------------------
-
-TxConsequences
-EscrowCreate::makeTxConsequences(PreflightContext const& ctx)
-{
-    auto const amount = ctx.tx[sfAmount];
-    return TxConsequences{ctx.tx, isXRP(amount) ? amount.xrp() : beast::zero};
-}
-
-template <ValidIssueType T>
-static NotTEC
-escrowCreatePreflightHelper(PreflightContext const& ctx);
-
-template <>
-NotTEC
-escrowCreatePreflightHelper<Issue>(PreflightContext const& ctx)
-{
-    STAmount const amount = ctx.tx[sfAmount];
-    if (amount.native() || amount <= beast::zero)
-        return temBAD_AMOUNT;
-
-    if (badCurrency() == amount.getCurrency())
-        return temBAD_CURRENCY;
-
-    return tesSUCCESS;
-}
-
-template <>
-NotTEC
-escrowCreatePreflightHelper<MPTIssue>(PreflightContext const& ctx)
-{
-    if (!ctx.rules.enabled(featureMPTokensV1))
-        return temDISABLED;
-
-    auto const amount = ctx.tx[sfAmount];
-    if (amount.native() || amount.mpt() > MPTAmount{maxMPTokenAmount} || amount <= beast::zero)
-        return temBAD_AMOUNT;
-
-    return tesSUCCESS;
-}
-
-NotTEC
-EscrowCreate::preflight(PreflightContext const& ctx)
-{
-    STAmount const amount{ctx.tx[sfAmount]};
-    if (!isXRP(amount))
-    {
-        if (!ctx.rules.enabled(featureTokenEscrow))
-            return temBAD_AMOUNT;
-
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) { return escrowCreatePreflightHelper<T>(ctx); },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-    }
-    else
-    {
-        if (amount <= beast::zero)
-            return temBAD_AMOUNT;
-    }
-
-    // We must specify at least one timeout value
-    if (!ctx.tx[~sfCancelAfter] && !ctx.tx[~sfFinishAfter])
-        return temBAD_EXPIRATION;
-
-    // If both finish and cancel times are specified then the cancel time must
-    // be strictly after the finish time.
-    if (ctx.tx[~sfCancelAfter] && ctx.tx[~sfFinishAfter] &&
-        ctx.tx[sfCancelAfter] <= ctx.tx[sfFinishAfter])
-        return temBAD_EXPIRATION;
-
-    // In the absence of a FinishAfter, the escrow can be finished
-    // immediately, which can be confusing. When creating an escrow,
-    // we want to ensure that either a FinishAfter time is explicitly
-    // specified or a completion condition is attached.
-    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition])
-        return temMALFORMED;
-
-    if (auto const cb = ctx.tx[~sfCondition])
-    {
-        using namespace xrpl::cryptoconditions;
-
-        std::error_code ec;
-
-        auto condition = Condition::deserialize(*cb, ec);
-        if (!condition)
-        {
-            JLOG(ctx.j.debug()) << "Malformed condition during escrow creation: " << ec.message();
-            return temMALFORMED;
-        }
-    }
-
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowCreatePreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount);
-
-template <>
-TER
-escrowCreatePreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecNO_PERMISSION
-    if (issuer == account)
-        return tecNO_PERMISSION;
-
-    // If the lsfAllowTrustLineLocking is not enabled, return tecNO_PERMISSION
-    auto const sleIssuer = ctx.view.read(keylet::account(issuer));
-    if (!sleIssuer)
-        return tecNO_ISSUER;
-    if (!sleIssuer->isFlag(lsfAllowTrustLineLocking))
-        return tecNO_PERMISSION;
-
-    // If the account does not have a trustline to the issuer, return tecNO_LINE
-    auto const sleRippleState = ctx.view.read(keylet::line(account, issuer, amount.getCurrency()));
-    if (!sleRippleState)
-        return tecNO_LINE;
-
-    STAmount const balance = (*sleRippleState)[sfBalance];
-
-    // If balance is positive, issuer must have higher address than account
-    if (balance > beast::zero && issuer < account)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If balance is negative, issuer must have lower address than account
-    if (balance < beast::zero && issuer > account)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If the issuer has requireAuth set, check if the account is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has requireAuth set, check if the destination is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the account, return tecFROZEN
-    if (isFrozen(ctx.view, account, amount.issue()))
-        return tecFROZEN;
-
-    // If the issuer has frozen the destination, return tecFROZEN
-    if (isFrozen(ctx.view, dest, amount.issue()))
-        return tecFROZEN;
-
-    STAmount const spendableAmount =
-        accountHolds(ctx.view, account, amount.getCurrency(), issuer, fhIGNORE_FREEZE, ctx.j);
-
-    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
-    if (spendableAmount <= beast::zero)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the spendable amount is less than the amount, return
-    // tecINSUFFICIENT_FUNDS
-    if (spendableAmount < amount)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the amount is not addable to the balance, return tecPRECISION_LOSS
-    if (!canAdd(spendableAmount, amount))
-        return tecPRECISION_LOSS;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowCreatePreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecNO_PERMISSION
-    if (issuer == account)
-        return tecNO_PERMISSION;
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the lsfMPTCanEscrow is not enabled, return tecNO_PERMISSION
-    if (!sleIssuance->isFlag(lsfMPTCanEscrow))
-        return tecNO_PERMISSION;
-
-    // If the issuer is not the same as the issuer of the mpt, return
-    // tecNO_PERMISSION
-    if (sleIssuance->getAccountID(sfIssuer) != issuer)
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-
-    // If the account does not have the mpt, return tecOBJECT_NOT_FOUND
-    if (!ctx.view.exists(keylet::mptoken(issuanceKey.key, account)))
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the account is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has requireAuth set, check if the destination is
-    // authorized
-    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the account, return tecLOCKED
-    if (isFrozen(ctx.view, account, mptIssue))
-        return tecLOCKED;
-
-    // If the issuer has frozen the destination, return tecLOCKED
-    if (isFrozen(ctx.view, dest, mptIssue))
-        return tecLOCKED;
-
-    // If the mpt cannot be transferred, return tecNO_AUTH
-    if (auto const ter = canTransfer(ctx.view, mptIssue, account, dest); ter != tesSUCCESS)
-        return ter;
-
-    STAmount const spendableAmount = accountHolds(
-        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j);
-
-    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
-    if (spendableAmount <= beast::zero)
-        return tecINSUFFICIENT_FUNDS;
-
-    // If the spendable amount is less than the amount, return
-    // tecINSUFFICIENT_FUNDS
-    if (spendableAmount < amount)
-        return tecINSUFFICIENT_FUNDS;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowCreate::preclaim(PreclaimContext const& ctx)
-{
-    STAmount const amount{ctx.tx[sfAmount]};
-    AccountID const account{ctx.tx[sfAccount]};
-    AccountID const dest{ctx.tx[sfDestination]};
-
-    auto const sled = ctx.view.read(keylet::account(dest));
-    if (!sled)
-        return tecNO_DST;
-
-    // Pseudo-accounts cannot receive escrow. Note, this is not amendment-gated
-    // because all writes to pseudo-account discriminator fields **are**
-    // amendment gated, hence the behaviour of this check will always match the
-    // currently active amendments.
-    if (isPseudoAccount(sled))
-        return tecNO_PERMISSION;
-
-    if (!isXRP(amount))
-    {
-        if (!ctx.view.rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowCreatePreclaimHelper<T>(ctx, account, dest, amount);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-    }
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowLockApplyHelper(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal);
-
-template <>
-TER
-escrowLockApplyHelper<Issue>(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal)
-{
-    // Defensive: Issuer cannot create an escrow
-    if (issuer == sender)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const ter = rippleCredit(
-        view, sender, issuer, amount, amount.holds<MPTIssue>() ? false : true, journal);
-    if (ter != tesSUCCESS)
-        return ter;  // LCOV_EXCL_LINE
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowLockApplyHelper<MPTIssue>(
-    ApplyView& view,
-    AccountID const& issuer,
-    AccountID const& sender,
-    STAmount const& amount,
-    beast::Journal journal)
-{
-    // Defensive: Issuer cannot create an escrow
-    if (issuer == sender)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    auto const ter = rippleLockEscrowMPT(view, sender, amount, journal);
-    if (ter != tesSUCCESS)
-        return ter;  // LCOV_EXCL_LINE
-    return tesSUCCESS;
-}
-
-TER
-EscrowCreate::doApply()
-{
-    auto const closeTime = ctx_.view().header().parentCloseTime;
-
-    if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    if (ctx_.tx[~sfFinishAfter] && after(closeTime, ctx_.tx[sfFinishAfter]))
-        return tecNO_PERMISSION;
-
-    auto const sle = ctx_.view().peek(keylet::account(account_));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    // Check reserve and funds availability
-    STAmount const amount{ctx_.tx[sfAmount]};
-
-    auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
-
-    if (mSourceBalance < reserve)
-        return tecINSUFFICIENT_RESERVE;
-
-    // Check reserve and funds availability
-    if (isXRP(amount))
-    {
-        if (mSourceBalance < reserve + STAmount(amount).xrp())
-            return tecUNFUNDED;
-    }
-
-    // Check destination account
-    {
-        auto const sled = ctx_.view().read(keylet::account(ctx_.tx[sfDestination]));
-        if (!sled)
-            return tecNO_DST;  // LCOV_EXCL_LINE
-        if (((*sled)[sfFlags] & lsfRequireDestTag) && !ctx_.tx[~sfDestinationTag])
-            return tecDST_TAG_NEEDED;
-    }
-
-    // Create escrow in ledger.  Note that we we use the value from the
-    // sequence or ticket.  For more explanation see comments in SeqProxy.h.
-    Keylet const escrowKeylet = keylet::escrow(account_, ctx_.tx.getSeqValue());
-    auto const slep = std::make_shared<SLE>(escrowKeylet);
-    (*slep)[sfAmount] = amount;
-    (*slep)[sfAccount] = account_;
-    (*slep)[~sfCondition] = ctx_.tx[~sfCondition];
-    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
-    (*slep)[sfDestination] = ctx_.tx[sfDestination];
-    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
-    (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
-    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
-
-    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
-    {
-        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
-    }
-
-    if (ctx_.view().rules().enabled(featureTokenEscrow) && !isXRP(amount))
-    {
-        auto const xferRate = transferRate(ctx_.view(), amount);
-        if (xferRate != parityRate)
-            (*slep)[sfTransferRate] = xferRate.value;
-    }
-
-    ctx_.view().insert(slep);
-
-    // Add escrow to sender's owner directory
-    {
-        auto page = ctx_.view().dirInsert(
-            keylet::ownerDir(account_), escrowKeylet, describeOwnerDir(account_));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfOwnerNode] = *page;
-    }
-
-    // If it's not a self-send, add escrow to recipient's owner directory.
-    AccountID const dest = ctx_.tx[sfDestination];
-    if (dest != account_)
-    {
-        auto page =
-            ctx_.view().dirInsert(keylet::ownerDir(dest), escrowKeylet, describeOwnerDir(dest));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfDestinationNode] = *page;
-    }
-
-    // IOU escrow objects are added to the issuer's owner directory to help
-    // track the total locked balance. For MPT, this isn't necessary because the
-    // locked balance is already stored directly in the MPTokenIssuance object.
-    AccountID const issuer = amount.getIssuer();
-    if (!isXRP(amount) && issuer != account_ && issuer != dest && !amount.holds<MPTIssue>())
-    {
-        auto page =
-            ctx_.view().dirInsert(keylet::ownerDir(issuer), escrowKeylet, describeOwnerDir(issuer));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfIssuerNode] = *page;
-    }
-
-    // Deduct owner's balance
-    if (isXRP(amount))
-        (*sle)[sfBalance] = (*sle)[sfBalance] - amount;
-    else
-    {
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowLockApplyHelper<T>(ctx_.view(), issuer, account_, amount, j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-        {
-            return ret;  // LCOV_EXCL_LINE
-        }
-    }
-
-    // increment owner count
-    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
-    ctx_.view().update(sle);
-    return tesSUCCESS;
-}
-
-//------------------------------------------------------------------------------
-
-static bool
-checkCondition(Slice f, Slice c)
-{
-    using namespace xrpl::cryptoconditions;
-
-    std::error_code ec;
-
-    auto condition = Condition::deserialize(c, ec);
-    if (!condition)
-        return false;
-
-    auto fulfillment = Fulfillment::deserialize(f, ec);
-    if (!fulfillment)
-        return false;
-
-    return validate(*fulfillment, *condition);
-}
-
-bool
-EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
-{
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
-}
-
-NotTEC
-EscrowFinish::preflight(PreflightContext const& ctx)
-{
-    auto const cb = ctx.tx[~sfCondition];
-    auto const fb = ctx.tx[~sfFulfillment];
-
-    // If you specify a condition, then you must also specify
-    // a fulfillment.
-    if (static_cast<bool>(cb) != static_cast<bool>(fb))
-        return temMALFORMED;
-
-    return tesSUCCESS;
-}
-
-NotTEC
-EscrowFinish::preflightSigValidated(PreflightContext const& ctx)
-{
-    auto const cb = ctx.tx[~sfCondition];
-    auto const fb = ctx.tx[~sfFulfillment];
-
-    if (cb && fb)
-    {
-        auto& router = ctx.registry.getHashRouter();
-
-        auto const id = ctx.tx.getTransactionID();
-        auto const flags = router.getFlags(id);
-
-        // If we haven't checked the condition, check it
-        // now. Whether it passes or not isn't important
-        // in preflight.
-        if (!any(flags & (SF_CF_INVALID | SF_CF_VALID)))
-        {
-            if (checkCondition(*fb, *cb))
-                router.setFlags(id, SF_CF_VALID);
-            else
-                router.setFlags(id, SF_CF_INVALID);
-        }
-    }
-
-    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-XRPAmount
-EscrowFinish::calculateBaseFee(ReadView const& view, STTx const& tx)
-{
-    XRPAmount extraFee{0};
-
-    if (auto const fb = tx[~sfFulfillment])
-    {
-        extraFee += view.fees().base * (32 + (fb->size() / 16));
-    }
-
-    return Transactor::calculateBaseFee(view, tx) + extraFee;
-}
-
-template <ValidIssueType T>
-static TER
-escrowFinishPreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount);
-
-template <>
-TER
-escrowFinishPreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tesSUCCESS
-    if (issuer == dest)
-        return tesSUCCESS;
-
-    // If the issuer has requireAuth set, check if the destination is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has deep frozen the destination, return tecFROZEN
-    if (isDeepFrozen(ctx.view, dest, amount.getCurrency(), amount.getIssuer()))
-        return tecFROZEN;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowFinishPreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& dest,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the dest, return tesSUCCESS
-    if (issuer == dest)
-        return tesSUCCESS;
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the destination is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    // If the issuer has frozen the destination, return tecLOCKED
-    if (isFrozen(ctx.view, dest, mptIssue))
-        return tecLOCKED;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowFinish::preclaim(PreclaimContext const& ctx)
-{
-    if (ctx.view.rules().enabled(featureCredentials))
-    {
-        if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
-            !isTesSuccess(err))
-            return err;
-    }
-
-    if (ctx.view.rules().enabled(featureTokenEscrow))
-    {
-        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
-        auto const slep = ctx.view.read(k);
-        if (!slep)
-            return tecNO_TARGET;
-
-        AccountID const dest = (*slep)[sfDestination];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
-        {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
-        }
-    }
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowUnlockApplyHelper(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal);
-
-template <>
-TER
-escrowUnlockApplyHelper<Issue>(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal)
-{
-    Keylet const trustLineKey = keylet::line(receiver, amount.issue());
-    bool const recvLow = issuer > receiver;
-    bool const senderIssuer = issuer == sender;
-    bool const receiverIssuer = issuer == receiver;
-    bool const issuerHigh = issuer > receiver;
-
-    if (senderIssuer)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    if (receiverIssuer)
-        return tesSUCCESS;
-
-    if (!view.exists(trustLineKey) && createAsset && !receiverIssuer)
-    {
-        // Can the account cover the trust line's reserve?
-        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
-            xrpBalance < view.fees().accountReserve(ownerCount + 1))
-        {
-            JLOG(journal.trace()) << "Trust line does not exist. "
-                                     "Insufficent reserve to create line.";
-
-            return tecNO_LINE_INSUF_RESERVE;
-        }
-
-        Currency const currency = amount.getCurrency();
-        STAmount initialBalance(amount.issue());
-        initialBalance.setIssuer(noAccount());
-
-        // clang-format off
-        if (TER const ter = trustCreate(
-                view,                           // payment sandbox
-                recvLow,                        // is dest low?
-                issuer,                         // source
-                receiver,                       // destination
-                trustLineKey.key,               // ledger index
-                sleDest,                        // Account to add to
-                false,                          // authorize account
-                (sleDest->getFlags() & lsfDefaultRipple) == 0,
-                false,                          // freeze trust line
-                false,                          // deep freeze trust line
-                initialBalance,                 // zero initial balance
-                Issue(currency, receiver),      // limit of zero
-                0,                              // quality in
-                0,                              // quality out
-                journal);                       // journal
-            !isTesSuccess(ter))
-        {
-            return ter; // LCOV_EXCL_LINE
-        }
-        // clang-format on
-
-        view.update(sleDest);
-    }
-
-    if (!view.exists(trustLineKey) && !receiverIssuer)
-        return tecNO_LINE;
-
-    auto const xferRate = transferRate(view, amount);
-    // update if issuer rate is less than locked rate
-    if (xferRate < lockedRate)
-        lockedRate = xferRate;
-
-    // Transfer Rate only applies when:
-    // 1. Issuer is not involved in the transfer (senderIssuer or
-    // receiverIssuer)
-    // 2. The locked rate is different from the parity rate
-
-    // NOTE: Transfer fee in escrow works a bit differently from a normal
-    // payment. In escrow, the fee is deducted from the locked/sending amount,
-    // whereas in a normal payment, the transfer fee is taken on top of the
-    // sending amount.
-    auto finalAmt = amount;
-    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
-    {
-        // compute transfer fee, if any
-        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.issue(), true);
-        // compute balance to transfer
-        finalAmt = amount.value() - xferFee;
-    }
-
-    // validate the line limit if the account submitting txn is not the receiver
-    // of the funds
-    if (!createAsset)
-    {
-        auto const sleRippleState = view.peek(trustLineKey);
-        if (!sleRippleState)
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        // if the issuer is the high, then we use the low limit
-        // otherwise we use the high limit
-        STAmount const lineLimit =
-            sleRippleState->getFieldAmount(issuerHigh ? sfLowLimit : sfHighLimit);
-
-        STAmount lineBalance = sleRippleState->getFieldAmount(sfBalance);
-
-        // flip the sign of the line balance if the issuer is not high
-        if (!issuerHigh)
-            lineBalance.negate();
-
-        // add the final amount to the line balance
-        lineBalance += finalAmt;
-
-        // if the transfer would exceed the line limit return tecLIMIT_EXCEEDED
-        if (lineLimit < lineBalance)
-            return tecLIMIT_EXCEEDED;
-    }
-
-    // if destination is not the issuer then transfer funds
-    if (!receiverIssuer)
-    {
-        auto const ter = rippleCredit(view, issuer, receiver, finalAmt, true, journal);
-        if (ter != tesSUCCESS)
-            return ter;  // LCOV_EXCL_LINE
-    }
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowUnlockApplyHelper<MPTIssue>(
-    ApplyView& view,
-    Rate lockedRate,
-    std::shared_ptr<SLE> const& sleDest,
-    STAmount const& xrpBalance,
-    STAmount const& amount,
-    AccountID const& issuer,
-    AccountID const& sender,
-    AccountID const& receiver,
-    bool createAsset,
-    beast::Journal journal)
-{
-    bool const senderIssuer = issuer == sender;
-    bool const receiverIssuer = issuer == receiver;
-
-    auto const mptID = amount.get<MPTIssue>().getMptID();
-    auto const issuanceKey = keylet::mptIssuance(mptID);
-    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && createAsset && !receiverIssuer)
-    {
-        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
-            xrpBalance < view.fees().accountReserve(ownerCount + 1))
-        {
-            return tecINSUFFICIENT_RESERVE;
-        }
-
-        if (auto const ter = MPTokenAuthorize::createMPToken(view, mptID, receiver, 0);
-            !isTesSuccess(ter))
-        {
-            return ter;  // LCOV_EXCL_LINE
-        }
-
-        // update owner count.
-        adjustOwnerCount(view, sleDest, 1, journal);
-    }
-
-    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && !receiverIssuer)
-        return tecNO_PERMISSION;
-
-    auto const xferRate = transferRate(view, amount);
-    // update if issuer rate is less than locked rate
-    if (xferRate < lockedRate)
-        lockedRate = xferRate;
-
-    // Transfer Rate only applies when:
-    // 1. Issuer is not involved in the transfer (senderIssuer or
-    // receiverIssuer)
-    // 2. The locked rate is different from the parity rate
-
-    // NOTE: Transfer fee in escrow works a bit differently from a normal
-    // payment. In escrow, the fee is deducted from the locked/sending amount,
-    // whereas in a normal payment, the transfer fee is taken on top of the
-    // sending amount.
-    auto finalAmt = amount;
-    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
-    {
-        // compute transfer fee, if any
-        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.asset(), true);
-        // compute balance to transfer
-        finalAmt = amount.value() - xferFee;
-    }
-    return rippleUnlockEscrowMPT(
-        view,
-        sender,
-        receiver,
-        finalAmt,
-        view.rules().enabled(fixTokenEscrowV1) ? amount : finalAmt,
-        journal);
-}
-
-TER
-EscrowFinish::doApply()
-{
-    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-    {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        return tecNO_TARGET;
-    }
-
-    // If a cancel time is present, a finish operation should only succeed prior
-    // to that time.
-    auto const now = ctx_.view().header().parentCloseTime;
-
-    // Too soon: can't execute before the finish time
-    if ((*slep)[~sfFinishAfter] && !after(now, (*slep)[sfFinishAfter]))
-        return tecNO_PERMISSION;
-
-    // Too late: can't execute after the cancel time
-    if ((*slep)[~sfCancelAfter] && after(now, (*slep)[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    // Check cryptocondition fulfillment
-    {
-        auto const id = ctx_.tx.getTransactionID();
-        auto flags = ctx_.registry.getHashRouter().getFlags(id);
-
-        auto const cb = ctx_.tx[~sfCondition];
-
-        // It's unlikely that the results of the check will
-        // expire from the hash router, but if it happens,
-        // simply re-run the check.
-        if (cb && !any(flags & (SF_CF_INVALID | SF_CF_VALID)))
-        {
-            // LCOV_EXCL_START
-            auto const fb = ctx_.tx[~sfFulfillment];
-
-            if (!fb)
-                return tecINTERNAL;
-
-            if (checkCondition(*fb, *cb))
-                flags = SF_CF_VALID;
-            else
-                flags = SF_CF_INVALID;
-
-            ctx_.registry.getHashRouter().setFlags(id, flags);
-            // LCOV_EXCL_STOP
-        }
-
-        // If the check failed, then simply return an error
-        // and don't look at anything else.
-        if (any(flags & SF_CF_INVALID))
-            return tecCRYPTOCONDITION_ERROR;
-
-        // Check against condition in the ledger entry:
-        auto const cond = (*slep)[~sfCondition];
-
-        // If a condition wasn't specified during creation,
-        // one shouldn't be included now.
-        if (!cond && cb)
-            return tecCRYPTOCONDITION_ERROR;
-
-        // If a condition was specified during creation of
-        // the suspended payment, the identical condition
-        // must be presented again. We don't check if the
-        // fulfillment matches the condition since we did
-        // that in preflight.
-        if (cond && (cond != cb))
-            return tecCRYPTOCONDITION_ERROR;
-    }
-
-    // NOTE: Escrow payments cannot be used to fund accounts.
-    AccountID const destID = (*slep)[sfDestination];
-    auto const sled = ctx_.view().peek(keylet::account(destID));
-    if (!sled)
-        return tecNO_DST;
-
-    if (auto err = verifyDepositPreauth(ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
-        !isTesSuccess(err))
-        return err;
-
-    AccountID const account = (*slep)[sfAccount];
-
-    // Remove escrow from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove escrow from recipient's owner directory, if present.
-    if (auto const optPage = (*slep)[~sfDestinationNode])
-    {
-        if (!ctx_.view().dirRemove(keylet::ownerDir(destID), *optPage, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    STAmount const amount = slep->getFieldAmount(sfAmount);
-    // Transfer amount to destination
-    if (isXRP(amount))
-        (*sled)[sfBalance] = (*sled)[sfBalance] + amount;
-    else
-    {
-        if (!ctx_.view().rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        Rate lockedRate = slep->isFieldPresent(sfTransferRate)
-            ? xrpl::Rate(slep->getFieldU32(sfTransferRate))
-            : parityRate;
-        auto const issuer = amount.getIssuer();
-        bool const createAsset = destID == account_;
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowUnlockApplyHelper<T>(
-                        ctx_.view(),
-                        lockedRate,
-                        sled,
-                        mPriorBalance,
-                        amount,
-                        issuer,
-                        account,
-                        destID,
-                        createAsset,
-                        j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;
-
-        // Remove escrow from issuers owner directory, if present.
-        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
-        {
-            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
-            {
-                // LCOV_EXCL_START
-                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-                return tefBAD_LEDGER;
-                // LCOV_EXCL_STOP
-            }
-        }
-    }
-
-    ctx_.view().update(sled);
-
-    // Adjust source owner count
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    // Remove escrow from ledger
-    ctx_.view().erase(slep);
-    return tesSUCCESS;
-}
-
-//------------------------------------------------------------------------------
-
-NotTEC
-EscrowCancel::preflight(PreflightContext const& ctx)
-{
-    return tesSUCCESS;
-}
-
-template <ValidIssueType T>
-static TER
-escrowCancelPreclaimHelper(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount);
-
-template <>
-TER
-escrowCancelPreclaimHelper<Issue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecINTERNAL
-    if (issuer == account)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    // If the issuer has requireAuth set, check if the account is authorized
-    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
-        return ter;
-
-    return tesSUCCESS;
-}
-
-template <>
-TER
-escrowCancelPreclaimHelper<MPTIssue>(
-    PreclaimContext const& ctx,
-    AccountID const& account,
-    STAmount const& amount)
-{
-    AccountID issuer = amount.getIssuer();
-    // If the issuer is the same as the account, return tecINTERNAL
-    if (issuer == account)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
-    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
-    auto const sleIssuance = ctx.view.read(issuanceKey);
-    if (!sleIssuance)
-        return tecOBJECT_NOT_FOUND;
-
-    // If the issuer has requireAuth set, check if the account is
-    // authorized
-    auto const& mptIssue = amount.get<MPTIssue>();
-    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
-        ter != tesSUCCESS)
-        return ter;
-
-    return tesSUCCESS;
-}
-
-TER
-EscrowCancel::preclaim(PreclaimContext const& ctx)
-{
-    if (ctx.view.rules().enabled(featureTokenEscrow))
-    {
-        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
-        auto const slep = ctx.view.read(k);
-        if (!slep)
-            return tecNO_TARGET;
-
-        AccountID const account = (*slep)[sfAccount];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
-        {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowCancelPreclaimHelper<T>(ctx, account, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
-        }
-    }
-    return tesSUCCESS;
-}
-
-TER
-EscrowCancel::doApply()
-{
-    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-    {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
-            return tecINTERNAL;  // LCOV_EXCL_LINE
-
-        return tecNO_TARGET;
-    }
-
-    auto const now = ctx_.view().header().parentCloseTime;
-
-    // No cancel time specified: can't execute at all.
-    if (!(*slep)[~sfCancelAfter])
-        return tecNO_PERMISSION;
-
-    // Too soon: can't execute before the cancel time.
-    if (!after(now, (*slep)[sfCancelAfter]))
-        return tecNO_PERMISSION;
-
-    AccountID const account = (*slep)[sfAccount];
-
-    // Remove escrow from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove escrow from recipient's owner directory, if present.
-    if (auto const optPage = (*slep)[~sfDestinationNode]; optPage)
-    {
-        if (!ctx_.view().dirRemove(keylet::ownerDir((*slep)[sfDestination]), *optPage, k.key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    STAmount const amount = slep->getFieldAmount(sfAmount);
-
-    // Transfer amount back to the owner
-    if (isXRP(amount))
-        (*sle)[sfBalance] = (*sle)[sfBalance] + amount;
-    else
-    {
-        if (!ctx_.view().rules().enabled(featureTokenEscrow))
-            return temDISABLED;  // LCOV_EXCL_LINE
-
-        auto const issuer = amount.getIssuer();
-        bool const createAsset = account == account_;
-        if (auto const ret = std::visit(
-                [&]<typename T>(T const&) {
-                    return escrowUnlockApplyHelper<T>(
-                        ctx_.view(),
-                        parityRate,
-                        slep,
-                        mPriorBalance,
-                        amount,
-                        issuer,
-                        account,  // sender and receiver are the same
-                        account,
-                        createAsset,
-                        j_);
-                },
-                amount.asset().value());
-            !isTesSuccess(ret))
-            return ret;  // LCOV_EXCL_LINE
-
-        // Remove escrow from issuers owner directory, if present.
-        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
-        {
-            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
-            {
-                // LCOV_EXCL_START
-                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
-                return tefBAD_LEDGER;
-                // LCOV_EXCL_STOP
-            }
-        }
-    }
-
-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    // Remove escrow from ledger
-    ctx_.view().erase(slep);
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/PayChan.cpp b/src/libxrpl/tx/transactors/PayChan.cpp
deleted file mode 100644
index 3b29169af6..0000000000
--- a/src/libxrpl/tx/transactors/PayChan.cpp
+++ /dev/null
@@ -1,542 +0,0 @@
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/PayChan.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/protocol/digest.h>
-#include <xrpl/tx/transactors/PayChan.h>
-
-namespace xrpl {
-
-/*
-    PaymentChannel
-
-        Payment channels permit off-ledger checkpoints of XRP payments flowing
-        in a single direction. A channel sequesters the owner's XRP in its own
-        ledger entry. The owner can authorize the recipient to claim up to a
-        given balance by giving the receiver a signed message (off-ledger). The
-        recipient can use this signed message to claim any unpaid balance while
-        the channel remains open. The owner can top off the line as needed. If
-        the channel has not paid out all its funds, the owner must wait out a
-        delay to close the channel to give the recipient a chance to supply any
-        claims. The recipient can close the channel at any time. Any transaction
-        that touches the channel after the expiration time will close the
-        channel. The total amount paid increases monotonically as newer claims
-        are issued. When the channel is closed any remaining balance is returned
-        to the owner. Channels are intended to permit intermittent off-ledger
-        settlement of ILP trust lines as balances get substantial. For
-        bidirectional channels, a payment channel can be used in each direction.
-
-    PaymentChannelCreate
-
-        Create a unidirectional channel. The parameters are:
-        Destination
-            The recipient at the end of the channel.
-        Amount
-            The amount of XRP to deposit in the channel immediately.
-        SettleDelay
-            The amount of time everyone but the recipient must wait for a
-            superior claim.
-        PublicKey
-            The key that will sign claims against the channel.
-        CancelAfter (optional)
-            Any channel transaction that touches this channel after the
-            `CancelAfter` time will close it.
-        DestinationTag (optional)
-            Destination tags allow the different accounts inside of a Hosted
-            Wallet to be mapped back onto the Ripple ledger. The destination tag
-            tells the server to which account in the Hosted Wallet the funds are
-            intended to go to. Required if the destination has lsfRequireDestTag
-            set.
-        SourceTag (optional)
-            Source tags allow the different accounts inside of a Hosted Wallet
-            to be mapped back onto the Ripple ledger. Source tags are similar to
-            destination tags but are for the channel owner to identify their own
-            transactions.
-
-    PaymentChannelFund
-
-        Add additional funds to the payment channel. Only the channel owner may
-        use this transaction. The parameters are:
-        Channel
-            The 256-bit ID of the channel.
-        Amount
-            The amount of XRP to add.
-        Expiration (optional)
-            Time the channel closes. The transaction will fail if the expiration
-            times does not satisfy the SettleDelay constraints.
-
-    PaymentChannelClaim
-
-        Place a claim against an existing channel. The parameters are:
-        Channel
-            The 256-bit ID of the channel.
-        Balance (optional)
-            The total amount of XRP delivered after this claim is processed
-   (optional, not needed if just closing). Amount (optional) The amount of XRP
-   the signature is for (not needed if equal to Balance or just closing the
-   line). Signature (optional) Authorization for the balance above, signed by
-   the owner (optional, not needed if closing or owner is performing the
-   transaction). The signature if for the following message: CLM\0 followed by
-   the 256-bit channel ID, and a 64-bit integer drops. PublicKey (optional) The
-   public key that made the signature (optional, required if a signature is
-   present) Flags tfClose Request that the channel be closed tfRenew Request
-   that the channel's expiration be reset. Only the owner may renew a channel.
-
-*/
-
-//------------------------------------------------------------------------------
-
-static TER
-closeChannel(
-    std::shared_ptr<SLE> const& slep,
-    ApplyView& view,
-    uint256 const& key,
-    beast::Journal j)
-{
-    AccountID const src = (*slep)[sfAccount];
-    // Remove PayChan from owner directory
-    {
-        auto const page = (*slep)[sfOwnerNode];
-        if (!view.dirRemove(keylet::ownerDir(src), page, key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j.fatal()) << "Could not remove paychan from src owner directory";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Remove PayChan from recipient's owner directory, if present.
-    if (auto const page = (*slep)[~sfDestinationNode])
-    {
-        auto const dst = (*slep)[sfDestination];
-        if (!view.dirRemove(keylet::ownerDir(dst), *page, key, true))
-        {
-            // LCOV_EXCL_START
-            JLOG(j.fatal()) << "Could not remove paychan from dst owner directory";
-            return tefBAD_LEDGER;
-            // LCOV_EXCL_STOP
-        }
-    }
-
-    // Transfer amount back to owner, decrement owner count
-    auto const sle = view.peek(keylet::account(src));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    XRPL_ASSERT(
-        (*slep)[sfAmount] >= (*slep)[sfBalance], "xrpl::closeChannel : minimum channel amount");
-    (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount] - (*slep)[sfBalance];
-    adjustOwnerCount(view, sle, -1, j);
-    view.update(sle);
-
-    // Remove PayChan from ledger
-    view.erase(slep);
-    return tesSUCCESS;
-}
-
-//------------------------------------------------------------------------------
-
-TxConsequences
-PayChanCreate::makeTxConsequences(PreflightContext const& ctx)
-{
-    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
-}
-
-NotTEC
-PayChanCreate::preflight(PreflightContext const& ctx)
-{
-    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
-        return temBAD_AMOUNT;
-
-    if (ctx.tx[sfAccount] == ctx.tx[sfDestination])
-        return temDST_IS_SRC;
-
-    if (!publicKeyType(ctx.tx[sfPublicKey]))
-        return temMALFORMED;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanCreate::preclaim(PreclaimContext const& ctx)
-{
-    auto const account = ctx.tx[sfAccount];
-    auto const sle = ctx.view.read(keylet::account(account));
-    if (!sle)
-        return terNO_ACCOUNT;
-
-    // Check reserve and funds availability
-    {
-        auto const balance = (*sle)[sfBalance];
-        auto const reserve = ctx.view.fees().accountReserve((*sle)[sfOwnerCount] + 1);
-
-        if (balance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-
-        if (balance < reserve + ctx.tx[sfAmount])
-            return tecUNFUNDED;
-    }
-
-    auto const dst = ctx.tx[sfDestination];
-
-    {
-        // Check destination account
-        auto const sled = ctx.view.read(keylet::account(dst));
-        if (!sled)
-            return tecNO_DST;
-
-        auto const flags = sled->getFlags();
-
-        // Check if they have disallowed incoming payment channels
-        if (flags & lsfDisallowIncomingPayChan)
-            return tecNO_PERMISSION;
-
-        if ((flags & lsfRequireDestTag) && !ctx.tx[~sfDestinationTag])
-            return tecDST_TAG_NEEDED;
-
-        // Pseudo-accounts cannot receive payment channels, other than native
-        // to their underlying ledger object - implemented in their respective
-        // transaction types. Note, this is not amendment-gated because all
-        // writes to pseudo-account discriminator fields **are** amendment
-        // gated, hence the behaviour of this check will always match the
-        // currently active amendments.
-        if (isPseudoAccount(sled))
-            return tecNO_PERMISSION;
-    }
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanCreate::doApply()
-{
-    auto const account = ctx_.tx[sfAccount];
-    auto const sle = ctx_.view().peek(keylet::account(account));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    if (ctx_.view().rules().enabled(fixPayChanCancelAfter))
-    {
-        auto const closeTime = ctx_.view().header().parentCloseTime;
-        if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
-            return tecEXPIRED;
-    }
-
-    auto const dst = ctx_.tx[sfDestination];
-
-    // Create PayChan in ledger.
-    //
-    // Note that we we use the value from the sequence or ticket as the
-    // payChan sequence.  For more explanation see comments in SeqProxy.h.
-    Keylet const payChanKeylet = keylet::payChan(account, dst, ctx_.tx.getSeqValue());
-    auto const slep = std::make_shared<SLE>(payChanKeylet);
-
-    // Funds held in this channel
-    (*slep)[sfAmount] = ctx_.tx[sfAmount];
-    // Amount channel has already paid
-    (*slep)[sfBalance] = ctx_.tx[sfAmount].zeroed();
-    (*slep)[sfAccount] = account;
-    (*slep)[sfDestination] = dst;
-    (*slep)[sfSettleDelay] = ctx_.tx[sfSettleDelay];
-    (*slep)[sfPublicKey] = ctx_.tx[sfPublicKey];
-    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
-    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
-    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
-    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
-    {
-        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
-    }
-
-    ctx_.view().insert(slep);
-
-    // Add PayChan to owner directory
-    {
-        auto const page = ctx_.view().dirInsert(
-            keylet::ownerDir(account), payChanKeylet, describeOwnerDir(account));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfOwnerNode] = *page;
-    }
-
-    // Add PayChan to the recipient's owner directory
-    {
-        auto const page =
-            ctx_.view().dirInsert(keylet::ownerDir(dst), payChanKeylet, describeOwnerDir(dst));
-        if (!page)
-            return tecDIR_FULL;  // LCOV_EXCL_LINE
-        (*slep)[sfDestinationNode] = *page;
-    }
-
-    // Deduct owner's balance, increment owner count
-    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
-    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
-    ctx_.view().update(sle);
-
-    return tesSUCCESS;
-}
-
-//------------------------------------------------------------------------------
-
-TxConsequences
-PayChanFund::makeTxConsequences(PreflightContext const& ctx)
-{
-    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
-}
-
-NotTEC
-PayChanFund::preflight(PreflightContext const& ctx)
-{
-    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
-        return temBAD_AMOUNT;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanFund::doApply()
-{
-    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-        return tecNO_ENTRY;
-
-    AccountID const src = (*slep)[sfAccount];
-    auto const txAccount = ctx_.tx[sfAccount];
-    auto const expiration = (*slep)[~sfExpiration];
-
-    {
-        auto const cancelAfter = (*slep)[~sfCancelAfter];
-        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
-        if ((cancelAfter && closeTime >= *cancelAfter) || (expiration && closeTime >= *expiration))
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-    }
-
-    if (src != txAccount)
-        // only the owner can add funds or extend
-        return tecNO_PERMISSION;
-
-    if (auto extend = ctx_.tx[~sfExpiration])
-    {
-        auto minExpiration = ctx_.view().header().parentCloseTime.time_since_epoch().count() +
-            (*slep)[sfSettleDelay];
-        if (expiration && *expiration < minExpiration)
-            minExpiration = *expiration;
-
-        if (*extend < minExpiration)
-            return temBAD_EXPIRATION;
-        (*slep)[~sfExpiration] = *extend;
-        ctx_.view().update(slep);
-    }
-
-    auto const sle = ctx_.view().peek(keylet::account(txAccount));
-    if (!sle)
-        return tefINTERNAL;  // LCOV_EXCL_LINE
-
-    {
-        // Check reserve and funds availability
-        auto const balance = (*sle)[sfBalance];
-        auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount]);
-
-        if (balance < reserve)
-            return tecINSUFFICIENT_RESERVE;
-
-        if (balance < reserve + ctx_.tx[sfAmount])
-            return tecUNFUNDED;
-    }
-
-    // do not allow adding funds if dst does not exist
-    if (AccountID const dst = (*slep)[sfDestination]; !ctx_.view().read(keylet::account(dst)))
-    {
-        return tecNO_DST;
-    }
-
-    (*slep)[sfAmount] = (*slep)[sfAmount] + ctx_.tx[sfAmount];
-    ctx_.view().update(slep);
-
-    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
-    ctx_.view().update(sle);
-
-    return tesSUCCESS;
-}
-
-//------------------------------------------------------------------------------
-
-bool
-PayChanClaim::checkExtraFeatures(PreflightContext const& ctx)
-{
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
-}
-
-std::uint32_t
-PayChanClaim::getFlagsMask(PreflightContext const&)
-{
-    return tfPayChanClaimMask;
-}
-
-NotTEC
-PayChanClaim::preflight(PreflightContext const& ctx)
-{
-    auto const bal = ctx.tx[~sfBalance];
-    if (bal && (!isXRP(*bal) || *bal <= beast::zero))
-        return temBAD_AMOUNT;
-
-    auto const amt = ctx.tx[~sfAmount];
-    if (amt && (!isXRP(*amt) || *amt <= beast::zero))
-        return temBAD_AMOUNT;
-
-    if (bal && amt && *bal > *amt)
-        return temBAD_AMOUNT;
-
-    {
-        auto const flags = ctx.tx.getFlags();
-
-        if ((flags & tfClose) && (flags & tfRenew))
-            return temMALFORMED;
-    }
-
-    if (auto const sig = ctx.tx[~sfSignature])
-    {
-        if (!(ctx.tx[~sfPublicKey] && bal))
-            return temMALFORMED;
-
-        // Check the signature
-        // The signature isn't needed if txAccount == src, but if it's
-        // present, check it
-
-        auto const reqBalance = bal->xrp();
-        auto const authAmt = amt ? amt->xrp() : reqBalance;
-
-        if (reqBalance > authAmt)
-            return temBAD_AMOUNT;
-
-        Keylet const k(ltPAYCHAN, ctx.tx[sfChannel]);
-        if (!publicKeyType(ctx.tx[sfPublicKey]))
-            return temMALFORMED;
-
-        PublicKey const pk(ctx.tx[sfPublicKey]);
-        Serializer msg;
-        serializePayChanAuthorization(msg, k.key, authAmt);
-        if (!verify(pk, msg.slice(), *sig))
-            return temBAD_SIGNATURE;
-    }
-
-    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanClaim::preclaim(PreclaimContext const& ctx)
-{
-    if (!ctx.view.rules().enabled(featureCredentials))
-        return Transactor::preclaim(ctx);
-
-    if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
-        !isTesSuccess(err))
-        return err;
-
-    return tesSUCCESS;
-}
-
-TER
-PayChanClaim::doApply()
-{
-    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
-    auto const slep = ctx_.view().peek(k);
-    if (!slep)
-        return tecNO_TARGET;
-
-    AccountID const src = (*slep)[sfAccount];
-    AccountID const dst = (*slep)[sfDestination];
-    AccountID const txAccount = ctx_.tx[sfAccount];
-
-    auto const curExpiration = (*slep)[~sfExpiration];
-    {
-        auto const cancelAfter = (*slep)[~sfCancelAfter];
-        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
-        if ((cancelAfter && closeTime >= *cancelAfter) ||
-            (curExpiration && closeTime >= *curExpiration))
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-    }
-
-    if (txAccount != src && txAccount != dst)
-        return tecNO_PERMISSION;
-
-    if (ctx_.tx[~sfBalance])
-    {
-        auto const chanBalance = slep->getFieldAmount(sfBalance).xrp();
-        auto const chanFunds = slep->getFieldAmount(sfAmount).xrp();
-        auto const reqBalance = ctx_.tx[sfBalance].xrp();
-
-        if (txAccount == dst && !ctx_.tx[~sfSignature])
-            return temBAD_SIGNATURE;
-
-        if (ctx_.tx[~sfSignature])
-        {
-            PublicKey const pk((*slep)[sfPublicKey]);
-            if (ctx_.tx[sfPublicKey] != pk)
-                return temBAD_SIGNER;
-        }
-
-        if (reqBalance > chanFunds)
-            return tecUNFUNDED_PAYMENT;
-
-        if (reqBalance <= chanBalance)
-            // nothing requested
-            return tecUNFUNDED_PAYMENT;
-
-        auto const sled = ctx_.view().peek(keylet::account(dst));
-        if (!sled)
-            return tecNO_DST;
-
-        if (auto err =
-                verifyDepositPreauth(ctx_.tx, ctx_.view(), txAccount, dst, sled, ctx_.journal);
-            !isTesSuccess(err))
-            return err;
-
-        (*slep)[sfBalance] = ctx_.tx[sfBalance];
-        XRPAmount const reqDelta = reqBalance - chanBalance;
-        XRPL_ASSERT(reqDelta >= beast::zero, "xrpl::PayChanClaim::doApply : minimum balance delta");
-        (*sled)[sfBalance] = (*sled)[sfBalance] + reqDelta;
-        ctx_.view().update(sled);
-        ctx_.view().update(slep);
-    }
-
-    if (ctx_.tx.getFlags() & tfRenew)
-    {
-        if (src != txAccount)
-            return tecNO_PERMISSION;
-        (*slep)[~sfExpiration] = std::nullopt;
-        ctx_.view().update(slep);
-    }
-
-    if (ctx_.tx.getFlags() & tfClose)
-    {
-        // Channel will close immediately if dry or the receiver closes
-        if (dst == txAccount || (*slep)[sfBalance] == (*slep)[sfAmount])
-            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
-
-        auto const settleExpiration =
-            ctx_.view().header().parentCloseTime.time_since_epoch().count() +
-            (*slep)[sfSettleDelay];
-
-        if (!curExpiration || *curExpiration > settleExpiration)
-        {
-            (*slep)[~sfExpiration] = settleExpiration;
-            ctx_.view().update(slep);
-        }
-    }
-
-    return tesSUCCESS;
-}
-
-}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/DeleteAccount.cpp b/src/libxrpl/tx/transactors/account/DeleteAccount.cpp
similarity index 94%
rename from src/libxrpl/tx/transactors/DeleteAccount.cpp
rename to src/libxrpl/tx/transactors/account/DeleteAccount.cpp
index 79ce03ca9a..a4f1408298 100644
--- a/src/libxrpl/tx/transactors/DeleteAccount.cpp
+++ b/src/libxrpl/tx/transactors/account/DeleteAccount.cpp
@@ -1,5 +1,4 @@
 #include <xrpl/basics/Log.h>
-#include <xrpl/basics/mulDiv.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/CredentialHelpers.h>
 #include <xrpl/ledger/View.h>
@@ -8,13 +7,13 @@
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/Units.h>
-#include <xrpl/tx/transactors/DID.h>
-#include <xrpl/tx/transactors/Delegate/DelegateSet.h>
-#include <xrpl/tx/transactors/DeleteAccount.h>
-#include <xrpl/tx/transactors/DeleteOracle.h>
-#include <xrpl/tx/transactors/DepositPreauth.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
-#include <xrpl/tx/transactors/SetSignerList.h>
+#include <xrpl/tx/transactors/account/DeleteAccount.h>
+#include <xrpl/tx/transactors/account/SetSignerList.h>
+#include <xrpl/tx/transactors/delegate/DelegateSet.h>
+#include <xrpl/tx/transactors/did/DIDDelete.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+#include <xrpl/tx/transactors/oracle/DeleteOracle.h>
+#include <xrpl/tx/transactors/payment/DepositPreauth.h>
 
 namespace xrpl {
 
@@ -372,9 +371,10 @@ DeleteAccount::doApply()
         return ter;
 
     // Transfer any XRP remaining after the fee is paid to the destination:
-    (*dst)[sfBalance] = (*dst)[sfBalance] + mSourceBalance;
-    (*src)[sfBalance] = (*src)[sfBalance] - mSourceBalance;
-    ctx_.deliver(mSourceBalance);
+    auto const remainingBalance = src->getFieldAmount(sfBalance).xrp();
+    (*dst)[sfBalance] = (*dst)[sfBalance] + remainingBalance;
+    (*src)[sfBalance] = (*src)[sfBalance] - remainingBalance;
+    ctx_.deliver(remainingBalance);
 
     XRPL_ASSERT(
         (*src)[sfBalance] == XRPAmount(0), "xrpl::DeleteAccount::doApply : source balance is zero");
@@ -388,7 +388,7 @@ DeleteAccount::doApply()
     }
 
     // Re-arm the password change fee if we can and need to.
-    if (mSourceBalance > XRPAmount(0) && dst->isFlag(lsfPasswordSpent))
+    if (remainingBalance > XRPAmount(0) && dst->isFlag(lsfPasswordSpent))
         dst->clearFlag(lsfPasswordSpent);
 
     view().update(dst);
diff --git a/src/libxrpl/tx/transactors/SetAccount.cpp b/src/libxrpl/tx/transactors/account/SetAccount.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/SetAccount.cpp
rename to src/libxrpl/tx/transactors/account/SetAccount.cpp
index 64b52d12d5..032b4727ad 100644
--- a/src/libxrpl/tx/transactors/SetAccount.cpp
+++ b/src/libxrpl/tx/transactors/account/SetAccount.cpp
@@ -5,8 +5,8 @@
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/Quality.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/SetAccount.h>
+#include <xrpl/tx/transactors/account/SetAccount.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
 
 namespace xrpl {
 
@@ -491,7 +491,7 @@ SetAccount::doApply()
 
         if (messageKey.empty())
         {
-            JLOG(j_.debug()) << "set message key";
+            JLOG(j_.debug()) << "clear message key";
             sle->makeFieldAbsent(sfMessageKey);
         }
         else
diff --git a/src/libxrpl/tx/transactors/SetRegularKey.cpp b/src/libxrpl/tx/transactors/account/SetRegularKey.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/SetRegularKey.cpp
rename to src/libxrpl/tx/transactors/account/SetRegularKey.cpp
index e26e6b1bd5..08175b196f 100644
--- a/src/libxrpl/tx/transactors/SetRegularKey.cpp
+++ b/src/libxrpl/tx/transactors/account/SetRegularKey.cpp
@@ -1,7 +1,7 @@
 #include <xrpl/basics/Log.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/SetRegularKey.h>
+#include <xrpl/tx/transactors/account/SetRegularKey.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/SetSignerList.cpp b/src/libxrpl/tx/transactors/account/SetSignerList.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/SetSignerList.cpp
rename to src/libxrpl/tx/transactors/account/SetSignerList.cpp
index 858fb33bff..864c46013f 100644
--- a/src/libxrpl/tx/transactors/SetSignerList.cpp
+++ b/src/libxrpl/tx/transactors/account/SetSignerList.cpp
@@ -7,7 +7,7 @@
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/SetSignerList.h>
+#include <xrpl/tx/transactors/account/SetSignerList.h>
 
 #include <algorithm>
 #include <cstdint>
@@ -306,7 +306,7 @@ SetSignerList::replaceSignerList()
     // We check the reserve against the starting balance because we want to
     // allow dipping into the reserve to pay fees.  This behavior is consistent
     // with CreateTicket.
-    if (mPriorBalance < newReserve)
+    if (preFeeBalance_ < newReserve)
         return tecINSUFFICIENT_RESERVE;
 
     // Everything's ducky.  Add the ltSIGNER_LIST to the ledger.
diff --git a/src/libxrpl/tx/transactors/XChainBridge.cpp b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/XChainBridge.cpp
rename to src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
index 30fc9f59e1..3597cc8959 100644
--- a/src/libxrpl/tx/transactors/XChainBridge.cpp
+++ b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
@@ -21,7 +21,7 @@
 #include <xrpl/tx/SignerEntries.h>
 #include <xrpl/tx/Transactor.h>
 #include <xrpl/tx/paths/Flow.h>
-#include <xrpl/tx/transactors/XChainBridge.h>
+#include <xrpl/tx/transactors/bridge/XChainBridge.h>
 
 #include <unordered_map>
 #include <unordered_set>
@@ -337,7 +337,7 @@ enum class DepositAuthPolicy { normal, dstCanBypass };
 struct TransferHelperSubmittingAccountInfo
 {
     AccountID account;
-    STAmount preFeeBalance;
+    STAmount preFeeBalance_;
     STAmount postFeeBalance;
 };
 
@@ -423,7 +423,7 @@ transferHelper(
                 if (!submittingAccountInfo || submittingAccountInfo->account != src ||
                     submittingAccountInfo->postFeeBalance != curBal)
                     return curBal;
-                return submittingAccountInfo->preFeeBalance;
+                return submittingAccountInfo->preFeeBalance_;
             }();
 
             if (availableBalance < amt + reserve)
@@ -868,7 +868,13 @@ applyClaimAttestations(
         XChainClaimAttestations curAtts{sleClaimID->getFieldArray(sfXChainClaimAttestations)};
 
         auto const newAttResult = onNewAttestations(
-            curAtts, view, &atts[0], &atts[0] + atts.size(), quorum, signersList, j);
+            curAtts,
+            view,
+            &atts[0],
+            &atts[0] + atts.size(),  // NOLINT(bugprone-pointer-arithmetic-on-polymorphic-object)
+            quorum,
+            signersList,
+            j);
 
         // update the claim id
         sleClaimID->setFieldArray(sfXChainClaimAttestations, curAtts.toSTArray());
@@ -975,7 +981,7 @@ applyCreateAccountAttestations(
     struct ScopeResult
     {
         OnNewAttestationResult newAttResult;
-        bool createCID;
+        bool createCID{};
         XChainCreateAccountAttestations curAtts;
     };
 
@@ -1026,7 +1032,13 @@ applyCreateAccountAttestations(
         }();
 
         auto const newAttResult = onNewAttestations(
-            curAtts, view, &atts[0], &atts[0] + atts.size(), quorum, signersList, j);
+            curAtts,
+            view,
+            &atts[0],
+            &atts[0] + atts.size(),  // NOLINT(bugprone-pointer-arithmetic-on-polymorphic-object)
+            quorum,
+            signersList,
+            j);
 
         if (!createCID)
         {
@@ -1126,8 +1138,8 @@ toClaim(STTx const& tx)
     }
     catch (...)
     {
+        return std::nullopt;
     }
-    return std::nullopt;
 }
 
 template <class TAttestation>
@@ -1197,9 +1209,9 @@ attestationDoApply(ApplyContext& ctx)
 
     struct ScopeResult
     {
-        STXChainBridge::ChainType srcChain;
+        STXChainBridge::ChainType srcChain = STXChainBridge::ChainType::locking;
         std::unordered_map<AccountID, std::uint32_t> signersList;
-        std::uint32_t quorum;
+        std::uint32_t quorum{};
         AccountID thisDoor;
         Keylet bridgeK;
     };
@@ -1448,7 +1460,7 @@ XChainCreateBridge::doApply()
 std::uint32_t
 BridgeModify::getFlagsMask(PreflightContext const& ctx)
 {
-    return tfBridgeModifyMask;
+    return tfXChainModifyBridgeMask;
 }
 
 NotTEC
@@ -1840,7 +1852,8 @@ XChainCommit::doApply()
     auto const amount = ctx_.tx[sfAmount];
     auto const bridgeSpec = ctx_.tx[sfXChainBridge];
 
-    if (!psb.read(keylet::account(account)))
+    auto const sleAccount = psb.read(keylet::account(account));
+    if (!sleAccount)
         return tecINTERNAL;  // LCOV_EXCL_LINE
 
     auto const sleBridge = readBridge(psb, bridgeSpec);
@@ -1851,7 +1864,7 @@ XChainCommit::doApply()
 
     // Support dipping into reserves to pay the fee
     TransferHelperSubmittingAccountInfo submittingAccountInfo{
-        account_, mPriorBalance, mSourceBalance};
+        account_, preFeeBalance_, (*sleAccount)[sfBalance]};
 
     auto const thTer = transferHelper(
         psb,
@@ -2120,7 +2133,7 @@ XChainCreateAccountCommit::doApply()
 
     // Support dipping into reserves to pay the fee
     TransferHelperSubmittingAccountInfo submittingAccountInfo{
-        account_, mPriorBalance, mSourceBalance};
+        account_, preFeeBalance_, (*sle)[sfBalance]};
     STAmount const toTransfer = amount + reward;
     auto const thTer = transferHelper(
         psb,
diff --git a/src/libxrpl/tx/transactors/Check/CancelCheck.cpp b/src/libxrpl/tx/transactors/check/CancelCheck.cpp
similarity index 91%
rename from src/libxrpl/tx/transactors/Check/CancelCheck.cpp
rename to src/libxrpl/tx/transactors/check/CancelCheck.cpp
index c9a947ae6a..59d80fb27e 100644
--- a/src/libxrpl/tx/transactors/Check/CancelCheck.cpp
+++ b/src/libxrpl/tx/transactors/check/CancelCheck.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Check/CancelCheck.h>
+#include <xrpl/tx/transactors/check/CancelCheck.h>
 
 namespace xrpl {
 
@@ -25,15 +25,11 @@ CancelCheck::preclaim(PreclaimContext const& ctx)
         return tecNO_ENTRY;
     }
 
-    using duration = NetClock::duration;
-    using timepoint = NetClock::time_point;
-    auto const optExpiry = (*sleCheck)[~sfExpiration];
-
     // Expiration is defined in terms of the close time of the parent
     // ledger, because we definitively know the time that it closed but
     // we do not know the closing time of the ledger that is under
     // construction.
-    if (!optExpiry || (ctx.view.parentCloseTime() < timepoint{duration{*optExpiry}}))
+    if (!hasExpired(ctx.view, (*sleCheck)[~sfExpiration]))
     {
         // If the check is not yet expired, then only the creator or the
         // destination may cancel the check.
diff --git a/src/libxrpl/tx/transactors/Check/CashCheck.cpp b/src/libxrpl/tx/transactors/check/CashCheck.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Check/CashCheck.cpp
rename to src/libxrpl/tx/transactors/check/CashCheck.cpp
index c459ef9b67..3d15da374c 100644
--- a/src/libxrpl/tx/transactors/Check/CashCheck.cpp
+++ b/src/libxrpl/tx/transactors/check/CashCheck.cpp
@@ -6,7 +6,7 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/paths/Flow.h>
-#include <xrpl/tx/transactors/Check/CashCheck.h>
+#include <xrpl/tx/transactors/check/CashCheck.h>
 
 #include <algorithm>
 
@@ -309,7 +309,7 @@ CashCheck::doApply()
 
                 // Can the account cover the trust line's reserve?
                 if (std::uint32_t const ownerCount = {sleDst->at(sfOwnerCount)};
-                    mPriorBalance < psb.fees().accountReserve(ownerCount + 1))
+                    preFeeBalance_ < psb.fees().accountReserve(ownerCount + 1))
                 {
                     JLOG(j_.trace()) << "Trust line does not exist. "
                                         "Insufficent reserve to create line.";
diff --git a/src/libxrpl/tx/transactors/Check/CreateCheck.cpp b/src/libxrpl/tx/transactors/check/CreateCheck.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Check/CreateCheck.cpp
rename to src/libxrpl/tx/transactors/check/CreateCheck.cpp
index 7ec4746d20..1530b20f40 100644
--- a/src/libxrpl/tx/transactors/Check/CreateCheck.cpp
+++ b/src/libxrpl/tx/transactors/check/CreateCheck.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Check/CreateCheck.h>
+#include <xrpl/tx/transactors/check/CreateCheck.h>
 
 namespace xrpl {
 
@@ -140,7 +140,7 @@ CreateCheck::doApply()
     {
         STAmount const reserve{view().fees().accountReserve(sle->getFieldU32(sfOwnerCount) + 1)};
 
-        if (mPriorBalance < reserve)
+        if (preFeeBalance_ < reserve)
             return tecINSUFFICIENT_RESERVE;
     }
 
diff --git a/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp b/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp
new file mode 100644
index 0000000000..1c5608c09f
--- /dev/null
+++ b/src/libxrpl/tx/transactors/credentials/CredentialAccept.cpp
@@ -0,0 +1,113 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/tx/transactors/credentials/CredentialAccept.h>
+
+#include <chrono>
+
+namespace xrpl {
+
+using namespace credentials;
+
+std::uint32_t
+CredentialAccept::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialAccept::preflight(PreflightContext const& ctx)
+{
+    if (!ctx.tx[sfIssuer])
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: Issuer field zeroed.";
+        return temINVALID_ACCOUNT_ID;
+    }
+
+    auto const credType = ctx.tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialAccept::preclaim(PreclaimContext const& ctx)
+{
+    AccountID const subject = ctx.tx[sfAccount];
+    AccountID const issuer = ctx.tx[sfIssuer];
+    auto const credType(ctx.tx[sfCredentialType]);
+
+    if (!ctx.view.exists(keylet::account(issuer)))
+    {
+        JLOG(ctx.j.warn()) << "No issuer: " << to_string(issuer);
+        return tecNO_ISSUER;
+    }
+
+    auto const sleCred = ctx.view.read(keylet::credential(subject, issuer, credType));
+    if (!sleCred)
+    {
+        JLOG(ctx.j.warn()) << "No credential: " << to_string(subject) << ", " << to_string(issuer)
+                           << ", " << credType;
+        return tecNO_ENTRY;
+    }
+
+    if (sleCred->getFieldU32(sfFlags) & lsfAccepted)
+    {
+        JLOG(ctx.j.warn()) << "Credential already accepted: " << to_string(subject) << ", "
+                           << to_string(issuer) << ", " << credType;
+        return tecDUPLICATE;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialAccept::doApply()
+{
+    AccountID const issuer{ctx_.tx[sfIssuer]};
+
+    // Both exist as credential object exist itself (checked in preclaim)
+    auto const sleSubject = view().peek(keylet::account(account_));
+    auto const sleIssuer = view().peek(keylet::account(issuer));
+
+    if (!sleSubject || !sleIssuer)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        STAmount const reserve{
+            view().fees().accountReserve(sleSubject->getFieldU32(sfOwnerCount) + 1)};
+        if (preFeeBalance_ < reserve)
+            return tecINSUFFICIENT_RESERVE;
+    }
+
+    auto const credType(ctx_.tx[sfCredentialType]);
+    Keylet const credentialKey = keylet::credential(account_, issuer, credType);
+    auto const sleCred = view().peek(credentialKey);  // Checked in preclaim()
+
+    if (checkExpired(sleCred, view().header().parentCloseTime))
+    {
+        JLOG(j_.trace()) << "Credential is expired: " << sleCred->getText();
+        // delete expired credentials even if the transaction failed
+        auto const err = credentials::deleteSLE(view(), sleCred, j_);
+        return isTesSuccess(err) ? tecEXPIRED : err;
+    }
+
+    sleCred->setFieldU32(sfFlags, lsfAccepted);
+    view().update(sleCred);
+
+    adjustOwnerCount(view(), sleIssuer, -1, j_);
+    adjustOwnerCount(view(), sleSubject, 1, j_);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp b/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp
new file mode 100644
index 0000000000..5dafd146c7
--- /dev/null
+++ b/src/libxrpl/tx/transactors/credentials/CredentialCreate.cpp
@@ -0,0 +1,164 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/tx/transactors/credentials/CredentialCreate.h>
+
+#include <chrono>
+
+namespace xrpl {
+
+/*
+    Credentials
+    ======
+
+   A verifiable credentials (VC
+   https://en.wikipedia.org/wiki/Verifiable_credentials), as defined by the W3C
+   specification (https://www.w3.org/TR/vc-data-model-2.0/), is a
+   secure and tamper-evident way to represent information about a subject, such
+   as an individual, organization, or even an IoT device. These credentials are
+   issued by a trusted entity and can be verified by third parties without
+   directly involving the issuer at all.
+*/
+
+using namespace credentials;
+
+std::uint32_t
+CredentialCreate::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialCreate::preflight(PreflightContext const& ctx)
+{
+    auto const& tx = ctx.tx;
+    auto& j = ctx.j;
+
+    if (!tx[sfSubject])
+    {
+        JLOG(j.trace()) << "Malformed transaction: Invalid Subject";
+        return temMALFORMED;
+    }
+
+    auto const uri = tx[~sfURI];
+    if (uri && (uri->empty() || (uri->size() > maxCredentialURILength)))
+    {
+        JLOG(j.trace()) << "Malformed transaction: invalid size of URI.";
+        return temMALFORMED;
+    }
+
+    auto const credType = tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialCreate::preclaim(PreclaimContext const& ctx)
+{
+    auto const credType(ctx.tx[sfCredentialType]);
+    auto const subject = ctx.tx[sfSubject];
+
+    if (!ctx.view.exists(keylet::account(subject)))
+    {
+        JLOG(ctx.j.trace()) << "Subject doesn't exist.";
+        return tecNO_TARGET;
+    }
+
+    if (ctx.view.exists(keylet::credential(subject, ctx.tx[sfAccount], credType)))
+    {
+        JLOG(ctx.j.trace()) << "Credential already exists.";
+        return tecDUPLICATE;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialCreate::doApply()
+{
+    auto const subject = ctx_.tx[sfSubject];
+    auto const credType(ctx_.tx[sfCredentialType]);
+    Keylet const credentialKey = keylet::credential(subject, account_, credType);
+
+    auto const sleCred = std::make_shared<SLE>(credentialKey);
+    if (!sleCred)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    auto const optExp = ctx_.tx[~sfExpiration];
+    if (optExp)
+    {
+        std::uint32_t const closeTime =
+            ctx_.view().header().parentCloseTime.time_since_epoch().count();
+
+        if (closeTime > *optExp)
+        {
+            JLOG(j_.trace()) << "Malformed transaction: "
+                                "Expiration time is in the past.";
+            return tecEXPIRED;
+        }
+
+        sleCred->setFieldU32(sfExpiration, *optExp);
+    }
+
+    auto const sleIssuer = view().peek(keylet::account(account_));
+    if (!sleIssuer)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        STAmount const reserve{
+            view().fees().accountReserve(sleIssuer->getFieldU32(sfOwnerCount) + 1)};
+        if (preFeeBalance_ < reserve)
+            return tecINSUFFICIENT_RESERVE;
+    }
+
+    sleCred->setAccountID(sfSubject, subject);
+    sleCred->setAccountID(sfIssuer, account_);
+    sleCred->setFieldVL(sfCredentialType, credType);
+
+    if (ctx_.tx.isFieldPresent(sfURI))
+        sleCred->setFieldVL(sfURI, ctx_.tx.getFieldVL(sfURI));
+
+    {
+        auto const page =
+            view().dirInsert(keylet::ownerDir(account_), credentialKey, describeOwnerDir(account_));
+        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
+                         << ": " << (page ? "success" : "failure");
+        if (!page)
+            return tecDIR_FULL;
+        sleCred->setFieldU64(sfIssuerNode, *page);
+
+        adjustOwnerCount(view(), sleIssuer, 1, j_);
+    }
+
+    if (subject == account_)
+    {
+        sleCred->setFieldU32(sfFlags, lsfAccepted);
+    }
+    else
+    {
+        auto const page =
+            view().dirInsert(keylet::ownerDir(subject), credentialKey, describeOwnerDir(subject));
+        JLOG(j_.trace()) << "Adding Credential to owner directory " << to_string(credentialKey.key)
+                         << ": " << (page ? "success" : "failure");
+        if (!page)
+            return tecDIR_FULL;
+        sleCred->setFieldU64(sfSubjectNode, *page);
+        view().update(view().peek(keylet::account(subject)));
+    }
+
+    view().insert(sleCred);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp b/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp
new file mode 100644
index 0000000000..d273135aa9
--- /dev/null
+++ b/src/libxrpl/tx/transactors/credentials/CredentialDelete.cpp
@@ -0,0 +1,90 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/tx/transactors/credentials/CredentialDelete.h>
+
+#include <chrono>
+
+namespace xrpl {
+
+using namespace credentials;
+
+std::uint32_t
+CredentialDelete::getFlagsMask(PreflightContext const& ctx)
+{
+    // 0 means "Allow any flags"
+    return ctx.rules.enabled(fixInvalidTxFlags) ? tfUniversalMask : 0;
+}
+
+NotTEC
+CredentialDelete::preflight(PreflightContext const& ctx)
+{
+    auto const subject = ctx.tx[~sfSubject];
+    auto const issuer = ctx.tx[~sfIssuer];
+
+    if (!subject && !issuer)
+    {
+        // Neither field is present, the transaction is malformed.
+        JLOG(ctx.j.trace()) << "Malformed transaction: "
+                               "No Subject or Issuer fields.";
+        return temMALFORMED;
+    }
+
+    // Make sure that the passed account is valid.
+    if ((subject && subject->isZero()) || (issuer && issuer->isZero()))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: Subject or Issuer "
+                               "field zeroed.";
+        return temINVALID_ACCOUNT_ID;
+    }
+
+    auto const credType = ctx.tx[sfCredentialType];
+    if (credType.empty() || (credType.size() > maxCredentialTypeLength))
+    {
+        JLOG(ctx.j.trace()) << "Malformed transaction: invalid size of CredentialType.";
+        return temMALFORMED;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialDelete::preclaim(PreclaimContext const& ctx)
+{
+    AccountID const account{ctx.tx[sfAccount]};
+    auto const subject = ctx.tx[~sfSubject].value_or(account);
+    auto const issuer = ctx.tx[~sfIssuer].value_or(account);
+    auto const credType(ctx.tx[sfCredentialType]);
+
+    if (!ctx.view.exists(keylet::credential(subject, issuer, credType)))
+        return tecNO_ENTRY;
+
+    return tesSUCCESS;
+}
+
+TER
+CredentialDelete::doApply()
+{
+    auto const subject = ctx_.tx[~sfSubject].value_or(account_);
+    auto const issuer = ctx_.tx[~sfIssuer].value_or(account_);
+
+    auto const credType(ctx_.tx[sfCredentialType]);
+    auto const sleCred = view().peek(keylet::credential(subject, issuer, credType));
+    if (!sleCred)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    if ((subject != account_) && (issuer != account_) &&
+        !checkExpired(sleCred, ctx_.view().header().parentCloseTime))
+    {
+        JLOG(j_.trace()) << "Can't delete non-expired credential.";
+        return tecNO_PERMISSION;
+    }
+
+    return deleteSLE(view(), sleCred, j_);
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/Delegate/DelegateSet.cpp b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/Delegate/DelegateSet.cpp
rename to src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
index 69ec707dd2..87e6c076b5 100644
--- a/src/libxrpl/tx/transactors/Delegate/DelegateSet.cpp
+++ b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/Delegate/DelegateSet.h>
+#include <xrpl/tx/transactors/delegate/DelegateSet.h>
 
 namespace xrpl {
 
@@ -70,7 +70,7 @@ DelegateSet::doApply()
     STAmount const reserve{
         ctx_.view().fees().accountReserve(sleOwner->getFieldU32(sfOwnerCount) + 1)};
 
-    if (mPriorBalance < reserve)
+    if (preFeeBalance_ < reserve)
         return tecINSUFFICIENT_RESERVE;
 
     auto const& permissions = ctx_.tx.getFieldArray(sfPermissions);
diff --git a/src/libxrpl/tx/transactors/Delegate/DelegateUtils.cpp b/src/libxrpl/tx/transactors/delegate/DelegateUtils.cpp
similarity index 95%
rename from src/libxrpl/tx/transactors/Delegate/DelegateUtils.cpp
rename to src/libxrpl/tx/transactors/delegate/DelegateUtils.cpp
index eceb73503f..d9d74a1212 100644
--- a/src/libxrpl/tx/transactors/Delegate/DelegateUtils.cpp
+++ b/src/libxrpl/tx/transactors/delegate/DelegateUtils.cpp
@@ -1,5 +1,5 @@
 #include <xrpl/protocol/STArray.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
 
 namespace xrpl {
 NotTEC
diff --git a/src/libxrpl/tx/transactors/AMM/AMMBid.cpp b/src/libxrpl/tx/transactors/dex/AMMBid.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/AMM/AMMBid.cpp
rename to src/libxrpl/tx/transactors/dex/AMMBid.cpp
index 8ba7970472..d73e65ec3a 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMBid.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMBid.cpp
@@ -4,9 +4,9 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMBid.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMBid.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/AMM/AMMClawback.cpp b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp
similarity index 95%
rename from src/libxrpl/tx/transactors/AMM/AMMClawback.cpp
rename to src/libxrpl/tx/transactors/dex/AMMClawback.cpp
index c9ea1e44eb..5b21f535d9 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMClawback.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp
@@ -4,10 +4,10 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/AMM/AMMClawback.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
-#include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
+#include <xrpl/tx/transactors/dex/AMMClawback.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMWithdraw.h>
 
 #include <tuple>
 
@@ -128,8 +128,7 @@ AMMClawback::applyGuts(Sandbox& sb)
 
     if (sb.rules().enabled(fixAMMClawbackRounding))
     {
-        // retrieve LP token balance inside the amendment gate to avoid
-        // inconsistent error behavior
+        // retrieve LP token balance inside the amendment gate to avoid inconsistent error behavior
         auto const lpTokenBalance = ammLPHolds(sb, *ammSle, holder, j_);
         if (lpTokenBalance == beast::zero)
             return tecAMM_BALANCE;
@@ -138,7 +137,6 @@ AMMClawback::applyGuts(Sandbox& sb)
             !res)
             return res.error();  // LCOV_EXCL_LINE
     }
-
     auto const expected =
         ammHolds(sb, *ammSle, asset, asset2, FreezeHandling::fhIGNORE_FREEZE, ctx_.journal);
 
@@ -151,6 +149,8 @@ AMMClawback::applyGuts(Sandbox& sb)
     STAmount amountWithdraw;
     std::optional<STAmount> amount2Withdraw;
 
+    // calling a second time on purpose since `verifyAndAdjustLPTokenBalance` rounds and may adjust
+    // the balance
     auto const holdLPtokens = ammLPHolds(sb, *ammSle, holder, j_);
     if (holdLPtokens == beast::zero)
         return tecAMM_BALANCE;
@@ -172,7 +172,7 @@ AMMClawback::applyGuts(Sandbox& sb)
                 0,
                 FreezeHandling::fhIGNORE_FREEZE,
                 WithdrawAll::Yes,
-                mPriorBalance,
+                preFeeBalance_,
                 ctx_.journal);
     else
         std::tie(result, newLPTokenBalance, amountWithdraw, amount2Withdraw) =
@@ -251,7 +251,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
             0,
             FreezeHandling::fhIGNORE_FREEZE,
             WithdrawAll::Yes,
-            mPriorBalance,
+            preFeeBalance_,
             ctx_.journal);
 
     auto const& rules = sb.rules();
@@ -282,7 +282,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
             0,
             FreezeHandling::fhIGNORE_FREEZE,
             WithdrawAll::No,
-            mPriorBalance,
+            preFeeBalance_,
             ctx_.journal);
     }
 
@@ -301,7 +301,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
         0,
         FreezeHandling::fhIGNORE_FREEZE,
         WithdrawAll::No,
-        mPriorBalance,
+        preFeeBalance_,
         ctx_.journal);
 }
 
diff --git a/src/libxrpl/tx/transactors/AMM/AMMCreate.cpp b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/AMM/AMMCreate.cpp
rename to src/libxrpl/tx/transactors/dex/AMMCreate.cpp
index 53933df629..1c5b2bae6f 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
@@ -5,9 +5,9 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMCreate.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMCreate.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/AMM/AMMDelete.cpp b/src/libxrpl/tx/transactors/dex/AMMDelete.cpp
similarity index 92%
rename from src/libxrpl/tx/transactors/AMM/AMMDelete.cpp
rename to src/libxrpl/tx/transactors/dex/AMMDelete.cpp
index 39b7c9a11b..da0ea4cb80 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMDelete.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMDelete.cpp
@@ -2,8 +2,8 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMDelete.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMDelete.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/AMM/AMMDeposit.cpp b/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/AMM/AMMDeposit.cpp
rename to src/libxrpl/tx/transactors/dex/AMMDeposit.cpp
index ba48295851..95535803c5 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMDeposit.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMDeposit.cpp
@@ -3,9 +3,9 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMDeposit.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMDeposit.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
@@ -17,9 +17,8 @@ AMMDeposit::checkExtraFeatures(PreflightContext const& ctx)
 
 std::uint32_t
 AMMDeposit::getFlagsMask(PreflightContext const& ctx)
-
 {
-    return tfDepositMask;
+    return tfAMMDepositMask;
 }
 
 NotTEC
diff --git a/src/libxrpl/tx/transactors/AMM/AMMHelpers.cpp b/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/AMM/AMMHelpers.cpp
rename to src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
index 5d5af6da03..75aa51c9d4 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMHelpers.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
@@ -1,4 +1,4 @@
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
 
 namespace xrpl {
 
@@ -257,9 +257,9 @@ multiply(STAmount const& amount, Number const& frac, Number::rounding_mode rm)
 STAmount
 getRoundedAsset(
     Rules const& rules,
-    std::function<Number()>&& noRoundCb,
+    std::function<Number()> const& noRoundCb,
     STAmount const& balance,
-    std::function<Number()>&& productCb,
+    std::function<Number()> const& productCb,
     IsDeposit isDeposit)
 {
     if (!rules.enabled(fixAMMv1_3))
@@ -290,9 +290,9 @@ getRoundedLPTokens(
 STAmount
 getRoundedLPTokens(
     Rules const& rules,
-    std::function<Number()>&& noRoundCb,
+    std::function<Number()> const& noRoundCb,
     STAmount const& lptAMMBalance,
-    std::function<Number()>&& productCb,
+    std::function<Number()> const& productCb,
     IsDeposit isDeposit)
 {
     if (!rules.enabled(fixAMMv1_3))
diff --git a/src/libxrpl/tx/transactors/AMM/AMMUtils.cpp b/src/libxrpl/tx/transactors/dex/AMMUtils.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/AMM/AMMUtils.cpp
rename to src/libxrpl/tx/transactors/dex/AMMUtils.cpp
index ac67e861f1..a4edaddb6f 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMUtils.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMUtils.cpp
@@ -1,9 +1,10 @@
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/STObject.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
@@ -153,7 +154,7 @@ getTradingFee(ReadView const& view, SLE const& ammSle, AccountID const& account)
         "xrpl::getTradingFee : auction present");
     if (ammSle.isFieldPresent(sfAuctionSlot))
     {
-        auto const& auctionSlot = static_cast<STObject const&>(ammSle.peekAtField(sfAuctionSlot));
+        auto const& auctionSlot = safe_downcast<STObject const&>(ammSle.peekAtField(sfAuctionSlot));
         // Not expired
         if (auto const expiration = auctionSlot[~sfExpiration];
             duration_cast<seconds>(view.header().parentCloseTime.time_since_epoch()).count() <
@@ -180,8 +181,9 @@ ammAccountHolds(ReadView const& view, AccountID const& ammAccountID, Issue const
         if (auto const sle = view.read(keylet::account(ammAccountID)))
             return (*sle)[sfBalance];
     }
-    else if (auto const sle = view.read(keylet::line(ammAccountID, issue.account, issue.currency));
-             sle && !isFrozen(view, ammAccountID, issue.currency, issue.account))
+    else if (
+        auto const sle = view.read(keylet::line(ammAccountID, issue.account, issue.currency));
+        sle && !isFrozen(view, ammAccountID, issue.currency, issue.account))
     {
         auto amount = (*sle)[sfBalance];
         if (ammAccountID > issue.account)
diff --git a/src/libxrpl/tx/transactors/AMM/AMMVote.cpp b/src/libxrpl/tx/transactors/dex/AMMVote.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/AMM/AMMVote.cpp
rename to src/libxrpl/tx/transactors/dex/AMMVote.cpp
index f40015ac08..d784b67f88 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMVote.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMVote.cpp
@@ -2,8 +2,8 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
-#include <xrpl/tx/transactors/AMM/AMMVote.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMVote.h>
 
 namespace xrpl {
 
@@ -42,8 +42,9 @@ AMMVote::preclaim(PreclaimContext const& ctx)
     }
     else if (ammSle->getFieldAmount(sfLPTokenBalance) == beast::zero)
         return tecAMM_EMPTY;
-    else if (auto const lpTokensNew = ammLPHolds(ctx.view, *ammSle, ctx.tx[sfAccount], ctx.j);
-             lpTokensNew == beast::zero)
+    else if (
+        auto const lpTokensNew = ammLPHolds(ctx.view, *ammSle, ctx.tx[sfAccount], ctx.j);
+        lpTokensNew == beast::zero)
     {
         JLOG(ctx.j.debug()) << "AMM Vote: account is not LP.";
         return tecAMM_INVALID_TOKENS;
diff --git a/src/libxrpl/tx/transactors/AMM/AMMWithdraw.cpp b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/AMM/AMMWithdraw.cpp
rename to src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
index 3c974ee4a4..39156f31d4 100644
--- a/src/libxrpl/tx/transactors/AMM/AMMWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
@@ -2,9 +2,9 @@
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
-#include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMWithdraw.h>
 
 namespace xrpl {
 
@@ -17,7 +17,7 @@ AMMWithdraw::checkExtraFeatures(PreflightContext const& ctx)
 std::uint32_t
 AMMWithdraw::getFlagsMask(PreflightContext const& ctx)
 {
-    return tfWithdrawMask;
+    return tfAMMWithdrawMask;
 }
 
 NotTEC
@@ -414,7 +414,7 @@ AMMWithdraw::withdraw(
         tfee,
         FreezeHandling::fhZERO_IF_FROZEN,
         isWithdrawAll(ctx_.tx),
-        mPriorBalance,
+        preFeeBalance_,
         j_);
     return {ter, newLPTokenBalance};
 }
@@ -628,7 +628,7 @@ AMMWithdraw::equalWithdrawTokens(
         tfee,
         FreezeHandling::fhZERO_IF_FROZEN,
         isWithdrawAll(ctx_.tx),
-        mPriorBalance,
+        preFeeBalance_,
         ctx_.journal);
     return {ter, newLPTokenBalance};
 }
@@ -676,7 +676,7 @@ AMMWithdraw::equalWithdrawTokens(
     STAmount const& lpTokens,
     STAmount const& lpTokensWithdraw,
     std::uint16_t tfee,
-    FreezeHandling freezeHanding,
+    FreezeHandling freezeHandling,
     WithdrawAll withdrawAll,
     XRPAmount const& priorBalance,
     beast::Journal const& journal)
@@ -697,7 +697,7 @@ AMMWithdraw::equalWithdrawTokens(
                 lptAMMBalance,
                 lpTokensWithdraw,
                 tfee,
-                freezeHanding,
+                freezeHandling,
                 WithdrawAll::Yes,
                 priorBalance,
                 journal);
@@ -731,7 +731,7 @@ AMMWithdraw::equalWithdrawTokens(
             lptAMMBalance,
             tokensAdj,
             tfee,
-            freezeHanding,
+            freezeHandling,
             withdrawAll,
             priorBalance,
             journal);
diff --git a/src/libxrpl/tx/transactors/Offer/CancelOffer.cpp b/src/libxrpl/tx/transactors/dex/CancelOffer.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/Offer/CancelOffer.cpp
rename to src/libxrpl/tx/transactors/dex/CancelOffer.cpp
index 3e5d2441e1..2549fd327e 100644
--- a/src/libxrpl/tx/transactors/Offer/CancelOffer.cpp
+++ b/src/libxrpl/tx/transactors/dex/CancelOffer.cpp
@@ -1,7 +1,7 @@
 #include <xrpl/basics/Log.h>
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/Offer/CancelOffer.h>
+#include <xrpl/tx/transactors/dex/CancelOffer.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Offer/CreateOffer.cpp b/src/libxrpl/tx/transactors/dex/CreateOffer.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Offer/CreateOffer.cpp
rename to src/libxrpl/tx/transactors/dex/CreateOffer.cpp
index 9516926693..c176203da7 100644
--- a/src/libxrpl/tx/transactors/Offer/CreateOffer.cpp
+++ b/src/libxrpl/tx/transactors/dex/CreateOffer.cpp
@@ -8,8 +8,8 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/st.h>
 #include <xrpl/tx/paths/Flow.h>
-#include <xrpl/tx/transactors/Offer/CreateOffer.h>
-#include <xrpl/tx/transactors/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/dex/CreateOffer.h>
+#include <xrpl/tx/transactors/dex/PermissionedDEXHelpers.h>
 
 namespace xrpl {
 TxConsequences
@@ -214,8 +214,10 @@ CreateOffer::checkAcceptAsset(
         return (flags & tapRETRY) ? TER{terNO_ACCOUNT} : TER{tecNO_ISSUER};
     }
 
+    // An account cannot create a trustline to itself, so no line can exist
+    // to be frozen. Additionally, an issuer can always accept its own
+    // issuance.
     if (issue.account == id)
-        // An account can always accept its own issuance.
         return tesSUCCESS;
 
     if ((*issuerAccount)[sfFlags] & lsfRequireAuth)
@@ -242,14 +244,6 @@ CreateOffer::checkAcceptAsset(
         }
     }
 
-    // An account can not create a trustline to itself, so no line can exist
-    // to be frozen. Additionally, an issuer can always accept its own
-    // issuance.
-    if (issue.account == id)
-    {
-        return tesSUCCESS;
-    }
-
     auto const trustLine = view.read(keylet::line(id, issue.account, issue.currency));
 
     if (!trustLine)
@@ -733,7 +727,7 @@ CreateOffer::applyGuts(Sandbox& sb, Sandbox& sbCancel)
     {
         XRPAmount reserve = sb.fees().accountReserve(sleCreator->getFieldU32(sfOwnerCount) + 1);
 
-        if (mPriorBalance < reserve)
+        if (preFeeBalance_ < reserve)
         {
             // If we are here, the signing account had an insufficient reserve
             // *prior* to our processing. If something actually crossed, then
diff --git a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDEXHelpers.cpp b/src/libxrpl/tx/transactors/dex/PermissionedDEXHelpers.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDEXHelpers.cpp
rename to src/libxrpl/tx/transactors/dex/PermissionedDEXHelpers.cpp
index 7a4fa62078..37db2d632f 100644
--- a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDEXHelpers.cpp
+++ b/src/libxrpl/tx/transactors/dex/PermissionedDEXHelpers.cpp
@@ -1,5 +1,5 @@
 #include <xrpl/ledger/CredentialHelpers.h>
-#include <xrpl/tx/transactors/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/dex/PermissionedDEXHelpers.h>
 
 namespace xrpl {
 namespace permissioned_dex {
diff --git a/src/libxrpl/tx/transactors/did/DIDDelete.cpp b/src/libxrpl/tx/transactors/did/DIDDelete.cpp
new file mode 100644
index 0000000000..e09fdd3510
--- /dev/null
+++ b/src/libxrpl/tx/transactors/did/DIDDelete.cpp
@@ -0,0 +1,59 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/tx/transactors/did/DIDDelete.h>
+
+namespace xrpl {
+
+NotTEC
+DIDDelete::preflight(PreflightContext const& ctx)
+{
+    return tesSUCCESS;
+}
+
+TER
+DIDDelete::deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner)
+{
+    auto const sle = ctx.view().peek(sleKeylet);
+    if (!sle)
+        return tecNO_ENTRY;
+
+    return DIDDelete::deleteSLE(ctx.view(), sle, owner, ctx.journal);
+}
+
+TER
+DIDDelete::deleteSLE(
+    ApplyView& view,
+    std::shared_ptr<SLE> sle,
+    AccountID const owner,
+    beast::Journal j)
+{
+    // Remove object from owner directory
+    if (!view.dirRemove(keylet::ownerDir(owner), (*sle)[sfOwnerNode], sle->key(), true))
+    {
+        // LCOV_EXCL_START
+        JLOG(j.fatal()) << "Unable to delete DID from owner.";
+        return tefBAD_LEDGER;
+        // LCOV_EXCL_STOP
+    }
+
+    auto const sleOwner = view.peek(keylet::account(owner));
+    if (!sleOwner)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    adjustOwnerCount(view, sleOwner, -1, j);
+    view.update(sleOwner);
+
+    // Remove object from ledger
+    view.erase(sle);
+    return tesSUCCESS;
+}
+
+TER
+DIDDelete::doApply()
+{
+    return deleteSLE(ctx_, keylet::did(account_), account_);
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/DID.cpp b/src/libxrpl/tx/transactors/did/DIDSet.cpp
similarity index 76%
rename from src/libxrpl/tx/transactors/DID.cpp
rename to src/libxrpl/tx/transactors/did/DIDSet.cpp
index ade60221df..32edbce82e 100644
--- a/src/libxrpl/tx/transactors/DID.cpp
+++ b/src/libxrpl/tx/transactors/did/DIDSet.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/DID.h>
+#include <xrpl/tx/transactors/did/DIDSet.h>
 
 namespace xrpl {
 
@@ -41,13 +41,13 @@ DIDSet::preflight(PreflightContext const& ctx)
     };
 
     if (isTooLong(sfURI, maxDIDURILength) || isTooLong(sfDIDDocument, maxDIDDocumentLength) ||
-        isTooLong(sfData, maxDIDAttestationLength))
+        isTooLong(sfData, maxDIDDataLength))
         return temMALFORMED;
 
     return tesSUCCESS;
 }
 
-TER
+static TER
 addSLE(ApplyContext& ctx, std::shared_ptr<SLE> const& sle, AccountID const& owner)
 {
     auto const sleAccount = ctx.view().peek(keylet::account(owner));
@@ -134,54 +134,4 @@ DIDSet::doApply()
     return addSLE(ctx_, sleDID, account_);
 }
 
-NotTEC
-DIDDelete::preflight(PreflightContext const& ctx)
-{
-    return tesSUCCESS;
-}
-
-TER
-DIDDelete::deleteSLE(ApplyContext& ctx, Keylet sleKeylet, AccountID const owner)
-{
-    auto const sle = ctx.view().peek(sleKeylet);
-    if (!sle)
-        return tecNO_ENTRY;
-
-    return DIDDelete::deleteSLE(ctx.view(), sle, owner, ctx.journal);
-}
-
-TER
-DIDDelete::deleteSLE(
-    ApplyView& view,
-    std::shared_ptr<SLE> sle,
-    AccountID const owner,
-    beast::Journal j)
-{
-    // Remove object from owner directory
-    if (!view.dirRemove(keylet::ownerDir(owner), (*sle)[sfOwnerNode], sle->key(), true))
-    {
-        // LCOV_EXCL_START
-        JLOG(j.fatal()) << "Unable to delete DID Token from owner.";
-        return tefBAD_LEDGER;
-        // LCOV_EXCL_STOP
-    }
-
-    auto const sleOwner = view.peek(keylet::account(owner));
-    if (!sleOwner)
-        return tecINTERNAL;  // LCOV_EXCL_LINE
-
-    adjustOwnerCount(view, sleOwner, -1, j);
-    view.update(sleOwner);
-
-    // Remove object from ledger
-    view.erase(sle);
-    return tesSUCCESS;
-}
-
-TER
-DIDDelete::doApply()
-{
-    return deleteSLE(ctx_, keylet::did(account_), account_);
-}
-
 }  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
new file mode 100644
index 0000000000..28194e4133
--- /dev/null
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
@@ -0,0 +1,201 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/tx/transactors/escrow/EscrowCancel.h>
+
+#include <libxrpl/tx/transactors/escrow/EscrowHelpers.h>
+
+namespace xrpl {
+
+NotTEC
+EscrowCancel::preflight(PreflightContext const& ctx)
+{
+    return tesSUCCESS;
+}
+
+template <ValidIssueType T>
+static TER
+escrowCancelPreclaimHelper(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    STAmount const& amount);
+
+template <>
+TER
+escrowCancelPreclaimHelper<Issue>(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the account, return tecINTERNAL
+    if (issuer == account)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    // If the issuer has requireAuth set, check if the account is authorized
+    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
+        return ter;
+
+    return tesSUCCESS;
+}
+
+template <>
+TER
+escrowCancelPreclaimHelper<MPTIssue>(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the account, return tecINTERNAL
+    if (issuer == account)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
+    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
+    auto const sleIssuance = ctx.view.read(issuanceKey);
+    if (!sleIssuance)
+        return tecOBJECT_NOT_FOUND;
+
+    // If the issuer has requireAuth set, check if the account is
+    // authorized
+    auto const& mptIssue = amount.get<MPTIssue>();
+    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
+        ter != tesSUCCESS)
+        return ter;
+
+    return tesSUCCESS;
+}
+
+TER
+EscrowCancel::preclaim(PreclaimContext const& ctx)
+{
+    if (ctx.view.rules().enabled(featureTokenEscrow))
+    {
+        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
+        auto const slep = ctx.view.read(k);
+        if (!slep)
+            return tecNO_TARGET;
+
+        AccountID const account = (*slep)[sfAccount];
+        STAmount const amount = (*slep)[sfAmount];
+
+        if (!isXRP(amount))
+        {
+            if (auto const ret = std::visit(
+                    [&]<typename T>(T const&) {
+                        return escrowCancelPreclaimHelper<T>(ctx, account, amount);
+                    },
+                    amount.asset().value());
+                !isTesSuccess(ret))
+                return ret;
+        }
+    }
+    return tesSUCCESS;
+}
+
+TER
+EscrowCancel::doApply()
+{
+    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+    {
+        if (ctx_.view().rules().enabled(featureTokenEscrow))
+            return tecINTERNAL;  // LCOV_EXCL_LINE
+
+        return tecNO_TARGET;
+    }
+
+    auto const now = ctx_.view().header().parentCloseTime;
+
+    // No cancel time specified: can't execute at all.
+    if (!(*slep)[~sfCancelAfter])
+        return tecNO_PERMISSION;
+
+    // Too soon: can't execute before the cancel time.
+    if (!after(now, (*slep)[sfCancelAfter]))
+        return tecNO_PERMISSION;
+
+    AccountID const account = (*slep)[sfAccount];
+
+    // Remove escrow from owner directory
+    {
+        auto const page = (*slep)[sfOwnerNode];
+        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Remove escrow from recipient's owner directory, if present.
+    if (auto const optPage = (*slep)[~sfDestinationNode]; optPage)
+    {
+        if (!ctx_.view().dirRemove(keylet::ownerDir((*slep)[sfDestination]), *optPage, k.key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    STAmount const amount = slep->getFieldAmount(sfAmount);
+
+    // Transfer amount back to the owner
+    if (isXRP(amount))
+        (*sle)[sfBalance] = (*sle)[sfBalance] + amount;
+    else
+    {
+        if (!ctx_.view().rules().enabled(featureTokenEscrow))
+            return temDISABLED;  // LCOV_EXCL_LINE
+
+        auto const issuer = amount.getIssuer();
+        bool const createAsset = account == account_;
+        if (auto const ret = std::visit(
+                [&]<typename T>(T const&) {
+                    return escrowUnlockApplyHelper<T>(
+                        ctx_.view(),
+                        parityRate,
+                        slep,
+                        preFeeBalance_,
+                        amount,
+                        issuer,
+                        account,  // sender and receiver are the same
+                        account,
+                        createAsset,
+                        j_);
+                },
+                amount.asset().value());
+            !isTesSuccess(ret))
+            return ret;  // LCOV_EXCL_LINE
+
+        // Remove escrow from issuers owner directory, if present.
+        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
+        {
+            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
+            {
+                // LCOV_EXCL_START
+                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
+                return tefBAD_LEDGER;
+                // LCOV_EXCL_STOP
+            }
+        }
+    }
+
+    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
+    ctx_.view().update(sle);
+
+    // Remove escrow from ledger
+    ctx_.view().erase(slep);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
new file mode 100644
index 0000000000..ef46328de1
--- /dev/null
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -0,0 +1,499 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/conditions/Condition.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTAmount.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/transactors/escrow/EscrowCreate.h>
+
+namespace xrpl {
+
+/*
+    Escrow
+    ======
+
+    Escrow is a feature of the XRP Ledger that allows you to send conditional
+    XRP payments. These conditional payments, called escrows, set aside XRP and
+    deliver it later when certain conditions are met. Conditions to successfully
+    finish an escrow include time-based unlocks and crypto-conditions. Escrows
+    can also be set to expire if not finished in time.
+
+    The XRP set aside in an escrow is locked up. No one can use or destroy the
+    XRP until the escrow has been successfully finished or canceled. Before the
+    expiration time, only the intended receiver can get the XRP. After the
+    expiration time, the XRP can only be returned to the sender.
+
+    For more details on escrow, including examples, diagrams and more please
+    visit https://xrpl.org/escrow.html
+
+    For details on specific transactions, including fields and validation rules
+    please see:
+
+    `EscrowCreate`
+    --------------
+        See: https://xrpl.org/escrowcreate.html
+
+    `EscrowFinish`
+    --------------
+        See: https://xrpl.org/escrowfinish.html
+
+    `EscrowCancel`
+    --------------
+        See: https://xrpl.org/escrowcancel.html
+*/
+
+//------------------------------------------------------------------------------
+
+TxConsequences
+EscrowCreate::makeTxConsequences(PreflightContext const& ctx)
+{
+    auto const amount = ctx.tx[sfAmount];
+    return TxConsequences{ctx.tx, isXRP(amount) ? amount.xrp() : beast::zero};
+}
+
+template <ValidIssueType T>
+static NotTEC
+escrowCreatePreflightHelper(PreflightContext const& ctx);
+
+template <>
+NotTEC
+escrowCreatePreflightHelper<Issue>(PreflightContext const& ctx)
+{
+    STAmount const amount = ctx.tx[sfAmount];
+    if (amount.native() || amount <= beast::zero)
+        return temBAD_AMOUNT;
+
+    if (badCurrency() == amount.getCurrency())
+        return temBAD_CURRENCY;
+
+    return tesSUCCESS;
+}
+
+template <>
+NotTEC
+escrowCreatePreflightHelper<MPTIssue>(PreflightContext const& ctx)
+{
+    if (!ctx.rules.enabled(featureMPTokensV1))
+        return temDISABLED;
+
+    auto const amount = ctx.tx[sfAmount];
+    if (amount.native() || amount.mpt() > MPTAmount{maxMPTokenAmount} || amount <= beast::zero)
+        return temBAD_AMOUNT;
+
+    return tesSUCCESS;
+}
+
+NotTEC
+EscrowCreate::preflight(PreflightContext const& ctx)
+{
+    STAmount const amount{ctx.tx[sfAmount]};
+    if (!isXRP(amount))
+    {
+        if (!ctx.rules.enabled(featureTokenEscrow))
+            return temBAD_AMOUNT;
+
+        if (auto const ret = std::visit(
+                [&]<typename T>(T const&) { return escrowCreatePreflightHelper<T>(ctx); },
+                amount.asset().value());
+            !isTesSuccess(ret))
+            return ret;
+    }
+    else
+    {
+        if (amount <= beast::zero)
+            return temBAD_AMOUNT;
+    }
+
+    // We must specify at least one timeout value
+    if (!ctx.tx[~sfCancelAfter] && !ctx.tx[~sfFinishAfter])
+        return temBAD_EXPIRATION;
+
+    // If both finish and cancel times are specified then the cancel time must
+    // be strictly after the finish time.
+    if (ctx.tx[~sfCancelAfter] && ctx.tx[~sfFinishAfter] &&
+        ctx.tx[sfCancelAfter] <= ctx.tx[sfFinishAfter])
+        return temBAD_EXPIRATION;
+
+    // In the absence of a FinishAfter, the escrow can be finished
+    // immediately, which can be confusing. When creating an escrow,
+    // we want to ensure that either a FinishAfter time is explicitly
+    // specified or a completion condition is attached.
+    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition])
+        return temMALFORMED;
+
+    if (auto const cb = ctx.tx[~sfCondition])
+    {
+        using namespace xrpl::cryptoconditions;
+
+        std::error_code ec;
+
+        auto condition = Condition::deserialize(*cb, ec);
+        if (!condition)
+        {
+            JLOG(ctx.j.debug()) << "Malformed condition during escrow creation: " << ec.message();
+            return temMALFORMED;
+        }
+    }
+
+    return tesSUCCESS;
+}
+
+template <ValidIssueType T>
+static TER
+escrowCreatePreclaimHelper(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    AccountID const& dest,
+    STAmount const& amount);
+
+template <>
+TER
+escrowCreatePreclaimHelper<Issue>(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    AccountID const& dest,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the account, return tecNO_PERMISSION
+    if (issuer == account)
+        return tecNO_PERMISSION;
+
+    // If the lsfAllowTrustLineLocking is not enabled, return tecNO_PERMISSION
+    auto const sleIssuer = ctx.view.read(keylet::account(issuer));
+    if (!sleIssuer)
+        return tecNO_ISSUER;
+    if (!sleIssuer->isFlag(lsfAllowTrustLineLocking))
+        return tecNO_PERMISSION;
+
+    // If the account does not have a trustline to the issuer, return tecNO_LINE
+    auto const sleRippleState = ctx.view.read(keylet::line(account, issuer, amount.getCurrency()));
+    if (!sleRippleState)
+        return tecNO_LINE;
+
+    STAmount const balance = (*sleRippleState)[sfBalance];
+
+    // If balance is positive, issuer must have higher address than account
+    if (balance > beast::zero && issuer < account)
+        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
+
+    // If balance is negative, issuer must have lower address than account
+    if (balance < beast::zero && issuer > account)
+        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
+
+    // If the issuer has requireAuth set, check if the account is authorized
+    if (auto const ter = requireAuth(ctx.view, amount.issue(), account); ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has requireAuth set, check if the destination is authorized
+    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has frozen the account, return tecFROZEN
+    if (isFrozen(ctx.view, account, amount.issue()))
+        return tecFROZEN;
+
+    // If the issuer has frozen the destination, return tecFROZEN
+    if (isFrozen(ctx.view, dest, amount.issue()))
+        return tecFROZEN;
+
+    STAmount const spendableAmount =
+        accountHolds(ctx.view, account, amount.getCurrency(), issuer, fhIGNORE_FREEZE, ctx.j);
+
+    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
+    if (spendableAmount <= beast::zero)
+        return tecINSUFFICIENT_FUNDS;
+
+    // If the spendable amount is less than the amount, return
+    // tecINSUFFICIENT_FUNDS
+    if (spendableAmount < amount)
+        return tecINSUFFICIENT_FUNDS;
+
+    // If the amount is not addable to the balance, return tecPRECISION_LOSS
+    if (!canAdd(spendableAmount, amount))
+        return tecPRECISION_LOSS;
+
+    return tesSUCCESS;
+}
+
+template <>
+TER
+escrowCreatePreclaimHelper<MPTIssue>(
+    PreclaimContext const& ctx,
+    AccountID const& account,
+    AccountID const& dest,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the account, return tecNO_PERMISSION
+    if (issuer == account)
+        return tecNO_PERMISSION;
+
+    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
+    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
+    auto const sleIssuance = ctx.view.read(issuanceKey);
+    if (!sleIssuance)
+        return tecOBJECT_NOT_FOUND;
+
+    // If the lsfMPTCanEscrow is not enabled, return tecNO_PERMISSION
+    if (!sleIssuance->isFlag(lsfMPTCanEscrow))
+        return tecNO_PERMISSION;
+
+    // If the issuer is not the same as the issuer of the mpt, return
+    // tecNO_PERMISSION
+    if (sleIssuance->getAccountID(sfIssuer) != issuer)
+        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
+
+    // If the account does not have the mpt, return tecOBJECT_NOT_FOUND
+    if (!ctx.view.exists(keylet::mptoken(issuanceKey.key, account)))
+        return tecOBJECT_NOT_FOUND;
+
+    // If the issuer has requireAuth set, check if the account is
+    // authorized
+    auto const& mptIssue = amount.get<MPTIssue>();
+    if (auto const ter = requireAuth(ctx.view, mptIssue, account, AuthType::WeakAuth);
+        ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has requireAuth set, check if the destination is
+    // authorized
+    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
+        ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has frozen the account, return tecLOCKED
+    if (isFrozen(ctx.view, account, mptIssue))
+        return tecLOCKED;
+
+    // If the issuer has frozen the destination, return tecLOCKED
+    if (isFrozen(ctx.view, dest, mptIssue))
+        return tecLOCKED;
+
+    // If the mpt cannot be transferred, return tecNO_AUTH
+    if (auto const ter = canTransfer(ctx.view, mptIssue, account, dest); ter != tesSUCCESS)
+        return ter;
+
+    STAmount const spendableAmount = accountHolds(
+        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j);
+
+    // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
+    if (spendableAmount <= beast::zero)
+        return tecINSUFFICIENT_FUNDS;
+
+    // If the spendable amount is less than the amount, return
+    // tecINSUFFICIENT_FUNDS
+    if (spendableAmount < amount)
+        return tecINSUFFICIENT_FUNDS;
+
+    return tesSUCCESS;
+}
+
+TER
+EscrowCreate::preclaim(PreclaimContext const& ctx)
+{
+    STAmount const amount{ctx.tx[sfAmount]};
+    AccountID const account{ctx.tx[sfAccount]};
+    AccountID const dest{ctx.tx[sfDestination]};
+
+    auto const sled = ctx.view.read(keylet::account(dest));
+    if (!sled)
+        return tecNO_DST;
+
+    // Pseudo-accounts cannot receive escrow. Note, this is not amendment-gated
+    // because all writes to pseudo-account discriminator fields **are**
+    // amendment gated, hence the behaviour of this check will always match the
+    // currently active amendments.
+    if (isPseudoAccount(sled))
+        return tecNO_PERMISSION;
+
+    if (!isXRP(amount))
+    {
+        if (!ctx.view.rules().enabled(featureTokenEscrow))
+            return temDISABLED;  // LCOV_EXCL_LINE
+
+        if (auto const ret = std::visit(
+                [&]<typename T>(T const&) {
+                    return escrowCreatePreclaimHelper<T>(ctx, account, dest, amount);
+                },
+                amount.asset().value());
+            !isTesSuccess(ret))
+            return ret;
+    }
+    return tesSUCCESS;
+}
+
+template <ValidIssueType T>
+static TER
+escrowLockApplyHelper(
+    ApplyView& view,
+    AccountID const& issuer,
+    AccountID const& sender,
+    STAmount const& amount,
+    beast::Journal journal);
+
+template <>
+TER
+escrowLockApplyHelper<Issue>(
+    ApplyView& view,
+    AccountID const& issuer,
+    AccountID const& sender,
+    STAmount const& amount,
+    beast::Journal journal)
+{
+    // Defensive: Issuer cannot create an escrow
+    if (issuer == sender)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    auto const ter = rippleCredit(
+        view, sender, issuer, amount, amount.holds<MPTIssue>() ? false : true, journal);
+    if (ter != tesSUCCESS)
+        return ter;  // LCOV_EXCL_LINE
+    return tesSUCCESS;
+}
+
+template <>
+TER
+escrowLockApplyHelper<MPTIssue>(
+    ApplyView& view,
+    AccountID const& issuer,
+    AccountID const& sender,
+    STAmount const& amount,
+    beast::Journal journal)
+{
+    // Defensive: Issuer cannot create an escrow
+    if (issuer == sender)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    auto const ter = rippleLockEscrowMPT(view, sender, amount, journal);
+    if (ter != tesSUCCESS)
+        return ter;  // LCOV_EXCL_LINE
+    return tesSUCCESS;
+}
+
+TER
+EscrowCreate::doApply()
+{
+    auto const closeTime = ctx_.view().header().parentCloseTime;
+
+    if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
+        return tecNO_PERMISSION;
+
+    if (ctx_.tx[~sfFinishAfter] && after(closeTime, ctx_.tx[sfFinishAfter]))
+        return tecNO_PERMISSION;
+
+    auto const sle = ctx_.view().peek(keylet::account(account_));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    // Check reserve and funds availability
+    STAmount const amount{ctx_.tx[sfAmount]};
+
+    auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
+
+    auto const balance = sle->getFieldAmount(sfBalance).xrp();
+    if (balance < reserve)
+        return tecINSUFFICIENT_RESERVE;
+
+    // Check reserve and funds availability
+    if (isXRP(amount))
+    {
+        if (balance < reserve + STAmount(amount).xrp())
+            return tecUNFUNDED;
+    }
+
+    // Check destination account
+    {
+        auto const sled = ctx_.view().read(keylet::account(ctx_.tx[sfDestination]));
+        if (!sled)
+            return tecNO_DST;  // LCOV_EXCL_LINE
+        if (((*sled)[sfFlags] & lsfRequireDestTag) && !ctx_.tx[~sfDestinationTag])
+            return tecDST_TAG_NEEDED;
+    }
+
+    // Create escrow in ledger.  Note that we we use the value from the
+    // sequence or ticket.  For more explanation see comments in SeqProxy.h.
+    Keylet const escrowKeylet = keylet::escrow(account_, ctx_.tx.getSeqValue());
+    auto const slep = std::make_shared<SLE>(escrowKeylet);
+    (*slep)[sfAmount] = amount;
+    (*slep)[sfAccount] = account_;
+    (*slep)[~sfCondition] = ctx_.tx[~sfCondition];
+    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
+    (*slep)[sfDestination] = ctx_.tx[sfDestination];
+    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
+    (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
+    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
+
+    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
+    {
+        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
+    }
+
+    if (ctx_.view().rules().enabled(featureTokenEscrow) && !isXRP(amount))
+    {
+        auto const xferRate = transferRate(ctx_.view(), amount);
+        if (xferRate != parityRate)
+            (*slep)[sfTransferRate] = xferRate.value;
+    }
+
+    ctx_.view().insert(slep);
+
+    // Add escrow to sender's owner directory
+    {
+        auto page = ctx_.view().dirInsert(
+            keylet::ownerDir(account_), escrowKeylet, describeOwnerDir(account_));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfOwnerNode] = *page;
+    }
+
+    // If it's not a self-send, add escrow to recipient's owner directory.
+    AccountID const dest = ctx_.tx[sfDestination];
+    if (dest != account_)
+    {
+        auto page =
+            ctx_.view().dirInsert(keylet::ownerDir(dest), escrowKeylet, describeOwnerDir(dest));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfDestinationNode] = *page;
+    }
+
+    // IOU escrow objects are added to the issuer's owner directory to help
+    // track the total locked balance. For MPT, this isn't necessary because the
+    // locked balance is already stored directly in the MPTokenIssuance object.
+    AccountID const issuer = amount.getIssuer();
+    if (!isXRP(amount) && issuer != account_ && issuer != dest && !amount.holds<MPTIssue>())
+    {
+        auto page =
+            ctx_.view().dirInsert(keylet::ownerDir(issuer), escrowKeylet, describeOwnerDir(issuer));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfIssuerNode] = *page;
+    }
+
+    // Deduct owner's balance
+    if (isXRP(amount))
+        (*sle)[sfBalance] = (*sle)[sfBalance] - amount;
+    else
+    {
+        if (auto const ret = std::visit(
+                [&]<typename T>(T const&) {
+                    return escrowLockApplyHelper<T>(ctx_.view(), issuer, account_, amount, j_);
+                },
+                amount.asset().value());
+            !isTesSuccess(ret))
+        {
+            return ret;  // LCOV_EXCL_LINE
+        }
+    }
+
+    // increment owner count
+    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
+    ctx_.view().update(sle);
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
new file mode 100644
index 0000000000..bab2016aae
--- /dev/null
+++ b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
@@ -0,0 +1,372 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/conditions/Condition.h>
+#include <xrpl/conditions/Fulfillment.h>
+#include <xrpl/core/HashRouter.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/transactors/escrow/EscrowFinish.h>
+
+#include <libxrpl/tx/transactors/escrow/EscrowHelpers.h>
+
+namespace xrpl {
+
+// During an EscrowFinish, the transaction must specify both
+// a condition and a fulfillment. We track whether that
+// fulfillment matches and validates the condition.
+constexpr HashRouterFlags SF_CF_INVALID = HashRouterFlags::PRIVATE5;
+constexpr HashRouterFlags SF_CF_VALID = HashRouterFlags::PRIVATE6;
+
+//------------------------------------------------------------------------------
+
+static bool
+checkCondition(Slice f, Slice c)
+{
+    using namespace xrpl::cryptoconditions;
+
+    std::error_code ec;
+
+    auto condition = Condition::deserialize(c, ec);
+    if (!condition)
+        return false;
+
+    auto fulfillment = Fulfillment::deserialize(f, ec);
+    if (!fulfillment)
+        return false;
+
+    return validate(*fulfillment, *condition);
+}
+
+bool
+EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
+{
+    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
+}
+
+NotTEC
+EscrowFinish::preflight(PreflightContext const& ctx)
+{
+    auto const cb = ctx.tx[~sfCondition];
+    auto const fb = ctx.tx[~sfFulfillment];
+
+    // If you specify a condition, then you must also specify
+    // a fulfillment.
+    if (static_cast<bool>(cb) != static_cast<bool>(fb))
+        return temMALFORMED;
+
+    return tesSUCCESS;
+}
+
+NotTEC
+EscrowFinish::preflightSigValidated(PreflightContext const& ctx)
+{
+    auto const cb = ctx.tx[~sfCondition];
+    auto const fb = ctx.tx[~sfFulfillment];
+
+    if (cb && fb)
+    {
+        auto& router = ctx.registry.getHashRouter();
+
+        auto const id = ctx.tx.getTransactionID();
+        auto const flags = router.getFlags(id);
+
+        // If we haven't checked the condition, check it
+        // now. Whether it passes or not isn't important
+        // in preflight.
+        if (!any(flags & (SF_CF_INVALID | SF_CF_VALID)))
+        {
+            if (checkCondition(*fb, *cb))
+                router.setFlags(id, SF_CF_VALID);
+            else
+                router.setFlags(id, SF_CF_INVALID);
+        }
+    }
+
+    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
+        return err;
+
+    return tesSUCCESS;
+}
+
+XRPAmount
+EscrowFinish::calculateBaseFee(ReadView const& view, STTx const& tx)
+{
+    XRPAmount extraFee{0};
+
+    if (auto const fb = tx[~sfFulfillment])
+    {
+        extraFee += view.fees().base * (32 + (fb->size() / 16));
+    }
+
+    return Transactor::calculateBaseFee(view, tx) + extraFee;
+}
+
+template <ValidIssueType T>
+static TER
+escrowFinishPreclaimHelper(
+    PreclaimContext const& ctx,
+    AccountID const& dest,
+    STAmount const& amount);
+
+template <>
+TER
+escrowFinishPreclaimHelper<Issue>(
+    PreclaimContext const& ctx,
+    AccountID const& dest,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the account, return tesSUCCESS
+    if (issuer == dest)
+        return tesSUCCESS;
+
+    // If the issuer has requireAuth set, check if the destination is authorized
+    if (auto const ter = requireAuth(ctx.view, amount.issue(), dest); ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has deep frozen the destination, return tecFROZEN
+    if (isDeepFrozen(ctx.view, dest, amount.getCurrency(), amount.getIssuer()))
+        return tecFROZEN;
+
+    return tesSUCCESS;
+}
+
+template <>
+TER
+escrowFinishPreclaimHelper<MPTIssue>(
+    PreclaimContext const& ctx,
+    AccountID const& dest,
+    STAmount const& amount)
+{
+    AccountID issuer = amount.getIssuer();
+    // If the issuer is the same as the dest, return tesSUCCESS
+    if (issuer == dest)
+        return tesSUCCESS;
+
+    // If the mpt does not exist, return tecOBJECT_NOT_FOUND
+    auto const issuanceKey = keylet::mptIssuance(amount.get<MPTIssue>().getMptID());
+    auto const sleIssuance = ctx.view.read(issuanceKey);
+    if (!sleIssuance)
+        return tecOBJECT_NOT_FOUND;
+
+    // If the issuer has requireAuth set, check if the destination is
+    // authorized
+    auto const& mptIssue = amount.get<MPTIssue>();
+    if (auto const ter = requireAuth(ctx.view, mptIssue, dest, AuthType::WeakAuth);
+        ter != tesSUCCESS)
+        return ter;
+
+    // If the issuer has frozen the destination, return tecLOCKED
+    if (isFrozen(ctx.view, dest, mptIssue))
+        return tecLOCKED;
+
+    return tesSUCCESS;
+}
+
+TER
+EscrowFinish::preclaim(PreclaimContext const& ctx)
+{
+    if (ctx.view.rules().enabled(featureCredentials))
+    {
+        if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
+            !isTesSuccess(err))
+            return err;
+    }
+
+    if (ctx.view.rules().enabled(featureTokenEscrow))
+    {
+        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
+        auto const slep = ctx.view.read(k);
+        if (!slep)
+            return tecNO_TARGET;
+
+        AccountID const dest = (*slep)[sfDestination];
+        STAmount const amount = (*slep)[sfAmount];
+
+        if (!isXRP(amount))
+        {
+            if (auto const ret = std::visit(
+                    [&]<typename T>(T const&) {
+                        return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
+                    },
+                    amount.asset().value());
+                !isTesSuccess(ret))
+                return ret;
+        }
+    }
+    return tesSUCCESS;
+}
+
+TER
+EscrowFinish::doApply()
+{
+    auto const k = keylet::escrow(ctx_.tx[sfOwner], ctx_.tx[sfOfferSequence]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+    {
+        if (ctx_.view().rules().enabled(featureTokenEscrow))
+            return tecINTERNAL;  // LCOV_EXCL_LINE
+
+        return tecNO_TARGET;
+    }
+
+    // If a cancel time is present, a finish operation should only succeed prior
+    // to that time.
+    auto const now = ctx_.view().header().parentCloseTime;
+
+    // Too soon: can't execute before the finish time
+    if ((*slep)[~sfFinishAfter] && !after(now, (*slep)[sfFinishAfter]))
+        return tecNO_PERMISSION;
+
+    // Too late: can't execute after the cancel time
+    if ((*slep)[~sfCancelAfter] && after(now, (*slep)[sfCancelAfter]))
+        return tecNO_PERMISSION;
+
+    // Check cryptocondition fulfillment
+    {
+        auto const id = ctx_.tx.getTransactionID();
+        auto flags = ctx_.registry.getHashRouter().getFlags(id);
+
+        auto const cb = ctx_.tx[~sfCondition];
+
+        // It's unlikely that the results of the check will
+        // expire from the hash router, but if it happens,
+        // simply re-run the check.
+        if (cb && !any(flags & (SF_CF_INVALID | SF_CF_VALID)))
+        {
+            // LCOV_EXCL_START
+            auto const fb = ctx_.tx[~sfFulfillment];
+
+            if (!fb)
+                return tecINTERNAL;
+
+            if (checkCondition(*fb, *cb))
+                flags = SF_CF_VALID;
+            else
+                flags = SF_CF_INVALID;
+
+            ctx_.registry.getHashRouter().setFlags(id, flags);
+            // LCOV_EXCL_STOP
+        }
+
+        // If the check failed, then simply return an error
+        // and don't look at anything else.
+        if (any(flags & SF_CF_INVALID))
+            return tecCRYPTOCONDITION_ERROR;
+
+        // Check against condition in the ledger entry:
+        auto const cond = (*slep)[~sfCondition];
+
+        // If a condition wasn't specified during creation,
+        // one shouldn't be included now.
+        if (!cond && cb)
+            return tecCRYPTOCONDITION_ERROR;
+
+        // If a condition was specified during creation of
+        // the suspended payment, the identical condition
+        // must be presented again. We don't check if the
+        // fulfillment matches the condition since we did
+        // that in preflight.
+        if (cond && (cond != cb))
+            return tecCRYPTOCONDITION_ERROR;
+    }
+
+    // NOTE: Escrow payments cannot be used to fund accounts.
+    AccountID const destID = (*slep)[sfDestination];
+    auto const sled = ctx_.view().peek(keylet::account(destID));
+    if (!sled)
+        return tecNO_DST;
+
+    if (auto err = verifyDepositPreauth(ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
+        !isTesSuccess(err))
+        return err;
+
+    AccountID const account = (*slep)[sfAccount];
+
+    // Remove escrow from owner directory
+    {
+        auto const page = (*slep)[sfOwnerNode];
+        if (!ctx_.view().dirRemove(keylet::ownerDir(account), page, k.key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j_.fatal()) << "Unable to delete Escrow from owner.";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Remove escrow from recipient's owner directory, if present.
+    if (auto const optPage = (*slep)[~sfDestinationNode])
+    {
+        if (!ctx_.view().dirRemove(keylet::ownerDir(destID), *optPage, k.key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    STAmount const amount = slep->getFieldAmount(sfAmount);
+    // Transfer amount to destination
+    if (isXRP(amount))
+        (*sled)[sfBalance] = (*sled)[sfBalance] + amount;
+    else
+    {
+        if (!ctx_.view().rules().enabled(featureTokenEscrow))
+            return temDISABLED;  // LCOV_EXCL_LINE
+
+        Rate lockedRate = slep->isFieldPresent(sfTransferRate)
+            ? xrpl::Rate(slep->getFieldU32(sfTransferRate))
+            : parityRate;
+        auto const issuer = amount.getIssuer();
+        bool const createAsset = destID == account_;
+        if (auto const ret = std::visit(
+                [&]<typename T>(T const&) {
+                    return escrowUnlockApplyHelper<T>(
+                        ctx_.view(),
+                        lockedRate,
+                        sled,
+                        preFeeBalance_,
+                        amount,
+                        issuer,
+                        account,
+                        destID,
+                        createAsset,
+                        j_);
+                },
+                amount.asset().value());
+            !isTesSuccess(ret))
+            return ret;
+
+        // Remove escrow from issuers owner directory, if present.
+        if (auto const optPage = (*slep)[~sfIssuerNode]; optPage)
+        {
+            if (!ctx_.view().dirRemove(keylet::ownerDir(issuer), *optPage, k.key, true))
+            {
+                // LCOV_EXCL_START
+                JLOG(j_.fatal()) << "Unable to delete Escrow from recipient.";
+                return tefBAD_LEDGER;
+                // LCOV_EXCL_STOP
+            }
+        }
+    }
+
+    ctx_.view().update(sled);
+
+    // Adjust source owner count
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
+    ctx_.view().update(sle);
+
+    // Remove escrow from ledger
+    ctx_.view().erase(slep);
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowHelpers.h b/src/libxrpl/tx/transactors/escrow/EscrowHelpers.h
new file mode 100644
index 0000000000..3519471272
--- /dev/null
+++ b/src/libxrpl/tx/transactors/escrow/EscrowHelpers.h
@@ -0,0 +1,228 @@
+#pragma once
+
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTAmount.h>
+#include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
+
+namespace xrpl {
+
+template <ValidIssueType T>
+TER
+escrowUnlockApplyHelper(
+    ApplyView& view,
+    Rate lockedRate,
+    std::shared_ptr<SLE> const& sleDest,
+    STAmount const& xrpBalance,
+    STAmount const& amount,
+    AccountID const& issuer,
+    AccountID const& sender,
+    AccountID const& receiver,
+    bool createAsset,
+    beast::Journal journal);
+
+template <>
+inline TER
+escrowUnlockApplyHelper<Issue>(
+    ApplyView& view,
+    Rate lockedRate,
+    std::shared_ptr<SLE> const& sleDest,
+    STAmount const& xrpBalance,
+    STAmount const& amount,
+    AccountID const& issuer,
+    AccountID const& sender,
+    AccountID const& receiver,
+    bool createAsset,
+    beast::Journal journal)
+{
+    Keylet const trustLineKey = keylet::line(receiver, amount.issue());
+    bool const recvLow = issuer > receiver;
+    bool const senderIssuer = issuer == sender;
+    bool const receiverIssuer = issuer == receiver;
+
+    if (senderIssuer)
+        return tecINTERNAL;  // LCOV_EXCL_LINE
+
+    if (receiverIssuer)
+        return tesSUCCESS;
+
+    if (!view.exists(trustLineKey) && createAsset)
+    {
+        // Can the account cover the trust line's reserve?
+        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
+            xrpBalance < view.fees().accountReserve(ownerCount + 1))
+        {
+            JLOG(journal.trace()) << "Trust line does not exist. "
+                                     "Insufficient reserve to create line.";
+
+            return tecNO_LINE_INSUF_RESERVE;
+        }
+
+        Currency const currency = amount.getCurrency();
+        STAmount initialBalance(amount.issue());
+        initialBalance.setIssuer(noAccount());
+
+        // clang-format off
+        if (TER const ter = trustCreate(
+                view,                           // payment sandbox
+                recvLow,                        // is dest low?
+                issuer,                         // source
+                receiver,                       // destination
+                trustLineKey.key,               // ledger index
+                sleDest,                        // Account to add to
+                false,                          // authorize account
+                (sleDest->getFlags() & lsfDefaultRipple) == 0,
+                false,                          // freeze trust line
+                false,                          // deep freeze trust line
+                initialBalance,                 // zero initial balance
+                Issue(currency, receiver),      // limit of zero
+                0,                              // quality in
+                0,                              // quality out
+                journal);                       // journal
+            !isTesSuccess(ter))
+        {
+            return ter; // LCOV_EXCL_LINE
+        }
+        // clang-format on
+
+        view.update(sleDest);
+    }
+
+    if (!view.exists(trustLineKey) && !receiverIssuer)
+        return tecNO_LINE;
+
+    auto const xferRate = transferRate(view, amount);
+    // update if issuer rate is less than locked rate
+    if (xferRate < lockedRate)
+        lockedRate = xferRate;
+
+    // Transfer Rate only applies when:
+    // 1. Issuer is not involved in the transfer (senderIssuer or
+    // receiverIssuer)
+    // 2. The locked rate is different from the parity rate
+
+    // NOTE: Transfer fee in escrow works a bit differently from a normal
+    // payment. In escrow, the fee is deducted from the locked/sending amount,
+    // whereas in a normal payment, the transfer fee is taken on top of the
+    // sending amount.
+    auto finalAmt = amount;
+    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
+    {
+        // compute transfer fee, if any
+        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.issue(), true);
+        // compute balance to transfer
+        finalAmt = amount.value() - xferFee;
+    }
+
+    // validate the line limit if the account submitting txn is not the receiver
+    // of the funds
+    if (!createAsset)
+    {
+        auto const sleRippleState = view.peek(trustLineKey);
+        if (!sleRippleState)
+            return tecINTERNAL;  // LCOV_EXCL_LINE
+
+        // if the issuer is the high, then we use the low limit
+        // otherwise we use the high limit
+        STAmount const lineLimit =
+            sleRippleState->getFieldAmount(recvLow ? sfLowLimit : sfHighLimit);
+
+        STAmount lineBalance = sleRippleState->getFieldAmount(sfBalance);
+
+        // flip the sign of the line balance if the issuer is not high
+        if (!recvLow)
+            lineBalance.negate();
+
+        // add the final amount to the line balance
+        lineBalance += finalAmt;
+
+        // if the transfer would exceed the line limit return tecLIMIT_EXCEEDED
+        if (lineLimit < lineBalance)
+            return tecLIMIT_EXCEEDED;
+    }
+
+    // if destination is not the issuer then transfer funds
+    if (!receiverIssuer)
+    {
+        auto const ter = rippleCredit(view, issuer, receiver, finalAmt, true, journal);
+        if (ter != tesSUCCESS)
+            return ter;  // LCOV_EXCL_LINE
+    }
+    return tesSUCCESS;
+}
+
+template <>
+inline TER
+escrowUnlockApplyHelper<MPTIssue>(
+    ApplyView& view,
+    Rate lockedRate,
+    std::shared_ptr<SLE> const& sleDest,
+    STAmount const& xrpBalance,
+    STAmount const& amount,
+    AccountID const& issuer,
+    AccountID const& sender,
+    AccountID const& receiver,
+    bool createAsset,
+    beast::Journal journal)
+{
+    bool const senderIssuer = issuer == sender;
+    bool const receiverIssuer = issuer == receiver;
+
+    auto const mptID = amount.get<MPTIssue>().getMptID();
+    auto const issuanceKey = keylet::mptIssuance(mptID);
+    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && createAsset && !receiverIssuer)
+    {
+        if (std::uint32_t const ownerCount = {sleDest->at(sfOwnerCount)};
+            xrpBalance < view.fees().accountReserve(ownerCount + 1))
+        {
+            return tecINSUFFICIENT_RESERVE;
+        }
+
+        if (auto const ter = MPTokenAuthorize::createMPToken(view, mptID, receiver, 0);
+            !isTesSuccess(ter))
+        {
+            return ter;  // LCOV_EXCL_LINE
+        }
+
+        // update owner count.
+        adjustOwnerCount(view, sleDest, 1, journal);
+    }
+
+    if (!view.exists(keylet::mptoken(issuanceKey.key, receiver)) && !receiverIssuer)
+        return tecNO_PERMISSION;
+
+    auto const xferRate = transferRate(view, amount);
+    // update if issuer rate is less than locked rate
+    if (xferRate < lockedRate)
+        lockedRate = xferRate;
+
+    // Transfer Rate only applies when:
+    // 1. Issuer is not involved in the transfer (senderIssuer or
+    // receiverIssuer)
+    // 2. The locked rate is different from the parity rate
+
+    // NOTE: Transfer fee in escrow works a bit differently from a normal
+    // payment. In escrow, the fee is deducted from the locked/sending amount,
+    // whereas in a normal payment, the transfer fee is taken on top of the
+    // sending amount.
+    auto finalAmt = amount;
+    if ((!senderIssuer && !receiverIssuer) && lockedRate != parityRate)
+    {
+        // compute transfer fee, if any
+        auto const xferFee = amount.value() - divideRound(amount, lockedRate, amount.asset(), true);
+        // compute balance to transfer
+        finalAmt = amount.value() - xferFee;
+    }
+    return rippleUnlockEscrowMPT(
+        view,
+        sender,
+        receiver,
+        finalAmt,
+        view.rules().enabled(fixTokenEscrowV1) ? amount : finalAmt,
+        journal);
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/Lending/LendingHelpers.cpp b/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Lending/LendingHelpers.cpp
rename to src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
index b0626b4650..d7162bbb0e 100644
--- a/src/libxrpl/tx/transactors/Lending/LendingHelpers.cpp
+++ b/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
@@ -1,6 +1,6 @@
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 // DO NOT REMOVE forces header file include to sort first
-#include <xrpl/tx/transactors/Vault/VaultCreate.h>
+#include <xrpl/tx/transactors/vault/VaultCreate.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverClawback.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Lending/LoanBrokerCoverClawback.cpp
rename to src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
index 870af54f94..8513ae5999 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverClawback.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
@@ -1,7 +1,7 @@
-#include <xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.cpp
rename to src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp
index d112959fea..83f7d2d1c6 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverDeposit.cpp
@@ -1,7 +1,7 @@
-#include <xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.cpp
rename to src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
index 43ff3659ef..57d9cbc173 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
@@ -1,9 +1,9 @@
-#include <xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h>
 //
 #include <xrpl/ledger/CredentialHelpers.h>
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
-#include <xrpl/tx/transactors/Payment.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/payment/Payment.h>
 
 namespace xrpl {
 
@@ -167,7 +167,7 @@ LoanBrokerCoverWithdraw::doApply()
 
     associateAsset(*broker, vaultAsset);
 
-    return doWithdraw(view(), tx, account_, dstAcct, brokerPseudoID, mPriorBalance, amount, j_);
+    return doWithdraw(view(), tx, account_, dstAcct, brokerPseudoID, preFeeBalance_, amount, j_);
 }
 
 //------------------------------------------------------------------------------
diff --git a/src/libxrpl/tx/transactors/Lending/LoanBrokerDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/Lending/LoanBrokerDelete.cpp
rename to src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
index 989c26d024..85026654da 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanBrokerDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
@@ -1,7 +1,7 @@
-#include <xrpl/tx/transactors/Lending/LoanBrokerDelete.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerDelete.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanBrokerSet.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/Lending/LoanBrokerSet.cpp
rename to src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp
index 1ede32dc23..2632b55812 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanBrokerSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerSet.cpp
@@ -1,7 +1,7 @@
-#include <xrpl/tx/transactors/Lending/LoanBrokerSet.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerSet.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
@@ -220,7 +220,7 @@ LoanBrokerSet::doApply()
         // one for the pseudo-account.
         adjustOwnerCount(view, owner, 2, j_);
         auto const ownerCount = owner->at(sfOwnerCount);
-        if (mPriorBalance < view.fees().accountReserve(ownerCount))
+        if (preFeeBalance_ < view.fees().accountReserve(ownerCount))
             return tecINSUFFICIENT_RESERVE;
 
         auto maybePseudo = createPseudoAccount(view, broker->key(), sfLoanBrokerID);
@@ -229,7 +229,7 @@ LoanBrokerSet::doApply()
         auto& pseudo = *maybePseudo;
         auto pseudoId = pseudo->at(sfAccount);
 
-        if (auto ter = addEmptyHolding(view, pseudoId, mPriorBalance, sleVault->at(sfAsset), j_))
+        if (auto ter = addEmptyHolding(view, pseudoId, preFeeBalance_, sleVault->at(sfAsset), j_))
             return ter;
 
         // Initialize data fields:
diff --git a/src/libxrpl/tx/transactors/Lending/LoanDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/Lending/LoanDelete.cpp
rename to src/libxrpl/tx/transactors/lending/LoanDelete.cpp
index fa3ccba7da..e7d219d6c8 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
@@ -1,7 +1,7 @@
-#include <xrpl/tx/transactors/Lending/LoanDelete.h>
+#include <xrpl/tx/transactors/lending/LoanDelete.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Lending/LoanManage.cpp
rename to src/libxrpl/tx/transactors/lending/LoanManage.cpp
index c066c4b3a9..2dacb453b5 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanManage.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
@@ -1,8 +1,8 @@
-#include <xrpl/tx/transactors/Lending/LoanManage.h>
+#include <xrpl/tx/transactors/lending/LoanManage.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Lending/LoanPay.cpp
rename to src/libxrpl/tx/transactors/lending/LoanPay.cpp
index 6b1f2acf7c..d894c56631 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -1,11 +1,11 @@
-#include <xrpl/tx/transactors/Lending/LoanPay.h>
+#include <xrpl/tx/transactors/lending/LoanPay.h>
 //
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
-#include <xrpl/tx/transactors/Lending/LoanManage.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LoanManage.h>
 
 #include <bit>
 
diff --git a/src/libxrpl/tx/transactors/Lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Lending/LoanSet.cpp
rename to src/libxrpl/tx/transactors/lending/LoanSet.cpp
index 3e1fd296f2..7ba042ea1b 100644
--- a/src/libxrpl/tx/transactors/Lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -1,8 +1,8 @@
-#include <xrpl/tx/transactors/Lending/LoanSet.h>
+#include <xrpl/tx/transactors/lending/LoanSet.h>
 //
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
 
 namespace xrpl {
 
@@ -84,11 +84,12 @@ LoanSet::preflight(PreflightContext const& ctx)
         !validNumericMinimum(paymentInterval, LoanSet::minPaymentInterval))
         return temINVALID;
     // Grace period is between min default value and payment interval
-    else if (auto const gracePeriod = tx[~sfGracePeriod];  //
-             !validNumericRange(
-                 gracePeriod,
-                 paymentInterval.value_or(LoanSet::defaultPaymentInterval),
-                 defaultGracePeriod))
+    else if (
+        auto const gracePeriod = tx[~sfGracePeriod];  //
+        !validNumericRange(
+            gracePeriod,
+            paymentInterval.value_or(LoanSet::defaultPaymentInterval),
+            defaultGracePeriod))
         return temINVALID;
 
     // Copied from preflight2
@@ -473,7 +474,7 @@ LoanSet::doApply()
     {
         auto const ownerCount = borrowerSle->at(sfOwnerCount);
         auto const balance =
-            account_ == borrower ? mPriorBalance : borrowerSle->at(sfBalance).value().xrp();
+            account_ == borrower ? preFeeBalance_ : borrowerSle->at(sfBalance).value().xrp();
         if (balance < view.fees().accountReserve(ownerCount))
             return tecINSUFFICIENT_RESERVE;
     }
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenAcceptOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/NFT/NFTokenAcceptOffer.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
index 45668d4273..4cdb7751c6 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenAcceptOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
@@ -2,17 +2,11 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Rate.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenAcceptOffer.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
-std::uint32_t
-NFTokenAcceptOffer::getFlagsMask(PreflightContext const& ctx)
-{
-    return tfNFTokenAcceptOfferMask;
-}
-
 NotTEC
 NFTokenAcceptOffer::preflight(PreflightContext const& ctx)
 {
@@ -367,7 +361,7 @@ NFTokenAcceptOffer::transferNFToken(
     // NFTs free of reserve.
     if (view().rules().enabled(fixNFTokenReserve))
     {
-        // To check if there is sufficient reserve, we cannot use mPriorBalance
+        // To check if there is sufficient reserve, we cannot use preFeeBalance_
         // because NFT is sold for a price. So we must use the balance after
         // the deduction of the potential offer price. A small caveat here is
         // that the balance has already deducted the transaction fee, meaning
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenBurn.cpp b/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/NFT/NFTokenBurn.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp
index 65ef9e7542..6d9ee56c51 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenBurn.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenBurn.cpp
@@ -1,8 +1,8 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenBurn.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenBurn.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenCancelOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp
similarity index 91%
rename from src/libxrpl/tx/transactors/NFT/NFTokenCancelOffer.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp
index 9a3e36b7c8..df0561e076 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenCancelOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenCancelOffer.cpp
@@ -1,19 +1,13 @@
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenCancelOffer.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenCancelOffer.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <boost/endian/conversion.hpp>
 
 namespace xrpl {
 
-std::uint32_t
-NFTokenCancelOffer::getFlagsMask(PreflightContext const& ctx)
-{
-    return tfNFTokenCancelOfferMask;
-}
-
 NotTEC
 NFTokenCancelOffer::preflight(PreflightContext const& ctx)
 {
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenCreateOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp
similarity index 93%
rename from src/libxrpl/tx/transactors/NFT/NFTokenCreateOffer.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp
index 6fe911ef5b..847d15a3b7 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenCreateOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenCreateOffer.cpp
@@ -1,8 +1,8 @@
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenCreateOffer.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenCreateOffer.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
@@ -74,7 +74,7 @@ NFTokenCreateOffer::doApply()
         ctx_.tx[~sfExpiration],
         ctx_.tx.getSeqProxy(),
         ctx_.tx[sfNFTokenID],
-        mPriorBalance,
+        preFeeBalance_,
         j_,
         ctx_.tx.getFlags());
 }
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenMint.cpp b/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/NFT/NFTokenMint.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
index d8c063571b..35e2705034 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenMint.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/InnerObjectFormats.h>
 #include <xrpl/protocol/Rate.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenMint.h>
+#include <xrpl/tx/transactors/nft/NFTokenMint.h>
 
 #include <boost/endian/conversion.hpp>
 
@@ -48,9 +48,8 @@ NFTokenMint::getFlagsMask(PreflightContext const& ctx)
     // tfTrustLine flag as a way to prevent the attack.  But until the
     // amendment passes we still need to keep the old behavior available.
     std::uint32_t const nfTokenMintMask = ctx.rules.enabled(fixRemoveNFTokenAutoTrustLine)
-        // if featureDynamicNFT enabled then new flag allowing mutable URI
-        // available
-        ? ctx.rules.enabled(featureDynamicNFT) ? tfNFTokenMintMaskWithMutable : tfNFTokenMintMask
+        // if featureDynamicNFT enabled then new flag allowing mutable URI available
+        ? ctx.rules.enabled(featureDynamicNFT) ? tfNFTokenMintMask : tfNFTokenMintMaskWithoutMutable
         : ctx.rules.enabled(featureDynamicNFT) ? tfNFTokenMintOldMaskWithMutable
                                                : tfNFTokenMintOldMask;
 
@@ -294,7 +293,7 @@ NFTokenMint::doApply()
                 ctx_.tx[~sfExpiration],
                 ctx_.tx.getSeqProxy(),
                 nftokenID,
-                mPriorBalance,
+                preFeeBalance_,
                 j_);
             !isTesSuccess(ter))
             return ter;
@@ -309,7 +308,7 @@ NFTokenMint::doApply()
         ownerCountAfter > ownerCountBefore)
     {
         if (auto const reserve = view().fees().accountReserve(ownerCountAfter);
-            mPriorBalance < reserve)
+            preFeeBalance_ < reserve)
             return tecINSUFFICIENT_RESERVE;
     }
     return tesSUCCESS;
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenModify.cpp b/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp
similarity index 93%
rename from src/libxrpl/tx/transactors/NFT/NFTokenModify.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenModify.cpp
index 316bcb0f27..af852530e4 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenModify.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenModify.cpp
@@ -1,7 +1,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/NFT/NFTokenModify.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenModify.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/NFT/NFTokenUtils.cpp b/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/NFT/NFTokenUtils.cpp
rename to src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
index 383929d54e..f66a3698d0 100644
--- a/src/libxrpl/tx/transactors/NFT/NFTokenUtils.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/protocol/STArray.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/nftPageMask.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <functional>
 #include <memory>
@@ -343,7 +343,7 @@ removeToken(
     ApplyView& view,
     AccountID const& owner,
     uint256 const& nftokenID,
-    std::shared_ptr<SLE>&& curr)
+    std::shared_ptr<SLE> const& curr)
 {
     // We found a page, but the given NFT may not be in it.
     auto arr = curr->getFieldArray(sfNFTokens);
diff --git a/src/libxrpl/tx/transactors/DeleteOracle.cpp b/src/libxrpl/tx/transactors/oracle/DeleteOracle.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/DeleteOracle.cpp
rename to src/libxrpl/tx/transactors/oracle/DeleteOracle.cpp
index ebaffd334a..5452096b6d 100644
--- a/src/libxrpl/tx/transactors/DeleteOracle.cpp
+++ b/src/libxrpl/tx/transactors/oracle/DeleteOracle.cpp
@@ -2,7 +2,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/DeleteOracle.h>
+#include <xrpl/tx/transactors/oracle/DeleteOracle.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/SetOracle.cpp b/src/libxrpl/tx/transactors/oracle/SetOracle.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/SetOracle.cpp
rename to src/libxrpl/tx/transactors/oracle/SetOracle.cpp
index 140938e2d7..be827c25d5 100644
--- a/src/libxrpl/tx/transactors/SetOracle.cpp
+++ b/src/libxrpl/tx/transactors/oracle/SetOracle.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/InnerObjectFormats.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/digest.h>
-#include <xrpl/tx/transactors/SetOracle.h>
+#include <xrpl/tx/transactors/oracle/SetOracle.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/DepositPreauth.cpp b/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/DepositPreauth.cpp
rename to src/libxrpl/tx/transactors/payment/DepositPreauth.cpp
index 6857816d1f..ceb90411a4 100644
--- a/src/libxrpl/tx/transactors/DepositPreauth.cpp
+++ b/src/libxrpl/tx/transactors/payment/DepositPreauth.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/DepositPreauth.h>
+#include <xrpl/tx/transactors/payment/DepositPreauth.h>
 
 #include <optional>
 
@@ -147,7 +147,7 @@ DepositPreauth::doApply()
             STAmount const reserve{
                 view().fees().accountReserve(sleOwner->getFieldU32(sfOwnerCount) + 1)};
 
-            if (mPriorBalance < reserve)
+            if (preFeeBalance_ < reserve)
                 return tecINSUFFICIENT_RESERVE;
         }
 
@@ -194,7 +194,7 @@ DepositPreauth::doApply()
             STAmount const reserve{
                 view().fees().accountReserve(sleOwner->getFieldU32(sfOwnerCount) + 1)};
 
-            if (mPriorBalance < reserve)
+            if (preFeeBalance_ < reserve)
                 return tecINSUFFICIENT_RESERVE;
         }
 
diff --git a/src/libxrpl/tx/transactors/Payment.cpp b/src/libxrpl/tx/transactors/payment/Payment.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Payment.cpp
rename to src/libxrpl/tx/transactors/payment/Payment.cpp
index b98bbf11bd..6844d90aed 100644
--- a/src/libxrpl/tx/transactors/Payment.cpp
+++ b/src/libxrpl/tx/transactors/payment/Payment.cpp
@@ -6,9 +6,9 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/tx/paths/RippleCalc.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/Payment.h>
-#include <xrpl/tx/transactors/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/dex/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/payment/Payment.h>
 
 namespace xrpl {
 
@@ -544,16 +544,16 @@ Payment::doApply()
     // This is the total reserve in drops.
     auto const reserve = view().fees().accountReserve(ownerCount);
 
-    // mPriorBalance is the balance on the sending account BEFORE the
+    // preFeeBalance_ is the balance on the sending account BEFORE the
     // fees were charged. We want to make sure we have enough reserve
     // to send. Allow final spend to use reserve for fee.
     auto const mmm = std::max(reserve, ctx_.tx.getFieldAmount(sfFee).xrp());
 
-    if (mPriorBalance < dstAmount.xrp() + mmm)
+    if (preFeeBalance_ < dstAmount.xrp() + mmm)
     {
         // Vote no. However the transaction might succeed, if applied in
         // a different order.
-        JLOG(j_.trace()) << "Delay transaction: Insufficient funds: " << to_string(mPriorBalance)
+        JLOG(j_.trace()) << "Delay transaction: Insufficient funds: " << to_string(preFeeBalance_)
                          << " / " << to_string(dstAmount.xrp() + mmm) << " (" << to_string(reserve)
                          << ")";
 
@@ -601,7 +601,7 @@ Payment::doApply()
     }
 
     // Do the arithmetic for the transfer and make the ledger change.
-    sleSrc->setFieldAmount(sfBalance, mSourceBalance - dstAmount);
+    sleSrc->setFieldAmount(sfBalance, sleSrc->getFieldAmount(sfBalance) - dstAmount);
     sleDst->setFieldAmount(sfBalance, sleDst->getFieldAmount(sfBalance) + dstAmount);
 
     // Re-arm the password change fee if we can and need to.
diff --git a/src/libxrpl/tx/transactors/payment_channel/PayChanClaim.cpp b/src/libxrpl/tx/transactors/payment_channel/PayChanClaim.cpp
new file mode 100644
index 0000000000..d41e6f043c
--- /dev/null
+++ b/src/libxrpl/tx/transactors/payment_channel/PayChanClaim.cpp
@@ -0,0 +1,186 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/PayChan.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/tx/transactors/payment_channel/PayChanClaim.h>
+
+#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
+
+namespace xrpl {
+
+bool
+PayChanClaim::checkExtraFeatures(PreflightContext const& ctx)
+{
+    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
+}
+
+std::uint32_t
+PayChanClaim::getFlagsMask(PreflightContext const&)
+{
+    return tfPaymentChannelClaimMask;
+}
+
+NotTEC
+PayChanClaim::preflight(PreflightContext const& ctx)
+{
+    auto const bal = ctx.tx[~sfBalance];
+    if (bal && (!isXRP(*bal) || *bal <= beast::zero))
+        return temBAD_AMOUNT;
+
+    auto const amt = ctx.tx[~sfAmount];
+    if (amt && (!isXRP(*amt) || *amt <= beast::zero))
+        return temBAD_AMOUNT;
+
+    if (bal && amt && *bal > *amt)
+        return temBAD_AMOUNT;
+
+    {
+        auto const flags = ctx.tx.getFlags();
+
+        if ((flags & tfClose) && (flags & tfRenew))
+            return temMALFORMED;
+    }
+
+    if (auto const sig = ctx.tx[~sfSignature])
+    {
+        if (!(ctx.tx[~sfPublicKey] && bal))
+            return temMALFORMED;
+
+        // Check the signature
+        // The signature isn't needed if txAccount == src, but if it's
+        // present, check it
+
+        auto const reqBalance = bal->xrp();
+        auto const authAmt = amt ? amt->xrp() : reqBalance;
+
+        if (reqBalance > authAmt)
+            return temBAD_AMOUNT;
+
+        Keylet const k(ltPAYCHAN, ctx.tx[sfChannel]);
+        if (!publicKeyType(ctx.tx[sfPublicKey]))
+            return temMALFORMED;
+
+        PublicKey const pk(ctx.tx[sfPublicKey]);
+        Serializer msg;
+        serializePayChanAuthorization(msg, k.key, authAmt);
+        if (!verify(pk, msg.slice(), *sig))
+            return temBAD_SIGNATURE;
+    }
+
+    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
+        return err;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanClaim::preclaim(PreclaimContext const& ctx)
+{
+    if (!ctx.view.rules().enabled(featureCredentials))
+        return Transactor::preclaim(ctx);
+
+    if (auto const err = credentials::valid(ctx.tx, ctx.view, ctx.tx[sfAccount], ctx.j);
+        !isTesSuccess(err))
+        return err;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanClaim::doApply()
+{
+    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+        return tecNO_TARGET;
+
+    AccountID const src = (*slep)[sfAccount];
+    AccountID const dst = (*slep)[sfDestination];
+    AccountID const txAccount = ctx_.tx[sfAccount];
+
+    auto const curExpiration = (*slep)[~sfExpiration];
+    {
+        auto const cancelAfter = (*slep)[~sfCancelAfter];
+        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
+        if ((cancelAfter && closeTime >= *cancelAfter) ||
+            (curExpiration && closeTime >= *curExpiration))
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+    }
+
+    if (txAccount != src && txAccount != dst)
+        return tecNO_PERMISSION;
+
+    if (ctx_.tx[~sfBalance])
+    {
+        auto const chanBalance = slep->getFieldAmount(sfBalance).xrp();
+        auto const chanFunds = slep->getFieldAmount(sfAmount).xrp();
+        auto const reqBalance = ctx_.tx[sfBalance].xrp();
+
+        if (txAccount == dst && !ctx_.tx[~sfSignature])
+            return temBAD_SIGNATURE;
+
+        if (ctx_.tx[~sfSignature])
+        {
+            PublicKey const pk((*slep)[sfPublicKey]);
+            if (ctx_.tx[sfPublicKey] != pk)
+                return temBAD_SIGNER;
+        }
+
+        if (reqBalance > chanFunds)
+            return tecUNFUNDED_PAYMENT;
+
+        if (reqBalance <= chanBalance)
+            // nothing requested
+            return tecUNFUNDED_PAYMENT;
+
+        auto const sled = ctx_.view().peek(keylet::account(dst));
+        if (!sled)
+            return tecNO_DST;
+
+        if (auto err =
+                verifyDepositPreauth(ctx_.tx, ctx_.view(), txAccount, dst, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+
+        (*slep)[sfBalance] = ctx_.tx[sfBalance];
+        XRPAmount const reqDelta = reqBalance - chanBalance;
+        XRPL_ASSERT(reqDelta >= beast::zero, "xrpl::PayChanClaim::doApply : minimum balance delta");
+        (*sled)[sfBalance] = (*sled)[sfBalance] + reqDelta;
+        ctx_.view().update(sled);
+        ctx_.view().update(slep);
+    }
+
+    if (ctx_.tx.getFlags() & tfRenew)
+    {
+        if (src != txAccount)
+            return tecNO_PERMISSION;
+        (*slep)[~sfExpiration] = std::nullopt;
+        ctx_.view().update(slep);
+    }
+
+    if (ctx_.tx.getFlags() & tfClose)
+    {
+        // Channel will close immediately if dry or the receiver closes
+        if (dst == txAccount || (*slep)[sfBalance] == (*slep)[sfAmount])
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+
+        auto const settleExpiration =
+            ctx_.view().header().parentCloseTime.time_since_epoch().count() +
+            (*slep)[sfSettleDelay];
+
+        if (!curExpiration || *curExpiration > settleExpiration)
+        {
+            (*slep)[~sfExpiration] = settleExpiration;
+            ctx_.view().update(slep);
+        }
+    }
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/payment_channel/PayChanCreate.cpp b/src/libxrpl/tx/transactors/payment_channel/PayChanCreate.cpp
new file mode 100644
index 0000000000..ccb0fa1a63
--- /dev/null
+++ b/src/libxrpl/tx/transactors/payment_channel/PayChanCreate.cpp
@@ -0,0 +1,173 @@
+#include <xrpl/basics/chrono.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/transactors/payment_channel/PayChanCreate.h>
+
+namespace xrpl {
+
+/*
+    PaymentChannel
+
+        Payment channels permit off-ledger checkpoints of XRP payments flowing
+        in a single direction. A channel sequesters the owner's XRP in its own
+        ledger entry. The owner can authorize the recipient to claim up to a
+        given balance by giving the receiver a signed message (off-ledger). The
+        recipient can use this signed message to claim any unpaid balance while
+        the channel remains open. The owner can top off the line as needed. If
+        the channel has not paid out all its funds, the owner must wait out a
+        delay to close the channel to give the recipient a chance to supply any
+        claims. The recipient can close the channel at any time. Any transaction
+        that touches the channel after the expiration time will close the
+        channel. The total amount paid increases monotonically as newer claims
+        are issued. When the channel is closed any remaining balance is returned
+        to the owner. Channels are intended to permit intermittent off-ledger
+        settlement of ILP trust lines as balances get substantial. For
+        bidirectional channels, a payment channel can be used in each direction.
+*/
+
+//------------------------------------------------------------------------------
+
+TxConsequences
+PayChanCreate::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
+}
+
+NotTEC
+PayChanCreate::preflight(PreflightContext const& ctx)
+{
+    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
+        return temBAD_AMOUNT;
+
+    if (ctx.tx[sfAccount] == ctx.tx[sfDestination])
+        return temDST_IS_SRC;
+
+    if (!publicKeyType(ctx.tx[sfPublicKey]))
+        return temMALFORMED;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanCreate::preclaim(PreclaimContext const& ctx)
+{
+    auto const account = ctx.tx[sfAccount];
+    auto const sle = ctx.view.read(keylet::account(account));
+    if (!sle)
+        return terNO_ACCOUNT;
+
+    // Check reserve and funds availability
+    {
+        auto const balance = (*sle)[sfBalance];
+        auto const reserve = ctx.view.fees().accountReserve((*sle)[sfOwnerCount] + 1);
+
+        if (balance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+
+        if (balance < reserve + ctx.tx[sfAmount])
+            return tecUNFUNDED;
+    }
+
+    auto const dst = ctx.tx[sfDestination];
+
+    {
+        // Check destination account
+        auto const sled = ctx.view.read(keylet::account(dst));
+        if (!sled)
+            return tecNO_DST;
+
+        auto const flags = sled->getFlags();
+
+        // Check if they have disallowed incoming payment channels
+        if (flags & lsfDisallowIncomingPayChan)
+            return tecNO_PERMISSION;
+
+        if ((flags & lsfRequireDestTag) && !ctx.tx[~sfDestinationTag])
+            return tecDST_TAG_NEEDED;
+
+        // Pseudo-accounts cannot receive payment channels, other than native
+        // to their underlying ledger object - implemented in their respective
+        // transaction types. Note, this is not amendment-gated because all
+        // writes to pseudo-account discriminator fields **are** amendment
+        // gated, hence the behaviour of this check will always match the
+        // currently active amendments.
+        if (isPseudoAccount(sled))
+            return tecNO_PERMISSION;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanCreate::doApply()
+{
+    auto const account = ctx_.tx[sfAccount];
+    auto const sle = ctx_.view().peek(keylet::account(account));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    if (ctx_.view().rules().enabled(fixPayChanCancelAfter))
+    {
+        auto const closeTime = ctx_.view().header().parentCloseTime;
+        if (ctx_.tx[~sfCancelAfter] && after(closeTime, ctx_.tx[sfCancelAfter]))
+            return tecEXPIRED;
+    }
+
+    auto const dst = ctx_.tx[sfDestination];
+
+    // Create PayChan in ledger.
+    //
+    // Note that we we use the value from the sequence or ticket as the
+    // payChan sequence.  For more explanation see comments in SeqProxy.h.
+    Keylet const payChanKeylet = keylet::payChan(account, dst, ctx_.tx.getSeqValue());
+    auto const slep = std::make_shared<SLE>(payChanKeylet);
+
+    // Funds held in this channel
+    (*slep)[sfAmount] = ctx_.tx[sfAmount];
+    // Amount channel has already paid
+    (*slep)[sfBalance] = ctx_.tx[sfAmount].zeroed();
+    (*slep)[sfAccount] = account;
+    (*slep)[sfDestination] = dst;
+    (*slep)[sfSettleDelay] = ctx_.tx[sfSettleDelay];
+    (*slep)[sfPublicKey] = ctx_.tx[sfPublicKey];
+    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
+    (*slep)[~sfSourceTag] = ctx_.tx[~sfSourceTag];
+    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
+    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
+    {
+        (*slep)[sfSequence] = ctx_.tx.getSeqValue();
+    }
+
+    ctx_.view().insert(slep);
+
+    // Add PayChan to owner directory
+    {
+        auto const page = ctx_.view().dirInsert(
+            keylet::ownerDir(account), payChanKeylet, describeOwnerDir(account));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfOwnerNode] = *page;
+    }
+
+    // Add PayChan to the recipient's owner directory
+    {
+        auto const page =
+            ctx_.view().dirInsert(keylet::ownerDir(dst), payChanKeylet, describeOwnerDir(dst));
+        if (!page)
+            return tecDIR_FULL;  // LCOV_EXCL_LINE
+        (*slep)[sfDestinationNode] = *page;
+    }
+
+    // Deduct owner's balance, increment owner count
+    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
+    ctx_.view().update(sle);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/payment_channel/PayChanFund.cpp b/src/libxrpl/tx/transactors/payment_channel/PayChanFund.cpp
new file mode 100644
index 0000000000..eb6fe1d2a9
--- /dev/null
+++ b/src/libxrpl/tx/transactors/payment_channel/PayChanFund.cpp
@@ -0,0 +1,92 @@
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/tx/transactors/payment_channel/PayChanFund.h>
+
+#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
+
+namespace xrpl {
+
+TxConsequences
+PayChanFund::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, ctx.tx[sfAmount].xrp()};
+}
+
+NotTEC
+PayChanFund::preflight(PreflightContext const& ctx)
+{
+    if (!isXRP(ctx.tx[sfAmount]) || (ctx.tx[sfAmount] <= beast::zero))
+        return temBAD_AMOUNT;
+
+    return tesSUCCESS;
+}
+
+TER
+PayChanFund::doApply()
+{
+    Keylet const k(ltPAYCHAN, ctx_.tx[sfChannel]);
+    auto const slep = ctx_.view().peek(k);
+    if (!slep)
+        return tecNO_ENTRY;
+
+    AccountID const src = (*slep)[sfAccount];
+    auto const txAccount = ctx_.tx[sfAccount];
+    auto const expiration = (*slep)[~sfExpiration];
+
+    {
+        auto const cancelAfter = (*slep)[~sfCancelAfter];
+        auto const closeTime = ctx_.view().header().parentCloseTime.time_since_epoch().count();
+        if ((cancelAfter && closeTime >= *cancelAfter) || (expiration && closeTime >= *expiration))
+            return closeChannel(slep, ctx_.view(), k.key, ctx_.registry.journal("View"));
+    }
+
+    if (src != txAccount)
+        // only the owner can add funds or extend
+        return tecNO_PERMISSION;
+
+    if (auto extend = ctx_.tx[~sfExpiration])
+    {
+        auto minExpiration = ctx_.view().header().parentCloseTime.time_since_epoch().count() +
+            (*slep)[sfSettleDelay];
+        if (expiration && *expiration < minExpiration)
+            minExpiration = *expiration;
+
+        if (*extend < minExpiration)
+            return temBAD_EXPIRATION;
+        (*slep)[~sfExpiration] = *extend;
+        ctx_.view().update(slep);
+    }
+
+    auto const sle = ctx_.view().peek(keylet::account(txAccount));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    {
+        // Check reserve and funds availability
+        auto const balance = (*sle)[sfBalance];
+        auto const reserve = ctx_.view().fees().accountReserve((*sle)[sfOwnerCount]);
+
+        if (balance < reserve)
+            return tecINSUFFICIENT_RESERVE;
+
+        if (balance < reserve + ctx_.tx[sfAmount])
+            return tecUNFUNDED;
+    }
+
+    // do not allow adding funds if dst does not exist
+    if (AccountID const dst = (*slep)[sfDestination]; !ctx_.view().read(keylet::account(dst)))
+    {
+        return tecNO_DST;
+    }
+
+    (*slep)[sfAmount] = (*slep)[sfAmount] + ctx_.tx[sfAmount];
+    ctx_.view().update(slep);
+
+    (*sle)[sfBalance] = (*sle)[sfBalance] - ctx_.tx[sfAmount];
+    ctx_.view().update(sle);
+
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.cpp b/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.cpp
new file mode 100644
index 0000000000..b761bb3fc3
--- /dev/null
+++ b/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.cpp
@@ -0,0 +1,58 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Indexes.h>
+
+#include <libxrpl/tx/transactors/payment_channel/PayChanHelpers.h>
+
+namespace xrpl {
+
+TER
+closeChannel(
+    std::shared_ptr<SLE> const& slep,
+    ApplyView& view,
+    uint256 const& key,
+    beast::Journal j)
+{
+    AccountID const src = (*slep)[sfAccount];
+    // Remove PayChan from owner directory
+    {
+        auto const page = (*slep)[sfOwnerNode];
+        if (!view.dirRemove(keylet::ownerDir(src), page, key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j.fatal()) << "Could not remove paychan from src owner directory";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Remove PayChan from recipient's owner directory, if present.
+    if (auto const page = (*slep)[~sfDestinationNode])
+    {
+        auto const dst = (*slep)[sfDestination];
+        if (!view.dirRemove(keylet::ownerDir(dst), *page, key, true))
+        {
+            // LCOV_EXCL_START
+            JLOG(j.fatal()) << "Could not remove paychan from dst owner directory";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Transfer amount back to owner, decrement owner count
+    auto const sle = view.peek(keylet::account(src));
+    if (!sle)
+        return tefINTERNAL;  // LCOV_EXCL_LINE
+
+    XRPL_ASSERT(
+        (*slep)[sfAmount] >= (*slep)[sfBalance], "xrpl::closeChannel : minimum channel amount");
+    (*sle)[sfBalance] = (*sle)[sfBalance] + (*slep)[sfAmount] - (*slep)[sfBalance];
+    adjustOwnerCount(view, sle, -1, j);
+    view.update(sle);
+
+    // Remove PayChan from ledger
+    view.erase(slep);
+    return tesSUCCESS;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.h b/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.h
new file mode 100644
index 0000000000..5d1a4c0aa1
--- /dev/null
+++ b/src/libxrpl/tx/transactors/payment_channel/PayChanHelpers.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+TER
+closeChannel(
+    std::shared_ptr<SLE> const& slep,
+    ApplyView& view,
+    uint256 const& key,
+    beast::Journal j);
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.cpp b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp
similarity index 87%
rename from src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.cpp
rename to src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp
index e013bd8d2b..2c7e934fc0 100644
--- a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.cpp
+++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.cpp
@@ -1,6 +1,6 @@
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h>
+#include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h>
 
 namespace xrpl {
 
@@ -18,7 +18,7 @@ TER
 PermissionedDomainDelete::preclaim(PreclaimContext const& ctx)
 {
     auto const domain = ctx.tx.getFieldH256(sfDomainID);
-    auto const sleDomain = ctx.view.read({ltPERMISSIONED_DOMAIN, domain});
+    auto const sleDomain = ctx.view.read(keylet::permissionedDomain(domain));
 
     if (!sleDomain)
         return tecNO_ENTRY;
@@ -40,7 +40,7 @@ PermissionedDomainDelete::doApply()
         ctx_.tx.isFieldPresent(sfDomainID),
         "xrpl::PermissionedDomainDelete::doApply : required field present");
 
-    auto const slePd = view().peek({ltPERMISSIONED_DOMAIN, ctx_.tx.at(sfDomainID)});
+    auto const slePd = view().peek(keylet::permissionedDomain(ctx_.tx.at(sfDomainID)));
     auto const page = (*slePd)[sfOwnerNode];
 
     if (!view().dirRemove(keylet::ownerDir(account_), page, slePd->key(), true))
diff --git a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.cpp b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.cpp
rename to src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp
index 51ff4d8217..c27c884b10 100644
--- a/src/libxrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.cpp
+++ b/src/libxrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.cpp
@@ -1,10 +1,9 @@
+#include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
+//
 #include <xrpl/ledger/CredentialHelpers.h>
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
-
-#include <optional>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Batch.cpp b/src/libxrpl/tx/transactors/system/Batch.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Batch.cpp
rename to src/libxrpl/tx/transactors/system/Batch.cpp
index f9b3036e57..62544d470d 100644
--- a/src/libxrpl/tx/transactors/Batch.cpp
+++ b/src/libxrpl/tx/transactors/system/Batch.cpp
@@ -7,7 +7,7 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/apply.h>
-#include <xrpl/tx/transactors/Batch.h>
+#include <xrpl/tx/transactors/system/Batch.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Change.cpp b/src/libxrpl/tx/transactors/system/Change.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Change.cpp
rename to src/libxrpl/tx/transactors/system/Change.cpp
index 315aeb89bd..d1e2d148d6 100644
--- a/src/libxrpl/tx/transactors/Change.cpp
+++ b/src/libxrpl/tx/transactors/system/Change.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/server/NetworkOPs.h>
-#include <xrpl/tx/transactors/Change.h>
+#include <xrpl/tx/transactors/system/Change.h>
 
 #include <string_view>
 
@@ -16,11 +16,11 @@ NotTEC
 Transactor::invokePreflight<Change>(PreflightContext const& ctx)
 {
     // 0 means "Allow any flags"
-    // The check for tfChangeMask is gated by LendingProtocol because that
-    // feature introduced this parameter, and it's not worth adding another
+    // The check for tfEnableAmendmentMask is gated by LendingProtocol because
+    // that feature introduced this parameter, and it's not worth adding another
     // amendment just for this.
     if (auto const ret =
-            preflight0(ctx, ctx.rules.enabled(featureLendingProtocol) ? tfChangeMask : 0))
+            preflight0(ctx, ctx.rules.enabled(featureLendingProtocol) ? tfEnableAmendmentMask : 0))
         return ret;
 
     auto account = ctx.tx.getAccountID(sfAccount);
diff --git a/src/libxrpl/tx/transactors/CreateTicket.cpp b/src/libxrpl/tx/transactors/system/CreateTicket.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/CreateTicket.cpp
rename to src/libxrpl/tx/transactors/system/CreateTicket.cpp
index b1991c6e77..b16cdeb7a2 100644
--- a/src/libxrpl/tx/transactors/CreateTicket.cpp
+++ b/src/libxrpl/tx/transactors/system/CreateTicket.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/CreateTicket.h>
+#include <xrpl/tx/transactors/system/CreateTicket.h>
 
 namespace xrpl {
 
@@ -65,7 +65,7 @@ CreateTicket::doApply()
         XRPAmount const reserve =
             view().fees().accountReserve(sleAccountRoot->getFieldU32(sfOwnerCount) + ticketCount);
 
-        if (mPriorBalance < reserve)
+        if (preFeeBalance_ < reserve)
             return tecINSUFFICIENT_RESERVE;
     }
 
diff --git a/src/libxrpl/tx/transactors/LedgerStateFix.cpp b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
similarity index 65%
rename from src/libxrpl/tx/transactors/LedgerStateFix.cpp
rename to src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
index 28028b6f2b..0ce0720ba0 100644
--- a/src/libxrpl/tx/transactors/LedgerStateFix.cpp
+++ b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
@@ -2,8 +2,8 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/LedgerStateFix.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+#include <xrpl/tx/transactors/system/LedgerStateFix.h>
 
 namespace xrpl {
 
@@ -35,15 +35,13 @@ LedgerStateFix::calculateBaseFee(ReadView const& view, STTx const& tx)
 TER
 LedgerStateFix::preclaim(PreclaimContext const& ctx)
 {
-    switch (ctx.tx[sfLedgerFixType])
+    if (ctx.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
     {
-        case FixType::nfTokenPageLink: {
-            AccountID const owner{ctx.tx[sfOwner]};
-            if (!ctx.view.read(keylet::account(owner)))
-                return tecOBJECT_NOT_FOUND;
+        AccountID const owner{ctx.tx[sfOwner]};
+        if (!ctx.view.read(keylet::account(owner)))
+            return tecOBJECT_NOT_FOUND;
 
-            return tesSUCCESS;
-        }
+        return tesSUCCESS;
     }
 
     // preflight is supposed to verify that only valid FixTypes get to preclaim.
@@ -53,13 +51,12 @@ LedgerStateFix::preclaim(PreclaimContext const& ctx)
 TER
 LedgerStateFix::doApply()
 {
-    switch (ctx_.tx[sfLedgerFixType])
+    if (ctx_.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
     {
-        case FixType::nfTokenPageLink:
-            if (!nft::repairNFTokenDirectoryLinks(view(), ctx_.tx[sfOwner]))
-                return tecFAILED_PROCESSING;
+        if (!nft::repairNFTokenDirectoryLinks(view(), ctx_.tx[sfOwner]))
+            return tecFAILED_PROCESSING;
 
-            return tesSUCCESS;
+        return tesSUCCESS;
     }
 
     // preflight is supposed to verify that only valid FixTypes get to doApply.
diff --git a/src/libxrpl/tx/transactors/Clawback.cpp b/src/libxrpl/tx/transactors/token/Clawback.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Clawback.cpp
rename to src/libxrpl/tx/transactors/token/Clawback.cpp
index ac13cc10da..c64459faa9 100644
--- a/src/libxrpl/tx/transactors/Clawback.cpp
+++ b/src/libxrpl/tx/transactors/token/Clawback.cpp
@@ -4,7 +4,7 @@
 #include <xrpl/protocol/MPTAmount.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Clawback.h>
+#include <xrpl/tx/transactors/token/Clawback.h>
 
 namespace xrpl {
 
@@ -54,12 +54,6 @@ preflightHelper<MPTIssue>(PreflightContext const& ctx)
     return tesSUCCESS;
 }
 
-std::uint32_t
-Clawback::getFlagsMask(PreflightContext const& ctx)
-{
-    return tfClawbackMask;
-}
-
 NotTEC
 Clawback::preflight(PreflightContext const& ctx)
 {
diff --git a/src/libxrpl/tx/transactors/MPT/MPTokenAuthorize.cpp b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/MPT/MPTokenAuthorize.cpp
rename to src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
index 846b25ca38..208936a5e6 100644
--- a/src/libxrpl/tx/transactors/MPT/MPTokenAuthorize.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
@@ -2,7 +2,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
+#include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
 
 namespace xrpl {
 
@@ -161,7 +161,7 @@ MPTokenAuthorize::doApply()
     auto const& tx = ctx_.tx;
     return authorizeMPToken(
         ctx_.view(),
-        mPriorBalance,
+        preFeeBalance_,
         tx[sfMPTokenIssuanceID],
         account_,
         ctx_.journal,
diff --git a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceCreate.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/MPT/MPTokenIssuanceCreate.cpp
rename to src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp
index ae697aa670..f9b9f9c01e 100644
--- a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceCreate.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceCreate.cpp
@@ -1,7 +1,7 @@
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h>
+#include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
 
 namespace xrpl {
 
@@ -138,7 +138,7 @@ MPTokenIssuanceCreate::doApply()
         view(),
         j_,
         {
-            .priorBalance = mPriorBalance,
+            .priorBalance = preFeeBalance_,
             .account = account_,
             .sequence = tx.getSeqValue(),
             .flags = tx.getFlags(),
diff --git a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp
similarity index 88%
rename from src/libxrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.cpp
rename to src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp
index acdd004bae..1df4da47ab 100644
--- a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceDestroy.cpp
@@ -1,16 +1,10 @@
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h>
+#include <xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h>
 
 namespace xrpl {
 
-std::uint32_t
-MPTokenIssuanceDestroy::getFlagsMask(PreflightContext const& ctx)
-{
-    return tfMPTokenIssuanceDestroyMask;
-}
-
 NotTEC
 MPTokenIssuanceDestroy::preflight(PreflightContext const& ctx)
 {
diff --git a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceSet.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/MPT/MPTokenIssuanceSet.cpp
rename to src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
index bacd4585d7..e6b1ffbbc3 100644
--- a/src/libxrpl/tx/transactors/MPT/MPTokenIssuanceSet.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
@@ -1,8 +1,8 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
 
 namespace xrpl {
 
@@ -130,7 +130,7 @@ MPTokenIssuanceSet::checkPermission(ReadView const& view, STTx const& tx)
 
     // this is added in case more flags will be added for MPTokenIssuanceSet
     // in the future. Currently unreachable.
-    if (txFlags & tfMPTokenIssuanceSetPermissionMask)
+    if (txFlags & tfMPTokenIssuanceSetMask)
         return terNO_DELEGATE_PERMISSION;  // LCOV_EXCL_LINE
 
     std::unordered_set<GranularPermissionType> granularPermissions;
diff --git a/src/libxrpl/tx/transactors/SetTrust.cpp b/src/libxrpl/tx/transactors/token/SetTrust.cpp
similarity index 97%
rename from src/libxrpl/tx/transactors/SetTrust.cpp
rename to src/libxrpl/tx/transactors/token/SetTrust.cpp
index 268d626432..d2984825b6 100644
--- a/src/libxrpl/tx/transactors/SetTrust.cpp
+++ b/src/libxrpl/tx/transactors/token/SetTrust.cpp
@@ -6,8 +6,8 @@
 #include <xrpl/protocol/Quality.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TER.h>
-#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/SetTrust.h>
+#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/token/SetTrust.h>
 
 namespace {
 
@@ -376,10 +376,10 @@ SetTrust::doApply()
         STAmount saLowLimit;
         STAmount saHighBalance;
         STAmount saHighLimit;
-        std::uint32_t uLowQualityIn;
-        std::uint32_t uLowQualityOut;
-        std::uint32_t uHighQualityIn;
-        std::uint32_t uHighQualityOut;
+        std::uint32_t uLowQualityIn = 0;
+        std::uint32_t uLowQualityOut = 0;
+        std::uint32_t uHighQualityIn = 0;
+        std::uint32_t uHighQualityOut = 0;
         auto const& uLowAccountID = !bHigh ? account_ : uDstAccountID;
         auto const& uHighAccountID = bHigh ? account_ : uDstAccountID;
         SLE::ref sleLowAccount = !bHigh ? sle : sleDst;
@@ -570,7 +570,7 @@ SetTrust::doApply()
             terResult = trustDelete(view(), sleRippleState, uLowAccountID, uHighAccountID, viewJ);
         }
         // Reserve is not scaled by load.
-        else if (bReserveIncrease && mPriorBalance < reserveCreate)
+        else if (bReserveIncrease && preFeeBalance_ < reserveCreate)
         {
             JLOG(j_.trace()) << "Delay transaction: Insufficent reserve to "
                                 "add trust line.";
@@ -598,8 +598,8 @@ SetTrust::doApply()
         JLOG(j_.trace()) << "Redundant: Setting non-existent ripple line to defaults.";
         return tecNO_LINE_REDUNDANT;
     }
-    else if (mPriorBalance < reserveCreate)  // Reserve is not scaled by
-                                             // load.
+    else if (preFeeBalance_ < reserveCreate)  // Reserve is not scaled by
+                                              // load.
     {
         JLOG(j_.trace()) << "Delay transaction: Line does not exist. "
                             "Insufficent reserve to create line.";
diff --git a/src/libxrpl/tx/transactors/Vault/VaultClawback.cpp b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Vault/VaultClawback.cpp
rename to src/libxrpl/tx/transactors/vault/VaultClawback.cpp
index bce53c706d..bfce93b1dd 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultClawback.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp
@@ -8,7 +8,7 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Vault/VaultClawback.h>
+#include <xrpl/tx/transactors/vault/VaultClawback.h>
 
 #include <optional>
 
diff --git a/src/libxrpl/tx/transactors/Vault/VaultCreate.cpp b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp
similarity index 92%
rename from src/libxrpl/tx/transactors/Vault/VaultCreate.cpp
rename to src/libxrpl/tx/transactors/vault/VaultCreate.cpp
index 230651fd9b..4e9faeb56c 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultCreate.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultCreate.cpp
@@ -10,9 +10,9 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
-#include <xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h>
-#include <xrpl/tx/transactors/Vault/VaultCreate.h>
+#include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
+#include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
+#include <xrpl/tx/transactors/vault/VaultCreate.h>
 
 namespace xrpl {
 
@@ -137,7 +137,7 @@ VaultCreate::doApply()
     // We will create Vault and PseudoAccount, hence increase OwnerCount by 2
     adjustOwnerCount(view(), owner, 2, j_);
     auto const ownerCount = owner->at(sfOwnerCount);
-    if (mPriorBalance < view().fees().accountReserve(ownerCount))
+    if (preFeeBalance_ < view().fees().accountReserve(ownerCount))
         return tecINSUFFICIENT_RESERVE;
 
     auto maybePseudo = createPseudoAccount(view(), vault->key(), sfVaultID);
@@ -147,7 +147,7 @@ VaultCreate::doApply()
     auto pseudoId = pseudo->at(sfAccount);
     auto asset = tx[sfAsset];
 
-    if (auto ter = addEmptyHolding(view(), pseudoId, mPriorBalance, asset, j_); !isTesSuccess(ter))
+    if (auto ter = addEmptyHolding(view(), pseudoId, preFeeBalance_, asset, j_); !isTesSuccess(ter))
         return ter;
 
     std::uint8_t const scale = (asset.holds<MPTIssue>() || asset.native())
@@ -206,7 +206,7 @@ VaultCreate::doApply()
 
     // Explicitly create MPToken for the vault owner
     if (auto const err =
-            authorizeMPToken(view(), mPriorBalance, mptIssuanceID, account_, ctx_.journal);
+            authorizeMPToken(view(), preFeeBalance_, mptIssuanceID, account_, ctx_.journal);
         !isTesSuccess(err))
         return err;
 
@@ -214,7 +214,7 @@ VaultCreate::doApply()
     if (txFlags & tfVaultPrivate)
     {
         if (auto const err = authorizeMPToken(
-                view(), mPriorBalance, mptIssuanceID, pseudoId, ctx_.journal, {}, account_);
+                view(), preFeeBalance_, mptIssuanceID, pseudoId, ctx_.journal, {}, account_);
             !isTesSuccess(err))
             return err;
     }
diff --git a/src/libxrpl/tx/transactors/Vault/VaultDelete.cpp b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Vault/VaultDelete.cpp
rename to src/libxrpl/tx/transactors/vault/VaultDelete.cpp
index 0b3aef19a8..ad39ed9cf2 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultDelete.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Vault/VaultDelete.h>
+#include <xrpl/tx/transactors/vault/VaultDelete.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Vault/VaultDeposit.cpp b/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp
similarity index 96%
rename from src/libxrpl/tx/transactors/Vault/VaultDeposit.cpp
rename to src/libxrpl/tx/transactors/vault/VaultDeposit.cpp
index c3a9327f2a..fe3d8d313a 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultDeposit.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultDeposit.cpp
@@ -9,8 +9,8 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
-#include <xrpl/tx/transactors/Vault/VaultDeposit.h>
+#include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
+#include <xrpl/tx/transactors/vault/VaultDeposit.h>
 
 namespace xrpl {
 
@@ -146,7 +146,7 @@ VaultDeposit::doApply()
     if (vault->isFlag(lsfVaultPrivate) && account_ != vault->at(sfOwner))
     {
         if (auto const err = enforceMPTokenAuthorization(
-                ctx_.view(), mptIssuanceID, account_, mPriorBalance, j_);
+                ctx_.view(), mptIssuanceID, account_, preFeeBalance_, j_);
             !isTesSuccess(err))
             return err;
     }
@@ -156,7 +156,7 @@ VaultDeposit::doApply()
         if (!view().exists(keylet::mptoken(mptIssuanceID, account_)))
         {
             if (auto const err = authorizeMPToken(
-                    view(), mPriorBalance, mptIssuanceID->value(), account_, ctx_.journal);
+                    view(), preFeeBalance_, mptIssuanceID->value(), account_, ctx_.journal);
                 !isTesSuccess(err))
                 return err;
         }
@@ -169,7 +169,7 @@ VaultDeposit::doApply()
                 account_ == vault->at(sfOwner), "xrpl::VaultDeposit::doApply : account is owner");
             if (auto const err = authorizeMPToken(
                     view(),
-                    mPriorBalance,              // priorBalance
+                    preFeeBalance_,             // priorBalance
                     mptIssuanceID->value(),     // mptIssuanceID
                     sleIssuance->at(sfIssuer),  // account
                     ctx_.journal,
diff --git a/src/libxrpl/tx/transactors/Vault/VaultSet.cpp b/src/libxrpl/tx/transactors/vault/VaultSet.cpp
similarity index 99%
rename from src/libxrpl/tx/transactors/Vault/VaultSet.cpp
rename to src/libxrpl/tx/transactors/vault/VaultSet.cpp
index c27c9aae3c..532edcdcef 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultSet.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultSet.cpp
@@ -7,7 +7,7 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Vault/VaultSet.h>
+#include <xrpl/tx/transactors/vault/VaultSet.h>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/transactors/Vault/VaultWithdraw.cpp b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
similarity index 98%
rename from src/libxrpl/tx/transactors/Vault/VaultWithdraw.cpp
rename to src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
index 3e468df2fc..725c54a3fd 100644
--- a/src/libxrpl/tx/transactors/Vault/VaultWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
@@ -7,7 +7,7 @@
 #include <xrpl/protocol/STTakesAsset.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/Vault/VaultWithdraw.h>
+#include <xrpl/tx/transactors/vault/VaultWithdraw.h>
 
 namespace xrpl {
 
@@ -230,7 +230,7 @@ VaultWithdraw::doApply()
     associateAsset(*vault, vaultAsset);
 
     return doWithdraw(
-        view(), ctx_.tx, account_, dstAcct, vaultAccount, mPriorBalance, assetsWithdrawn, j_);
+        view(), ctx_.tx, account_, dstAcct, vaultAccount, preFeeBalance_, assetsWithdrawn, j_);
 }
 
 }  // namespace xrpl
diff --git a/src/test/app/AMMCalc_test.cpp b/src/test/app/AMMCalc_test.cpp
index e6e68a95ce..690329d2f3 100644
--- a/src/test/app/AMMCalc_test.cpp
+++ b/src/test/app/AMMCalc_test.cpp
@@ -1,7 +1,7 @@
 #include <test/jtx.h>
 
 #include <xrpl/protocol/Quality.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
 
 #include <boost/regex.hpp>
 
diff --git a/src/test/app/AMMClawback_test.cpp b/src/test/app/AMMClawback_test.cpp
index 114a96b081..3034c628f4 100644
--- a/src/test/app/AMMClawback_test.cpp
+++ b/src/test/app/AMMClawback_test.cpp
@@ -3,7 +3,7 @@
 #include <test/jtx/CaptureLogs.h>
 
 #include <xrpl/protocol/Feature.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 namespace test {
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
index 06f82418da..14be260822 100644
--- a/src/test/app/AMMExtended_test.cpp
+++ b/src/test/app/AMMExtended_test.cpp
@@ -12,8 +12,8 @@
 #include <xrpl/protocol/STParsedJSON.h>
 #include <xrpl/tx/paths/Flow.h>
 #include <xrpl/tx/paths/detail/StrandFlow.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 #include <utility>
 #include <vector>
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index fc801be816..d09c482801 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -10,10 +10,10 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TER.h>
-#include <xrpl/tx/transactors/AMM/AMMBid.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMBid.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 #include <boost/regex.hpp>
 
@@ -2342,7 +2342,7 @@ private:
             // The vote is not added to the slots
             ammAlice.vote(carol, 1'000);
             auto const info = ammAlice.ammRpcInfo()[jss::amm][jss::vote_slots];
-            for (std::uint16_t i = 0; i < info.size(); ++i)
+            for (std::uint32_t i = 0; i < info.size(); ++i)
                 BEAST_EXPECT(info[i][jss::account] != carol.human());
             // But the slots are refreshed and the fee is changed
             BEAST_EXPECT(ammAlice.expectTradingFee(82));
@@ -5154,7 +5154,7 @@ private:
             // verify that the quality is better in the first case, and CLOB
             // is selected in the second case.
             {
-                std::array<Quality, 3> q;
+                std::array<Quality, 3> q{};
                 for (auto i = 0; i < 3; ++i)
                 {
                     Env env(*this, features);
@@ -5227,7 +5227,7 @@ private:
 
             // Same as the payment but reduced offer quality
             {
-                std::array<Quality, 3> q;
+                std::array<Quality, 3> q{};
                 for (auto i = 0; i < 3; ++i)
                 {
                     Env env(*this, features);
@@ -5426,7 +5426,7 @@ private:
             // multiple AMM offers are generated, which results in slightly
             // worse overall quality.
             {
-                std::array<Quality, 3> q;
+                std::array<Quality, 3> q{};
                 for (auto i = 0; i < 3; ++i)
                 {
                     Env env(*this, features);
@@ -6117,9 +6117,13 @@ private:
                 auto const failUsdBIT = features[fixAMMv1_1] ? input.failUsdBITr : input.failUsdBIT;
                 auto const goodUsdGH = features[fixAMMv1_1] ? input.goodUsdGHr : input.goodUsdGH;
                 auto const goodUsdBIT = features[fixAMMv1_1] ? input.goodUsdBITr : input.goodUsdBIT;
-                auto const lpTokenBalance = env.enabled(fixAMMv1_3) && input.lpTokenBalanceAlt
-                    ? *input.lpTokenBalanceAlt
-                    : input.lpTokenBalance;
+                auto const lpTokenBalance = [&] {
+                    if (not env.enabled(fixAMMv1_3))
+                        return input.lpTokenBalance;
+
+                    return input.lpTokenBalanceAlt.value_or(input.lpTokenBalance);
+                }();
+
                 if (!features[fixAMMOverflowOffer])
                 {
                     BEAST_EXPECT(amm.expectBalances(failUsdGH, failUsdBIT, lpTokenBalance));
diff --git a/src/test/rpc/AccountSet_test.cpp b/src/test/app/AccountSet_test.cpp
similarity index 99%
rename from src/test/rpc/AccountSet_test.cpp
rename to src/test/app/AccountSet_test.cpp
index d342bf366a..87c6474be2 100644
--- a/src/test/rpc/AccountSet_test.cpp
+++ b/src/test/app/AccountSet_test.cpp
@@ -575,6 +575,6 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE_PRIO(AccountSet, rpc, xrpl, 1);
+BEAST_DEFINE_TESTSUITE_PRIO(AccountSet, app, xrpl, 1);
 
 }  // namespace xrpl
diff --git a/src/test/app/Batch_test.cpp b/src/test/app/Batch_test.cpp
index 420999c192..143ecaa241 100644
--- a/src/test/app/Batch_test.cpp
+++ b/src/test/app/Batch_test.cpp
@@ -13,8 +13,8 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/server/NetworkOPs.h>
 #include <xrpl/tx/apply.h>
-#include <xrpl/tx/transactors/Batch.h>
-#include <xrpl/tx/transactors/Payment.h>
+#include <xrpl/tx/transactors/payment/Payment.h>
+#include <xrpl/tx/transactors/system/Batch.h>
 
 namespace xrpl {
 namespace test {
@@ -2312,7 +2312,7 @@ class Batch_test : public beast::unit_test::suite
             txn[sfTxnSignature] = "DEADBEEF";
             STParsedJSONObject parsed("test", txn.getTxn());
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate("TxnSignature set", s.slice(), __LINE__);
         }
 
@@ -2326,7 +2326,7 @@ class Batch_test : public beast::unit_test::suite
             txn[sfSigningPubKey] = strHex(alice.pk());
             STParsedJSONObject parsed("test", txn.getTxn());
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate(
                 "SigningPubKey set",
                 s.slice(),
@@ -2345,7 +2345,7 @@ class Batch_test : public beast::unit_test::suite
             txn[sfSigners] = Json::arrayValue;
             STParsedJSONObject parsed("test", txn.getTxn());
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate(
                 "Signers set",
                 s.slice(),
@@ -2361,7 +2361,7 @@ class Batch_test : public beast::unit_test::suite
 
             STParsedJSONObject parsed("test", jt.jv);
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate(
                 "Fully signed", s.slice(), __LINE__, std::nullopt, std::nullopt, !withBatch);
         }
@@ -2375,7 +2375,7 @@ class Batch_test : public beast::unit_test::suite
             auto txn = batch::inner(pay(alice, bob, XRP(1)), env.seq(alice));
             STParsedJSONObject parsed("test", txn.getTxn());
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate(
                 "No signing fields set",
                 s.slice(),
@@ -2399,7 +2399,7 @@ class Batch_test : public beast::unit_test::suite
             auto txn = batch::inner(amendTx.getJson(JsonOptions::none), env.seq(alice));
             STParsedJSONObject parsed("test", txn.getTxn());
             Serializer s;
-            parsed.object->add(s);
+            parsed.object->add(s);  // NOLINT(bugprone-unchecked-optional-access)
             submitAndValidate(
                 "Pseudo-transaction",
                 s.slice(),
@@ -3378,7 +3378,6 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), aliceSeq + 2));
 
             auto const noopTxn = env.jt(noop(alice), seq(aliceSeq + 1));
-            auto const noopTxnID = to_string(noopTxn.stx->getTransactionID());
             env(noopTxn, ter(tesSUCCESS));
             env.close();
 
@@ -3471,7 +3470,6 @@ class Batch_test : public beast::unit_test::suite
 
             // AccountSet Txn
             auto const noopTxn = env.jt(noop(alice), ticket::use(aliceTicketSeq + 1));
-            auto const noopTxnID = to_string(noopTxn.stx->getTransactionID());
             env(noopTxn, ter(tesSUCCESS));
 
             // Batch Txn
@@ -4454,6 +4452,7 @@ public:
     run() override
     {
         using namespace test::jtx;
+
         auto const sa = testable_amendments();
         testWithFeats(sa);
     }
diff --git a/src/test/app/DID_test.cpp b/src/test/app/DID_test.cpp
index f83571deab..20c367d64f 100644
--- a/src/test/app/DID_test.cpp
+++ b/src/test/app/DID_test.cpp
@@ -189,7 +189,7 @@ struct DID_test : public beast::unit_test::suite
         Account const edna{"edna"};
         Account const francis{"francis"};
         Account const george{"george"};
-        env.fund(XRP(5000), alice, bob, charlie, dave, edna, francis);
+        env.fund(XRP(5000), alice, bob, charlie, dave, edna, francis, george);
         env.close();
         BEAST_EXPECT(ownerCount(env, alice) == 0);
         BEAST_EXPECT(ownerCount(env, bob) == 0);
@@ -355,12 +355,14 @@ struct DID_test : public beast::unit_test::suite
         testAccountReserve(all);
         testSetInvalid(all);
         testDeleteInvalid(all);
+        testSetValidInitial(all);
         testSetModify(all);
 
         testEnabled(all - emptyDID);
         testAccountReserve(all - emptyDID);
         testSetInvalid(all - emptyDID);
         testDeleteInvalid(all - emptyDID);
+        testSetValidInitial(all - emptyDID);
         testSetModify(all - emptyDID);
     }
 };
diff --git a/src/test/app/DNS_test.cpp b/src/test/app/DNS_test.cpp
index f478bc89ee..0c2946f8ed 100644
--- a/src/test/app/DNS_test.cpp
+++ b/src/test/app/DNS_test.cpp
@@ -33,7 +33,7 @@ public:
     {
         auto onFetch = [&](error_code const& errorCode,
                            endpoint_type const& endpoint,
-                           xrpl::detail::response_type&& resp) {
+                           xrpl::detail::response_type const& resp) {
             BEAST_EXPECT(!errorCode);
             lastEndpoint_ = endpoint;
             resolved_[endpoint.address().to_string()]++;
diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp
index 31a394eeeb..cbfa29c215 100644
--- a/src/test/app/Delegate_test.cpp
+++ b/src/test/app/Delegate_test.cpp
@@ -1614,13 +1614,7 @@ class Delegate_test : public beast::unit_test::suite
             {"CredentialDelete", featureCredentials},
             {"NFTokenModify", featureDynamicNFT},
             {"PermissionedDomainSet", featurePermissionedDomains},
-            {"PermissionedDomainDelete", featurePermissionedDomains},
-            {"VaultCreate", featureSingleAssetVault},
-            {"VaultSet", featureSingleAssetVault},
-            {"VaultDelete", featureSingleAssetVault},
-            {"VaultDeposit", featureSingleAssetVault},
-            {"VaultWithdraw", featureSingleAssetVault},
-            {"VaultClawback", featureSingleAssetVault}};
+            {"PermissionedDomainDelete", featurePermissionedDomains}};
 
         // Can not delegate tx if any required feature disabled.
         {
@@ -1660,6 +1654,56 @@ class Delegate_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testTxDelegableCount()
+    {
+        testcase("Delegable Transactions Completeness");
+
+        std::size_t delegableCount = 0;
+
+#pragma push_macro("TRANSACTION")
+#undef TRANSACTION
+
+#define TRANSACTION(tag, value, name, delegable, ...) \
+    if (delegable == xrpl::delegable)                 \
+    {                                                 \
+        delegableCount++;                             \
+    }
+
+#include <xrpl/protocol/detail/transactions.macro>
+
+#undef TRANSACTION
+#pragma pop_macro("TRANSACTION")
+
+        // ====================================================================
+        // IMPORTANT NOTICE:
+        //
+        // If this test fails, it indicates that the 'Delegation::delegable' status
+        // in transactions.macro has been changed. Delegation allows accounts to act
+        // on behalf of others, significantly increasing the security surface.
+        //
+        //
+        // To ENSURE any added transaction is safe and compatible with delegation:
+        //
+        // 1. Verify that the transaction is intended to be delegable.
+        // 2. Every standard test case for that transaction MUST be
+        //    duplicated and verified for a Delegated context.
+        // 3. Ensure that Fee, Reserve, and Signing are correctly handled.
+        //
+        // DO NOT modify expectedDelegableCount unless all scenarios, including
+        // edge cases, have been fully tested and verified.
+        // ====================================================================
+        std::size_t const expectedDelegableCount = 75;
+
+        BEAST_EXPECTS(
+            delegableCount == expectedDelegableCount,
+            "\n[SECURITY] New delegable transaction detected!"
+            "\n  Expected: " +
+                std::to_string(expectedDelegableCount) +
+                "\n  Actual:   " + std::to_string(delegableCount) +
+                "\n  Action: Verify security requirements to interact with Delegation feature");
+    }
+
     void
     run() override
     {
@@ -1684,6 +1728,7 @@ class Delegate_test : public beast::unit_test::suite
         testMultiSignQuorumNotMet();
         testPermissionValue(all);
         testTxRequireFeatures(all);
+        testTxDelegableCount();
     }
 };
 BEAST_DEFINE_TESTSUITE(Delegate, app, xrpl);
diff --git a/src/test/app/FixNFTokenPageLinks_test.cpp b/src/test/app/FixNFTokenPageLinks_test.cpp
index 67dadac5e1..8022c52a5d 100644
--- a/src/test/app/FixNFTokenPageLinks_test.cpp
+++ b/src/test/app/FixNFTokenPageLinks_test.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
diff --git a/src/test/app/HashRouter_test.cpp b/src/test/app/HashRouter_test.cpp
index 753922a67d..43ef4a4e06 100644
--- a/src/test/app/HashRouter_test.cpp
+++ b/src/test/app/HashRouter_test.cpp
@@ -243,7 +243,7 @@ class HashRouter_test : public beast::unit_test::suite
         HashRouter router(getSetup(5s, 1s), stopwatch);
         uint256 const key(1);
         HashRouter::PeerShortID peer = 1;
-        HashRouterFlags flags;
+        HashRouterFlags flags = HashRouterFlags::UNDEFINED;
 
         BEAST_EXPECT(router.shouldProcess(key, peer, flags, 1s));
         BEAST_EXPECT(!router.shouldProcess(key, peer, flags, 1s));
diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp
index a01026c8ef..8b78caec11 100644
--- a/src/test/app/Invariants_test.cpp
+++ b/src/test/app/Invariants_test.cpp
@@ -110,6 +110,7 @@ class Invariants_test : public beast::unit_test::suite
 
     void
     doInvariantCheck(
+        // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
         test::jtx::Env&& env,
         test::jtx::Account const& A1,
         test::jtx::Account const& A2,
@@ -3499,12 +3500,13 @@ class Invariants_test : public beast::unit_test::suite
             precloseXrp);
 
         doInvariantCheck(
-            {"withdrawal must change vault and destination balance by "
-             "equal amount",
-             "withdrawal must decrease vault balance",
-             "withdrawal must increase destination balance",
-             "withdrawal and assets outstanding must add up",
-             "withdrawal and assets available must add up"},
+            {
+                "withdrawal must change vault and destination balance by equal amount",
+                "withdrawal must decrease vault balance",
+                "withdrawal must increase destination balance",
+                "withdrawal and assets outstanding must add up",
+                "withdrawal and assets available must add up",
+            },
             [&](Account const& A1, Account const& A2, ApplyContext& ac) {
                 auto const keylet = keylet::vault(A1.id(), ac.view().seq());
 
diff --git a/src/test/app/LedgerLoad_test.cpp b/src/test/app/LedgerLoad_test.cpp
index 0a1ffc024a..4c0cb00f3f 100644
--- a/src/test/app/LedgerLoad_test.cpp
+++ b/src/test/app/LedgerLoad_test.cpp
@@ -58,10 +58,11 @@ class LedgerLoad_test : public beast::unit_test::suite
             Account acct{"A" + std::to_string(i)};
             env.fund(XRP(10000), acct);
             env.close();
-            if (i > 0 && BEAST_EXPECT(prev))
+            if (i > 0 && BEAST_EXPECT(prev.has_value()))
             {
-                env.trust(acct["USD"](1000), *prev);
-                env(pay(acct, *prev, acct["USD"](5)));
+                env.trust(acct["USD"](1000), *prev);  // NOLINT(bugprone-unchecked-optional-access)
+                env(pay(
+                    acct, *prev, acct["USD"](5)));  // NOLINT(bugprone-unchecked-optional-access)
             }
             env(offer(acct, XRP(100), acct["USD"](1)));
             env.close();
diff --git a/src/test/app/LedgerMaster_test.cpp b/src/test/app/LedgerMaster_test.cpp
index 50a8a2ed02..b48579043e 100644
--- a/src/test/app/LedgerMaster_test.cpp
+++ b/src/test/app/LedgerMaster_test.cpp
@@ -78,6 +78,7 @@ class LedgerMaster_test : public beast::unit_test::suite
             uint32_t txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(startLegSeq, txnIndex);
             BEAST_EXPECT(
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 *result ==
                 uint256(
                     "277F4FD89C20B92457FEF05FF63F6405563AD0563C73D967A29727"
@@ -88,6 +89,7 @@ class LedgerMaster_test : public beast::unit_test::suite
             uint32_t txnIndex = metas[1]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(startLegSeq + 1, txnIndex);
             BEAST_EXPECT(
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 *result ==
                 uint256(
                     "293DF7335EBBAF4420D52E70ABF470EB4C5792CAEA2F91F76193C2"
diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp
index 5568a90d03..4428e82ea9 100644
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -1128,9 +1128,27 @@ struct LedgerReplayer_test : public beast::unit_test::suite
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Completed, TaskStatus::Completed, deltaStatuses));
 
-        // sweep
-        net.client.replayer.sweep();
-        BEAST_EXPECT(net.client.countsAsExpected(0, 0, 0));
+        // sweep() cleans up skipLists_ and deltas_ by removing entries whose
+        // weak_ptr can no longer be locked. Those weak_ptrs expire only when the
+        // last shared_ptr holder releases the sub-task. The sole owner is the
+        // LedgerReplayTask, but a JobQueue worker thread may still hold a
+        // temporary shared_ptr to a sub-task (from wptr.lock()) while executing
+        // the timer job that drove the task to completion. If sweep() runs before
+        // that thread unwinds, the weak_ptr is still lockable and the map entry
+        // is not removed. We retry until the worker thread finishes.
+        auto waitForSweep = [&net]() {
+            for (auto numAttempts = 0; numAttempts < 20; ++numAttempts)
+            {
+                net.client.replayer.sweep();
+                if (net.client.countsAsExpected(0, 0, 0))
+                {
+                    return true;
+                }
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            }
+            return false;
+        };
+        BEAST_EXPECT(waitForSweep());
     }
 
     void
diff --git a/src/test/app/LendingHelpers_test.cpp b/src/test/app/LendingHelpers_test.cpp
index aae60a252a..24661c18fb 100644
--- a/src/test/app/LendingHelpers_test.cpp
+++ b/src/test/app/LendingHelpers_test.cpp
@@ -8,9 +8,9 @@
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/server/LoadFeeTrack.h>
-#include <xrpl/tx/transactors/Batch.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
-#include <xrpl/tx/transactors/Lending/LoanSet.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LoanSet.h>
+#include <xrpl/tx/transactors/system/Batch.h>
 
 #include <string>
 #include <vector>
diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp
index 31cfb5c231..b41a84f59d 100644
--- a/src/test/app/LoanBroker_test.cpp
+++ b/src/test/app/LoanBroker_test.cpp
@@ -1,7 +1,7 @@
 #include <test/jtx.h>
 
 #include <xrpl/beast/unit_test/suite.h>
-#include <xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h>
+#include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
 
 namespace xrpl {
 namespace test {
@@ -674,38 +674,28 @@ class LoanBroker_test : public beast::unit_test::suite
 
                     // fields that can't be changed
                     // LoanBrokerID
-                    env(set(alice, vault.vaultID),
-                        loanBrokerID(nextKeylet.key),
-                        ter(tecNO_ENTRY),
-                        THISLINE);
+                    env(set(alice, vault.vaultID), loanBrokerID(nextKeylet.key), ter(tecNO_ENTRY));
                     // VaultID
-                    env(set(alice, nextKeylet.key),
-                        loanBrokerID(broker->key()),
-                        ter(tecNO_ENTRY),
-                        THISLINE);
+                    env(set(alice, nextKeylet.key), loanBrokerID(broker->key()), ter(tecNO_ENTRY));
                     // Owner
                     env(set(evan, vault.vaultID),
                         loanBrokerID(broker->key()),
-                        ter(tecNO_PERMISSION),
-                        THISLINE);
+                        ter(tecNO_PERMISSION));
                     // ManagementFeeRate
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         managementFeeRate(maxManagementFeeRate),
-                        ter(temINVALID),
-                        THISLINE);
+                        ter(temINVALID));
                     // CoverRateMinimum
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         coverRateMinimum(maxManagementFeeRate),
-                        ter(temINVALID),
-                        THISLINE);
+                        ter(temINVALID));
                     // CoverRateLiquidation
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         coverRateLiquidation(maxManagementFeeRate),
-                        ter(temINVALID),
-                        THISLINE);
+                        ter(temINVALID));
 
                     // fields that can be changed
                     testData = "Test Data 1234";
@@ -713,15 +703,13 @@ class LoanBroker_test : public beast::unit_test::suite
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         data(std::string(maxDataPayloadLength + 1, 'W')),
-                        ter(temINVALID),
-                        THISLINE);
+                        ter(temINVALID));
 
                     // Bad debt maximum
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         debtMaximum(Number(-175, -1)),
-                        ter(temINVALID),
-                        THISLINE);
+                        ter(temINVALID));
                     Number debtMax{175, -1};
                     if (vault.asset.integral())
                     {
@@ -729,16 +717,14 @@ class LoanBroker_test : public beast::unit_test::suite
                             loanBrokerID(broker->key()),
                             data(testData),
                             debtMaximum(debtMax),
-                            ter(tecPRECISION_LOSS),
-                            THISLINE);
+                            ter(tecPRECISION_LOSS));
                         roundToAsset(vault.asset, debtMax);
                     }
                     // Data & Debt maximum
                     env(set(alice, vault.vaultID),
                         loanBrokerID(broker->key()),
                         data(testData),
-                        debtMaximum(debtMax),
-                        THISLINE);
+                        debtMaximum(debtMax));
                 },
                 [&](SLE::const_ref broker) {
                     // Check the updated fields
@@ -817,16 +803,16 @@ class LoanBroker_test : public beast::unit_test::suite
         PrettyAsset const asset = [&]() {
             if (getAsset)
                 return getAsset(env, issuer, alice);
-            env(trust(alice, issuer["IOU"](1'000'000)), THISLINE);
+            env(trust(alice, issuer["IOU"](1'000'000)));
             env.close();
             return PrettyAsset(issuer["IOU"]);
         }();
 
-        env(pay(issuer, alice, asset(100'000)), THISLINE);
+        env(pay(issuer, alice, asset(100'000)));
         env.close();
 
         auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
-        env(tx, THISLINE);
+        env(tx);
         env.close();
         auto const le = env.le(vaultKeylet);
         VaultInfo vaultInfo = [&]() {
@@ -837,12 +823,11 @@ class LoanBroker_test : public beast::unit_test::suite
         if (vaultInfo.vaultID == uint256{})
             return;
 
-        env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}),
-            THISLINE);
+        env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
         env.close();
 
         auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice));
-        env(set(alice, vaultInfo.vaultID), THISLINE);
+        env(set(alice, vaultInfo.vaultID));
         env.close();
 
         auto broker = env.le(brokerKeylet);
@@ -853,23 +838,23 @@ class LoanBroker_test : public beast::unit_test::suite
             auto jv = getTxJv();
             // empty broker ID
             jv[sfLoanBrokerID] = "";
-            env(jv, ter(temINVALID), THISLINE);
+            env(jv, ter(temINVALID));
             // zero broker ID
             jv[sfLoanBrokerID] = to_string(uint256{});
             // needs a flag to distinguish the parsed STTx from the prior
             // test
-            env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID), THISLINE);
+            env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
         };
         auto testZeroVaultID = [&](auto&& getTxJv) {
             auto jv = getTxJv();
             // empty broker ID
             jv[sfVaultID] = "";
-            env(jv, ter(temINVALID), THISLINE);
+            env(jv, ter(temINVALID));
             // zero broker ID
             jv[sfVaultID] = to_string(uint256{});
             // needs a flag to distinguish the parsed STTx from the prior
             // test
-            env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID), THISLINE);
+            env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
         };
 
         if (brokerTest == CoverDeposit)
@@ -878,26 +863,22 @@ class LoanBroker_test : public beast::unit_test::suite
             testZeroBrokerID([&]() { return coverDeposit(alice, brokerKeylet.key, asset(10)); });
 
             // preclaim: tecWRONG_ASSET
-            env(coverDeposit(alice, brokerKeylet.key, issuer["BAD"](10)),
-                ter(tecWRONG_ASSET),
-                THISLINE);
+            env(coverDeposit(alice, brokerKeylet.key, issuer["BAD"](10)), ter(tecWRONG_ASSET));
 
             // preclaim: tecINSUFFICIENT_FUNDS
-            env(pay(alice, issuer, asset(100'000 - 50)), THISLINE);
+            env(pay(alice, issuer, asset(100'000 - 50)));
             env.close();
             env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)),
                 ter(tecINSUFFICIENT_FUNDS));
 
             // preclaim: tecFROZEN
-            env(fset(issuer, asfGlobalFreeze), THISLINE);
+            env(fset(issuer, asfGlobalFreeze));
             env.close();
-            env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)),
-                ter(tecFROZEN),
-                THISLINE);
+            env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)), ter(tecFROZEN));
         }
         else
             // Fund the cover deposit
-            env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)), THISLINE);
+            env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)));
         env.close();
 
         if (brokerTest == CoverWithdraw)
@@ -906,59 +887,51 @@ class LoanBroker_test : public beast::unit_test::suite
             testZeroBrokerID([&]() { return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
 
             // preclaim: tecWRONG_ASSET
-            env(coverWithdraw(alice, brokerKeylet.key, issuer["BAD"](10)),
-                ter(tecWRONG_ASSET),
-                THISLINE);
+            env(coverWithdraw(alice, brokerKeylet.key, issuer["BAD"](10)), ter(tecWRONG_ASSET));
 
             // preclaim: tecNO_DST
             Account const bogus{"bogus"};
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(bogus),
-                ter(tecNO_DST),
-                THISLINE);
+                ter(tecNO_DST));
 
             // preclaim: tecDST_TAG_NEEDED
             Account const dest{"dest"};
             env.fund(XRP(1'000), dest);
-            env(fset(dest, asfRequireDest), THISLINE);
+            env(fset(dest, asfRequireDest));
             env.close();
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(dest),
-                ter(tecDST_TAG_NEEDED),
-                THISLINE);
+                ter(tecDST_TAG_NEEDED));
 
             // preclaim: tecNO_PERMISSION
-            env(fclear(dest, asfRequireDest), THISLINE);
-            env(fset(dest, asfDepositAuth), THISLINE);
+            env(fclear(dest, asfRequireDest));
+            env(fset(dest, asfDepositAuth));
             env.close();
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(dest),
-                ter(tecNO_PERMISSION),
-                THISLINE);
+                ter(tecNO_PERMISSION));
 
             // preclaim: tecFROZEN
-            env(trust(dest, asset(1'000)), THISLINE);
-            env(fclear(dest, asfDepositAuth), THISLINE);
-            env(fset(issuer, asfGlobalFreeze), THISLINE);
+            env(trust(dest, asset(1'000)));
+            env(fclear(dest, asfDepositAuth));
+            env(fset(issuer, asfGlobalFreeze));
             env.close();
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(dest),
-                ter(tecFROZEN),
-                THISLINE);
+                ter(tecFROZEN));
 
             // preclaim:: tecFROZEN (deep frozen)
-            env(fclear(issuer, asfGlobalFreeze), THISLINE);
-            env(trust(issuer, asset(1'000), dest, tfSetFreeze | tfSetDeepFreeze), THISLINE);
+            env(fclear(issuer, asfGlobalFreeze));
+            env(trust(issuer, asset(1'000), dest, tfSetFreeze | tfSetDeepFreeze));
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(dest),
-                ter(tecFROZEN),
-                THISLINE);
+                ter(tecFROZEN));
 
             // preclaim: tecPSEUDO_ACCOUNT
             env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
                 destination(vaultInfo.pseudoAccount),
-                ter(tecPSEUDO_ACCOUNT),
-                THISLINE);
+                ter(tecPSEUDO_ACCOUNT));
         }
 
         if (brokerTest == CoverClawback)
@@ -977,17 +950,15 @@ class LoanBroker_test : public beast::unit_test::suite
                 env(coverClawback(issuer),
                     loanBrokerID(brokerKeylet.key),
                     amount(vaultInfo.asset(2)),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
 
                 // preclaim: NoFreeze is set
-                env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze), THISLINE);
+                env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze));
                 env.close();
                 env(coverClawback(issuer),
                     loanBrokerID(brokerKeylet.key),
                     amount(vaultInfo.asset(2)),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
             }
             else
             {
@@ -995,8 +966,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 env(coverClawback(issuer),
                     loanBrokerID(brokerKeylet.key),
                     amount(vaultInfo.asset(2)),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
             }
             env.close();
         }
@@ -1007,30 +977,29 @@ class LoanBroker_test : public beast::unit_test::suite
             env.fund(XRP(1'000), borrower);
             env(loan::set(borrower, brokerKeylet.key, asset(50).value()),
                 sig(sfCounterpartySignature, alice),
-                fee(env.current()->fees().base * 2),
-                THISLINE);
+                fee(env.current()->fees().base * 2));
 
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() { return del(alice, brokerKeylet.key); });
 
             // preclaim: tecHAS_OBLIGATIONS
-            env(del(alice, brokerKeylet.key), ter(tecHAS_OBLIGATIONS), THISLINE);
+            env(del(alice, brokerKeylet.key), ter(tecHAS_OBLIGATIONS));
 
             // Repay and delete the loan
             auto const loanKeylet = keylet::loan(brokerKeylet.key, 1);
-            env(loan::pay(borrower, loanKeylet.key, asset(50).value()), THISLINE);
-            env(loan::del(alice, loanKeylet.key), THISLINE);
+            env(loan::pay(borrower, loanKeylet.key, asset(50).value()));
+            env(loan::del(alice, loanKeylet.key));
 
-            env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze), THISLINE);
+            env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
             // preclaim: tecFROZEN (deep frozen)
-            env(del(alice, brokerKeylet.key), ter(tecFROZEN), THISLINE);
-            env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze), THISLINE);
+            env(del(alice, brokerKeylet.key), ter(tecFROZEN));
+            env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
 
             // successful delete the loan broker object
-            env(del(alice, brokerKeylet.key), ter(tesSUCCESS), THISLINE);
+            env(del(alice, brokerKeylet.key), ter(tesSUCCESS));
         }
         else
-            env(del(alice, brokerKeylet.key), THISLINE);
+            env(del(alice, brokerKeylet.key));
 
         if (brokerTest == Set)
         {
@@ -1045,21 +1014,21 @@ class LoanBroker_test : public beast::unit_test::suite
 
             if (asset.holds<Issue>())
             {
-                env(fclear(issuer, asfDefaultRipple), THISLINE);
+                env(fclear(issuer, asfDefaultRipple));
                 env.close();
                 // preclaim: DefaultRipple is not set
-                env(set(alice, vaultInfo.vaultID), ter(terNO_RIPPLE), THISLINE);
+                env(set(alice, vaultInfo.vaultID), ter(terNO_RIPPLE));
 
-                env(fset(issuer, asfDefaultRipple), THISLINE);
+                env(fset(issuer, asfDefaultRipple));
                 env.close();
             }
 
             auto const amt =
                 env.balance(alice) - env.current()->fees().accountReserve(env.ownerCount(alice));
-            env(pay(alice, issuer, amt), THISLINE);
+            env(pay(alice, issuer, amt));
 
             // preclaim:: tecINSUFFICIENT_RESERVE
-            env(set(alice, vaultInfo.vaultID), ter(tecINSUFFICIENT_RESERVE), THISLINE);
+            env(set(alice, vaultInfo.vaultID), ter(tecINSUFFICIENT_RESERVE));
         }
     }
 
@@ -1082,7 +1051,7 @@ class LoanBroker_test : public beast::unit_test::suite
             auto jtx = env.jt(coverClawback(alice), amount(USD(100)));
 
             // holder == account
-            env(jtx, ter(temINVALID), THISLINE);
+            env(jtx, ter(temINVALID));
 
             // holder == beast::zero
             STAmount bad(Issue{USD.currency, beast::zero}, 100);
@@ -1356,11 +1325,11 @@ class LoanBroker_test : public beast::unit_test::suite
             return mptAsset;
         }();
 
-        env(pay(issuer, alice, asset(100'000)), THISLINE);
+        env(pay(issuer, alice, asset(100'000)));
         env.close();
 
         auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
-        env(tx, THISLINE);
+        env(tx);
         env.close();
         auto const le = env.le(vaultKeylet);
         VaultInfo vaultInfo = [&]() {
@@ -1371,20 +1340,18 @@ class LoanBroker_test : public beast::unit_test::suite
         if (vaultInfo.vaultID == uint256{})
             return;
 
-        env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}),
-            THISLINE);
+        env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
         env.close();
 
         auto const brokerKeylet = keylet::loanbroker(alice.id(), env.seq(alice));
-        env(set(alice, vaultInfo.vaultID), THISLINE);
+        env(set(alice, vaultInfo.vaultID));
         env.close();
 
         Account const borrower{"borrower"};
         env.fund(XRP(1'000), borrower);
         env(loan::set(borrower, brokerKeylet.key, asset(50).value()),
             sig(sfCounterpartySignature, alice),
-            fee(env.current()->fees().base * 2),
-            THISLINE);
+            fee(env.current()->fees().base * 2));
         auto const broker = env.le(brokerKeylet);
         if (!BEAST_EXPECT(broker))
             return;
@@ -1395,47 +1362,47 @@ class LoanBroker_test : public beast::unit_test::suite
         auto tx2 = set(alice, vaultInfo.vaultID);
         tx2[sfLoanBrokerID] = to_string(brokerKeylet.key);
         tx2[sfDebtMaximum] = debtTotal - 1;
-        env(tx2, ter(tecLIMIT_EXCEEDED), THISLINE);
+        env(tx2, ter(tecLIMIT_EXCEEDED));
 
         tx2[sfDebtMaximum] = debtTotal + 1;
-        env(tx2, ter(tesSUCCESS), THISLINE);
+        env(tx2, ter(tesSUCCESS));
 
         tx2[sfDebtMaximum] = 0;
-        env(tx2, ter(tesSUCCESS), THISLINE);
+        env(tx2, ter(tesSUCCESS));
 
         tx2[sfDebtMaximum] = Json::Value::maxInt;
-        env(tx2, ter(tesSUCCESS), THISLINE);
+        env(tx2, ter(tesSUCCESS));
 
         {
             auto const dm = power(2, 64) - 1;
             BEAST_EXPECT(dm > maxMPTokenAmount);
             tx2[sfDebtMaximum] = dm;
-            env(tx2, ter(temINVALID), THISLINE);
+            env(tx2, ter(temINVALID));
         }
 
         {
             auto const dm = power(2, 63) - 1;
             BEAST_EXPECTS(dm > maxMPTokenAmount, to_string(dm));
             tx2[sfDebtMaximum] = dm;
-            env(tx2, ter(temINVALID), THISLINE);
+            env(tx2, ter(temINVALID));
         }
 
         {
             auto const dm = power(2, 63) - 3;
             BEAST_EXPECTS(dm == maxMPTokenAmount, to_string(dm));
             tx2[sfDebtMaximum] = dm;
-            env(tx2, ter(tesSUCCESS), THISLINE);
+            env(tx2, ter(tesSUCCESS));
         }
 
         {
             auto const dm = 2 * (power(2, 62) - 1) + 1;
             BEAST_EXPECTS(dm == maxMPTokenAmount, to_string(dm));
             tx2[sfDebtMaximum] = dm;
-            env(tx2, ter(tesSUCCESS), THISLINE);
+            env(tx2, ter(tesSUCCESS));
         }
 
         tx2[sfDebtMaximum] = Number{9223372036854775807, 0};
-        env(tx2, ter(tesSUCCESS), THISLINE);
+        env(tx2, ter(tesSUCCESS));
     }
 
     void
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 607e84abeb..f1cd76d88b 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -6,9 +6,9 @@
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/server/LoadFeeTrack.h>
-#include <xrpl/tx/transactors/Batch.h>
-#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
-#include <xrpl/tx/transactors/Lending/LoanSet.h>
+#include <xrpl/tx/transactors/lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/lending/LoanSet.h>
+#include <xrpl/tx/transactors/system/Batch.h>
 
 #include <chrono>
 
@@ -1127,7 +1127,7 @@ protected:
 
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -1903,7 +1903,6 @@ protected:
         }
 
         // Finally! Create a loan
-        std::string testData;
 
         auto coverAvailable = [&env, this](uint256 const& brokerID, Number const& expected) {
             if (auto const brokerSle = env.le(keylet::loanbroker(brokerID));
@@ -3304,8 +3303,7 @@ protected:
                     interestRate(TenthBips32(10'000)),
                     sig(sfCounterpartySignature, lender),
                     fee(env.current()->fees().base * 5),
-                    ter(tecLIMIT_EXCEEDED),
-                    THISLINE);
+                    ter(tecLIMIT_EXCEEDED));
             },
             nullptr);
 
@@ -3328,8 +3326,7 @@ protected:
                     fee(env.current()->fees().base * 5),
                     paymentTotal(2),
                     paymentInterval(3600 * 24),
-                    ter(tecLIMIT_EXCEEDED),
-                    THISLINE);
+                    ter(tecLIMIT_EXCEEDED));
             },
             nullptr);
     }
@@ -3728,7 +3725,7 @@ protected:
         createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
         // Fails in preclaim because principal requested can't be
         // represented as XRP
-        env(createJson, ter(tecPRECISION_LOSS), THISLINE);
+        env(createJson, ter(tecPRECISION_LOSS));
         env.close();
 
         BEAST_EXPECT(!env.le(keylet));
@@ -3740,7 +3737,7 @@ protected:
         createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
         // Fails in doApply because the payment is too small to be
         // represented as XRP.
-        env(createJson, ter(tecPRECISION_LOSS), THISLINE);
+        env(createJson, ter(tecPRECISION_LOSS));
         env.close();
     }
 
@@ -3765,10 +3762,8 @@ protected:
 
         Account const alice{"alice"};
         std::string const borrowerPass = "borrower";
-        std::string const borrowerSeed = "ssBRAsLpH4778sLNYC4ik1JBJsBVf";
         Account borrower{borrowerPass, KeyType::ed25519};
         auto const lenderPass = "lender";
-        std::string const lenderSeed = "shPTCZGwTEhJrYT8NbcNkeaa8pzPM";
         Account lender{lenderPass, KeyType::ed25519};
 
         env.fund(XRP(1'000'000), alice, lender, borrower);
@@ -4220,8 +4215,8 @@ protected:
         // preclaim
         Env env(*this);
         env.fund(XRP(1'000), lender, issuer, borrower);
-        env(trust(lender, IOU(10'000'000)), THISLINE);
-        env(pay(issuer, lender, IOU(5'000'000)), THISLINE);
+        env(trust(lender, IOU(10'000'000)));
+        env(pay(issuer, lender, IOU(5'000'000)));
         BrokerInfo brokerInfo{createVaultAndBroker(env, issuer["IOU"], lender)};
 
         auto const loanSetFee = fee(env.current()->fees().base * 2);
@@ -4229,22 +4224,21 @@ protected:
 
         env(set(borrower, brokerInfo.brokerID, debtMaximumRequest),
             sig(sfCounterpartySignature, lender),
-            loanSetFee,
-            THISLINE);
+            loanSetFee);
 
         env.close();
 
         std::uint32_t const loanSequence = 1;
         auto const loanKeylet = keylet::loan(brokerInfo.brokerID, loanSequence);
 
-        env(fset(issuer, asfGlobalFreeze), THISLINE);
+        env(fset(issuer, asfGlobalFreeze));
         env.close();
 
         // preclaim: tecFROZEN
-        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN), THISLINE);
+        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN));
         env.close();
 
-        env(fclear(issuer, asfGlobalFreeze), THISLINE);
+        env(fclear(issuer, asfGlobalFreeze));
         env.close();
 
         auto const pseudoBroker = [&]() -> std::optional<Account> {
@@ -4262,33 +4256,29 @@ protected:
             return;
 
         // Lender and pseudoaccount must both be frozen
-        env(trust(issuer, lender["IOU"](1'000), lender, tfSetFreeze | tfSetDeepFreeze), THISLINE);
+        env(trust(issuer, lender["IOU"](1'000), lender, tfSetFreeze | tfSetDeepFreeze));
         env(trust(
-                issuer,
-                (*pseudoBroker)["IOU"](1'000),
-                *pseudoBroker,
-                tfSetFreeze | tfSetDeepFreeze),
-            THISLINE);
+            issuer, (*pseudoBroker)["IOU"](1'000), *pseudoBroker, tfSetFreeze | tfSetDeepFreeze));
         env.close();
 
         // preclaim: tecFROZEN due to deep frozen
-        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN), THISLINE);
+        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecFROZEN));
         env.close();
 
         // Only one needs to be unfrozen
-        env(trust(issuer, lender["IOU"](1'000), tfClearFreeze | tfClearDeepFreeze), THISLINE);
+        env(trust(issuer, lender["IOU"](1'000), tfClearFreeze | tfClearDeepFreeze));
         env.close();
 
         // The payment is late by this point
-        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecEXPIRED), THISLINE);
+        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecEXPIRED));
         env.close();
-        env(pay(borrower, loanKeylet.key, debtMaximumRequest, tfLoanLatePayment), THISLINE);
+        env(pay(borrower, loanKeylet.key, debtMaximumRequest, tfLoanLatePayment));
         env.close();
 
         // preclaim: tecKILLED
         // note that tecKILLED in loanMakePayment()
         // doesn't happen because of the preclaim check.
-        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecKILLED), THISLINE);
+        env(pay(borrower, loanKeylet.key, debtMaximumRequest), ter(tecKILLED));
     }
 
     void
@@ -4640,12 +4630,12 @@ protected:
         auto const keylet = keylet::loan(broker.brokerID, loanSequence);
 
         createJson = env.json(createJson, sig(sfCounterpartySignature, lender));
-        env(createJson, THISLINE);
+        env(createJson);
         env.close();
 
         auto loanPayTx = env.json(pay(borrower, keylet.key, STAmount{broker.asset, Number{}}));
         loanPayTx["Amount"]["value"] = "0.000281284125490196";
-        env(loanPayTx, ter(tecINSUFFICIENT_PAYMENT), THISLINE);
+        env(loanPayTx, ter(tecINSUFFICIENT_PAYMENT));
         env.close();
     }
 
@@ -5346,7 +5336,7 @@ protected:
         auto const loanSetFee = fee(env.current()->fees().base * 2);
 
         auto const brokerPreLoan = env.le(keylet::loanbroker(broker.brokerID));
-        if (!BEAST_EXPECT(brokerPreLoan))
+        if (BEAST_EXPECT(brokerPreLoan); !brokerPreLoan.has_value())
             return;
 
         auto const loanSequence = brokerPreLoan->at(sfLoanSequence);
@@ -5943,7 +5933,7 @@ protected:
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
 
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -6014,7 +6004,7 @@ protected:
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
 
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -6220,7 +6210,7 @@ protected:
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
 
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -6380,7 +6370,7 @@ protected:
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, issuer);
 
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -6436,7 +6426,7 @@ protected:
         auto loanResult =
             createLoan(env, assetType, brokerParams, loanParams, issuer, lender, borrower);
 
-        if (!BEAST_EXPECT(loanResult))
+        if (BEAST_EXPECT(loanResult); !loanResult.has_value())
             return;
 
         auto broker = std::get<BrokerInfo>(*loanResult);
@@ -7091,14 +7081,13 @@ public:
     void
     run() override
     {
-        auto const argument = arg();
         auto const numIterations = [s = arg()]() -> int {
             int defaultNum = 5;
             if (s.empty())
                 return defaultNum;
             try
             {
-                std::size_t pos;
+                std::size_t pos = 0;
                 auto const r = stoi(s, &pos);
                 if (pos != s.size())
                     return defaultNum;
diff --git a/src/test/app/Manifest_test.cpp b/src/test/app/Manifest_test.cpp
index a790584ac2..609b7bdb89 100644
--- a/src/test/app/Manifest_test.cpp
+++ b/src/test/app/Manifest_test.cpp
@@ -1,4 +1,5 @@
 #include <test/jtx.h>
+#include <test/unit_test/utils.h>
 
 #include <xrpld/app/misc/ValidatorList.h>
 
@@ -71,7 +72,7 @@ public:
         {
             setupDatabaseDir(getDatabasePath());
         }
-        catch (std::exception const&)
+        catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -81,7 +82,7 @@ public:
         {
             cleanupDatabaseDir(getDatabasePath());
         }
-        catch (std::exception const&)
+        catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -99,7 +100,10 @@ public:
         st[sfPublicKey] = pk;
         st[sfSigningPubKey] = spk;
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         sign(st, HashPrefix::manifest, *publicKeyType(spk), ssk);
+
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         sign(st, HashPrefix::manifest, *publicKeyType(pk), sk, sfMasterSignature);
 
         Serializer s;
@@ -248,7 +252,6 @@ public:
                 // save should store all trusted master keys to db
                 std::vector<std::string> s1;
                 std::vector<std::string> keys;
-                std::string cfgManifest;
                 for (auto const& man : inManifests)
                     s1.push_back(toBase58(TokenType::NodePublic, man->masterKey));
                 unl->load({}, s1, keys);
@@ -348,7 +351,9 @@ public:
         ss.add32(HashPrefix::manifest);
         st.addWithoutSigningFields(ss);
         auto const sig = sign(KeyType::secp256k1, kp.second, ss.slice());
-        BEAST_EXPECT(strHex(sig) == strHex(*m.getSignature()));
+        BEAST_EXPECT(
+            strHex(sig) ==
+            strHex(*m.getSignature()));  // NOLINT(bugprone-unchecked-optional-access)
 
         auto const masterSig = sign(KeyType::ed25519, sk, ss.slice());
         BEAST_EXPECT(strHex(masterSig) == strHex(m.getMasterSignature()));
@@ -424,24 +429,15 @@ public:
 
             // Format token string to test trim()
             std::vector<std::string> const tokenBlob = {
-                "    "
-                "eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3ND"
-                "diNT\n",
-                " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2Iiwib"
-                "WFuaWZl     \n",
-                "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncx"
-                "L3ZDeE\n",
-                "\t "
-                "hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4"
-                "U0tG\t  \t\n",
-                "bjdNTzJmZGtjd1JRSWhBT25ndTlzQUtxWFlvdUorbDJWMFcrc0FPa1ZCK1pSUz"
-                "ZQU2\n",
-                "hsSkFmVXNYZkFpQnNWSkdlc2FhZE9KYy9hQVpva1MxdnltR21WcmxIUEtXWDNZ"
-                "eXd1\n",
-                "NmluOEhBU1FLUHVnQkQ2N2tNYVJGR3ZtcEFUSGxHS0pkdkRGbFdQWXk1QXFEZW"
-                "RGdj\n",
-                "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0i"
-                "fQ==\n"};
+                "    eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT\n",
+                " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFuaWZl     \n",
+                "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZDeE\n",
+                "\t hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4U0tG\t  \t\n",
+                "bjdNTzJmZGtjd1JRSWhBT25ndTlzQUtxWFlvdUorbDJWMFcrc0FPa1ZCK1pSUzZQU2\n",
+                "hsSkFmVXNYZkFpQnNWSkdlc2FhZE9KYy9hQVpva1MxdnltR21WcmxIUEtXWDNZeXd1\n",
+                "NmluOEhBU1FLUHVnQkQ2N2tNYVJGR3ZtcEFUSGxHS0pkdkRGbFdQWXk1QXFEZWRGdj\n",
+                "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0ifQ==\n",
+            };
 
             auto const manifest =
                 "JAAAAAFxIe1FtwmimvGtH2iCcMJqC9gVFKilGfw1/"
@@ -456,7 +452,9 @@ public:
 
             auto const token = loadValidatorToken(tokenBlob);
             BEAST_EXPECT(token);
-            BEAST_EXPECT(token->validationSecret == *valSecret);
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(test::equal(token->validationSecret, *valSecret));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(token->manifest == manifest);
         }
         {
@@ -584,12 +582,14 @@ public:
                         auto const manifest = deserializeManifest(m);
 
                         BEAST_EXPECT(manifest);
+                        // NOLINTBEGIN(bugprone-unchecked-optional-access)
                         BEAST_EXPECT(manifest->masterKey == pk);
                         BEAST_EXPECT(manifest->signingKey == spk);
                         BEAST_EXPECT(manifest->sequence == sequence);
                         BEAST_EXPECT(manifest->serialized == m);
                         BEAST_EXPECT(manifest->domain.empty());
                         BEAST_EXPECT(manifest->verify());
+                        // NOLINTEND(bugprone-unchecked-optional-access)
                     }
 
                     {  // invalid manifest (empty domain)
@@ -621,12 +621,14 @@ public:
                         auto const manifest = deserializeManifest(m);
 
                         BEAST_EXPECT(manifest);
+                        // NOLINTBEGIN(bugprone-unchecked-optional-access)
                         BEAST_EXPECT(manifest->masterKey == pk);
                         BEAST_EXPECT(manifest->signingKey == spk);
                         BEAST_EXPECT(manifest->sequence == sequence);
                         BEAST_EXPECT(manifest->serialized == m);
                         BEAST_EXPECT(manifest->domain == "example.com");
                         BEAST_EXPECT(manifest->verify());
+                        // NOLINTEND(bugprone-unchecked-optional-access)
                     }
                     {
                         // valid manifest with invalid signature
@@ -637,12 +639,14 @@ public:
                         auto const manifest = deserializeManifest(m);
 
                         BEAST_EXPECT(manifest);
+                        // NOLINTBEGIN(bugprone-unchecked-optional-access)
                         BEAST_EXPECT(manifest->masterKey == pk);
                         BEAST_EXPECT(manifest->signingKey == spk);
                         BEAST_EXPECT(manifest->sequence == sequence + 1);
                         BEAST_EXPECT(manifest->serialized == m);
                         BEAST_EXPECT(manifest->domain == "example.com");
                         BEAST_EXPECT(!manifest->verify());
+                        // NOLINTEND(bugprone-unchecked-optional-access)
                     }
                     {
                         // reject missing sequence
@@ -726,15 +730,16 @@ public:
                         auto const manifest = deserializeManifest(m);
 
                         BEAST_EXPECT(manifest);
+                        // NOLINTBEGIN(bugprone-unchecked-optional-access)
                         BEAST_EXPECT(manifest->masterKey == pk);
 
-                        // Since this manifest is revoked, it should not have
-                        // a signingKey
+                        // Since this manifest is revoked, it should not have a signingKey
                         BEAST_EXPECT(!manifest->signingKey);
                         BEAST_EXPECT(manifest->revoked());
                         BEAST_EXPECT(manifest->domain.empty());
                         BEAST_EXPECT(manifest->serialized == m);
                         BEAST_EXPECT(manifest->verify());
+                        // NOLINTEND(bugprone-unchecked-optional-access)
                     }
 
                     {  // can't specify an ephemeral signing key
diff --git a/src/test/app/MultiSign_test.cpp b/src/test/app/MultiSign_test.cpp
index adfcb12ee0..f96bfba2d2 100644
--- a/src/test/app/MultiSign_test.cpp
+++ b/src/test/app/MultiSign_test.cpp
@@ -486,7 +486,7 @@ public:
         env.close();
 
         auto const baseFee = env.current()->fees().base;
-        std::uint32_t aliceSeq;
+        std::uint32_t aliceSeq = 0;
 
         // these represent oft-repeated setup for input json below
         auto setup_tx = [&]() -> Json::Value {
diff --git a/src/test/app/NFTokenAuth_test.cpp b/src/test/app/NFTokenAuth_test.cpp
index 6fc92bc6cd..b973530f41 100644
--- a/src/test/app/NFTokenAuth_test.cpp
+++ b/src/test/app/NFTokenAuth_test.cpp
@@ -1,6 +1,6 @@
 #include <test/jtx.h>
 
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 namespace xrpl {
 
diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp
index c75e22e954..8cd67bd72b 100644
--- a/src/test/app/NFTokenBurn_test.cpp
+++ b/src/test/app/NFTokenBurn_test.cpp
@@ -2,7 +2,7 @@
 
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <random>
 
diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp
index c186a3d9e5..551b987204 100644
--- a/src/test/app/NFTokenDir_test.cpp
+++ b/src/test/app/NFTokenDir_test.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/protocol/nftPageMask.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <initializer_list>
 
diff --git a/src/test/app/NFToken_test.cpp b/src/test/app/NFToken_test.cpp
index 6d30fc6854..95dfc60c41 100644
--- a/src/test/app/NFToken_test.cpp
+++ b/src/test/app/NFToken_test.cpp
@@ -3,7 +3,7 @@
 #include <xrpl/basics/random.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <initializer_list>
 
@@ -2930,7 +2930,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         uint256 const nftokenID1 = token::getNextID(env, issuer, 0, tfTransferable);
         env(token::mint(minter, 0), token::issuer(issuer), txflags(tfTransferable));
         env.close();
-        uint8_t issuerCount, minterCount, buyerCount;
+        uint8_t issuerCount = 0, minterCount = 0, buyerCount = 0;
 
         // Test how adding an Expiration field to an offer affects permissions
         // for cancelling offers.
diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp
index c2de4f3f08..283abb330e 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -206,6 +206,8 @@ public:
                     Json::Value p;
                     p["Paths"] = path[jss::paths_computed];
                     STParsedJSONObject po("generic", p);
+
+                    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                     paths = po.object->getFieldPathSet(sfPaths);
                 }
             }
diff --git a/src/test/app/PayChan_test.cpp b/src/test/app/PayChan_test.cpp
index b217bb3687..ba79eb037d 100644
--- a/src/test/app/PayChan_test.cpp
+++ b/src/test/app/PayChan_test.cpp
@@ -401,18 +401,23 @@ struct PayChan_test : public beast::unit_test::suite
         // Owner closes, will close after settleDelay
         env(claim(alice, chan), txflags(tfClose));
         auto counts = [](auto const& t) { return t.time_since_epoch().count(); };
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration));
         // increase the expiration time
         env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration + 100s}));
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 100);
         // decrease the expiration, but still above minExpiration
         env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration + 50s}));
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
         // decrease the expiration below minExpiration
         env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration - 50s}),
             ter(temBAD_EXPIRATION));
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
         env(claim(bob, chan), txflags(tfRenew), ter(tecNO_PERMISSION));
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
         env(claim(alice, chan), txflags(tfRenew));
         BEAST_EXPECT(!channelExpiration(*env.current(), chan));
diff --git a/src/test/app/PayStrand_test.cpp b/src/test/app/PayStrand_test.cpp
index 2cc2a188c3..8c2ae698d0 100644
--- a/src/test/app/PayStrand_test.cpp
+++ b/src/test/app/PayStrand_test.cpp
@@ -10,7 +10,7 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/tx/paths/RippleCalc.h>
 #include <xrpl/tx/paths/detail/Steps.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
 
 #include <optional>
 
@@ -262,7 +262,7 @@ public:
             if (has(SB::sameAccIss))
                 return acc;
             if (has(SB::existingIss) && existingIss)
-                return *existingIss;
+                return existingIss;
             return issF().id();
         }();
         auto const cur = [&]() -> std::optional<Currency> {
@@ -271,7 +271,7 @@ public:
             if (has(SB::xrp))
                 return xrpCurrency();
             if (has(SB::existingCur) && existingCur)
-                return *existingCur;
+                return existingCur;
             return currencyF();
         }();
         if (!has(SB::boundary))
diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp
index 8ecc66911c..2817bc0502 100644
--- a/src/test/app/PermissionedDEX_test.cpp
+++ b/src/test/app/PermissionedDEX_test.cpp
@@ -16,7 +16,7 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
+#include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
 
 #include <atomic>
 #include <cstdint>
@@ -143,7 +143,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
         do
         {
-            auto const page = env.le(keylet::page(directory, *pageIndex));
+            auto const page = env.le(
+                keylet::page(directory, *pageIndex));  // NOLINT(bugprone-unchecked-optional-access)
             if (!page)
                 break;
 
@@ -524,7 +525,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
             auto const regularDirKey = getDefaultOfferDirKey(env, bob, regularOfferSeq);
             BEAST_EXPECT(regularDirKey);
-            BEAST_EXPECT(checkDirectorySize(env, *regularDirKey, 1));
+            BEAST_EXPECT(checkDirectorySize(
+                env, *regularDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
 
             // a domain payment cannot consume regular offers
             env(pay(alice, carol, USD(10)),
@@ -543,7 +545,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
             auto const domainDirKey = getDefaultOfferDirKey(env, bob, domainOfferSeq);
             BEAST_EXPECT(domainDirKey);
-            BEAST_EXPECT(checkDirectorySize(env, *domainDirKey, 1));
+            BEAST_EXPECT(checkDirectorySize(
+                env, *domainDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
 
             // cross-currency permissioned payment consumed
             // domain offer instead of regular offer
@@ -553,8 +556,10 @@ class PermissionedDEX_test : public beast::unit_test::suite
             BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
 
             // domain directory is empty
-            BEAST_EXPECT(checkDirectorySize(env, *domainDirKey, 0));
-            BEAST_EXPECT(checkDirectorySize(env, *regularDirKey, 1));
+            BEAST_EXPECT(checkDirectorySize(
+                env, *domainDirKey, 0));  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(checkDirectorySize(
+                env, *regularDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         // test domain payment consuming two offers in the path
@@ -889,7 +894,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
         auto const domainDirKey = getDefaultOfferDirKey(env, bob, bobOfferSeq);
         BEAST_EXPECT(domainDirKey);
-        BEAST_EXPECT(checkDirectorySize(env, *domainDirKey, 2));
+        BEAST_EXPECT(checkDirectorySize(
+            env, *domainDirKey, 2));  // NOLINT(bugprone-unchecked-optional-access)
 
         // remove alice from domain and thus alice's offer becomes unfunded
         env(credentials::deleteCred(domainOwner, alice, domainOwner, credType));
@@ -902,7 +908,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
         // alice's unfunded offer is removed implicitly
         BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
-        BEAST_EXPECT(checkDirectorySize(env, *domainDirKey, 1));
+        BEAST_EXPECT(checkDirectorySize(
+            env, *domainDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
     }
 
     void
diff --git a/src/test/app/PermissionedDomains_test.cpp b/src/test/app/PermissionedDomains_test.cpp
index 39ce85d23d..d2a14ce82a 100644
--- a/src/test/app/PermissionedDomains_test.cpp
+++ b/src/test/app/PermissionedDomains_test.cpp
@@ -2,7 +2,7 @@
 
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
+#include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
 
 #include <exception>
 #include <map>
diff --git a/src/test/app/Regression_test.cpp b/src/test/app/Regression_test.cpp
index e323e61132..9cc5ab53ed 100644
--- a/src/test/app/Regression_test.cpp
+++ b/src/test/app/Regression_test.cpp
@@ -270,7 +270,7 @@ struct Regression_test : public beast::unit_test::suite
             if (BEAST_EXPECT(bob_index.isNonZero()) && BEAST_EXPECT(digest.has_value()))
             {
                 auto& cache = env.app().cachedSLEs();
-                cache.del(*digest, false);
+                cache.del(*digest, false);  // NOLINT(bugprone-unchecked-optional-access)
                 auto const beforeCounts = mapCounts(CountedObjects::getInstance().getCounts(0));
 
                 env(check::cash(alice, bob_index, check::DeliverMin(XRP(100))), ter(tecNO_ENTRY));
diff --git a/src/test/app/TheoreticalQuality_test.cpp b/src/test/app/TheoreticalQuality_test.cpp
index 9b6d86dd5f..ad3b0a8d2d 100644
--- a/src/test/app/TheoreticalQuality_test.cpp
+++ b/src/test/app/TheoreticalQuality_test.cpp
@@ -9,7 +9,7 @@
 #include <xrpl/tx/paths/Flow.h>
 #include <xrpl/tx/paths/detail/Steps.h>
 #include <xrpl/tx/paths/detail/StrandFlow.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
 
 namespace xrpl {
 namespace test {
@@ -25,7 +25,9 @@ struct RippleCalcTestParams
     STPathSet paths;
 
     explicit RippleCalcTestParams(Json::Value const& jv)
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         : srcAccount{*parseBase58<AccountID>(jv[jss::Account].asString())}
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         , dstAccount{*parseBase58<AccountID>(jv[jss::Destination].asString())}
         , dstAmt{amountFromJson(sfAmount, jv[jss::Amount])}
     {
@@ -45,6 +47,7 @@ struct RippleCalcTestParams
                     {
                         assert(!pe.isMember(jss::currency) && !pe.isMember(jss::issuer));
                         p.emplace_back(
+                            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                             *parseBase58<AccountID>(pe[jss::account].asString()),
                             std::nullopt,
                             std::nullopt);
@@ -54,6 +57,7 @@ struct RippleCalcTestParams
                         auto const currency = to_currency(pe[jss::currency].asString());
                         std::optional<AccountID> issuer;
                         if (!isXRP(currency))
+                            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                             issuer = *parseBase58<AccountID>(pe[jss::issuer].asString());
                         else
                             assert(isXRP(*parseBase58<AccountID>(pe[jss::issuer].asString())));
@@ -255,7 +259,8 @@ class TheoreticalQuality_test : public beast::unit_test::suite
 
         for (auto const& strand : sr.second)
         {
-            Quality const theoreticalQ = *qualityUpperBound(sb, strand);
+            Quality const theoreticalQ =
+                *qualityUpperBound(sb, strand);  // NOLINT(bugprone-unchecked-optional-access)
             auto const f =
                 flow<IOUAmount, IOUAmount>(sb, strand, IOUAmount(10, 0), IOUAmount(5, 0), dummyJ);
             BEAST_EXPECT(f.success);
@@ -488,7 +493,7 @@ public:
                 return std::nullopt;
             try
             {
-                std::size_t pos;
+                std::size_t pos = 0;
                 auto const r = stoi(s, &pos);
                 if (pos != s.size())
                     return std::nullopt;
diff --git a/src/test/app/TxQ_test.cpp b/src/test/app/TxQ_test.cpp
index 94db50842a..fa1af526b6 100644
--- a/src/test/app/TxQ_test.cpp
+++ b/src/test/app/TxQ_test.cpp
@@ -722,6 +722,7 @@ public:
             auto aliceStat = txQ.getAccountTxs(alice.id());
             BEAST_EXPECT(aliceStat.size() == 1);
             BEAST_EXPECT(aliceStat.begin()->feeLevel == baseFeeLevel);
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(aliceStat.begin()->lastValid && *aliceStat.begin()->lastValid == 8);
             BEAST_EXPECT(!aliceStat.begin()->consequences.isBlocker());
 
diff --git a/src/test/app/ValidatorKeys_test.cpp b/src/test/app/ValidatorKeys_test.cpp
index 32f6305a37..9efe318662 100644
--- a/src/test/app/ValidatorKeys_test.cpp
+++ b/src/test/app/ValidatorKeys_test.cpp
@@ -1,4 +1,5 @@
 #include <test/jtx/Env.h>
+#include <test/unit_test/utils.h>
 
 #include <xrpld/app/misc/ValidatorKeys.h>
 #include <xrpld/core/Config.h>
@@ -22,19 +23,15 @@ class ValidatorKeys_test : public beast::unit_test::suite
     std::string const tokenSecretStr = "paQmjZ37pKKPMrgadBLsuf9ab7Y7EUNzh27LQrZqoexpAs31nJi";
 
     std::vector<std::string> const tokenBlob = {
-        "    "
-        "eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT\n",
-        " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFuaWZl "
-        "    \n",
-        "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZDeE"
-        "\n",
-        "\t "
-        "hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4U0tG\t  "
-        "\t\n",
+        "    eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT\n",
+        " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFuaWZl     \n",
+        "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZDeE\n",
+        "\t hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4U0tG\t  \t\n",
         "bjdNTzJmZGtjd1JRSWhBT25ndTlzQUtxWFlvdUorbDJWMFcrc0FPa1ZCK1pSUzZQU2\n",
         "hsSkFmVXNYZkFpQnNWSkdlc2FhZE9KYy9hQVpva1MxdnltR21WcmxIUEtXWDNZeXd1\n",
         "NmluOEhBU1FLUHVnQkQ2N2tNYVJGR3ZtcEFUSGxHS0pkdkRGbFdQWXk1QXFEZWRGdj\n",
-        "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0ifQ==\n"};
+        "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0ifQ==\n",
+    };
 
     std::string const tokenManifest =
         "JAAAAAFxIe1FtwmimvGtH2iCcMJqC9gVFKilGfw1/vCxHXXLplc2GnMhAkE1agqXxBwD"
@@ -52,7 +49,8 @@ class ValidatorKeys_test : public beast::unit_test::suite
         "NWF6dTJMVHlqL1pjQkpBbitmNGhtQTQ0U0tYbGtTTUFqak1rSWRyR1Rxa21SNjBzVG\n",
         "JaTjZOOUYwdk9UV3VYcUZ6eDFoSGIyL0RqWElVZXhDVGlITEcxTG9UdUp1eXdXbk55\n",
         "RFE9PSIsInZhbGlkYXRpb25fc2VjcmV0X2tleSI6IjkyRDhCNDBGMzYwMTc5MTkwMU\n",
-        "MzQTUzMzI3NzBDMkUwMTA4MDI0NTZFOEM2QkI0NEQ0N0FFREQ0NzJGMDQ2RkYifQ==\n"};
+        "MzQTUzMzI3NzBDMkUwMTA4MDI0NTZFOEM2QkI0NEQ0N0FFREQ0NzJGMDQ2RkYifQ==\n",
+    };
 
 public:
     void
@@ -65,17 +63,21 @@ public:
 
         // Keys/ID when using [validation_seed]
         SecretKey const seedSecretKey =
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             generateSecretKey(KeyType::secp256k1, *parseBase58<Seed>(seed));
         PublicKey const seedPublicKey = derivePublicKey(KeyType::secp256k1, seedSecretKey);
         NodeID const seedNodeID = calcNodeID(seedPublicKey);
 
         // Keys when using [validation_token]
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const tokenSecretKey = *parseBase58<SecretKey>(TokenType::NodePrivate, tokenSecretStr);
 
         auto const tokenPublicKey = derivePublicKey(KeyType::secp256k1, tokenSecretKey);
 
         auto const m = deserializeManifest(base64_decode(tokenManifest));
         BEAST_EXPECT(m);
+
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         NodeID const tokenNodeID = calcNodeID(m->masterKey);
 
         {
@@ -92,10 +94,10 @@ public:
             c.section(SECTION_VALIDATION_SEED).append(seed);
 
             ValidatorKeys k{c, journal};
-            if (BEAST_EXPECT(k.keys))
+            if (BEAST_EXPECT(k.keys); k.keys.has_value())
             {
                 BEAST_EXPECT(k.keys->publicKey == seedPublicKey);
-                BEAST_EXPECT(k.keys->secretKey == seedSecretKey);
+                BEAST_EXPECT(test::equal(k.keys->secretKey, seedSecretKey));
             }
             BEAST_EXPECT(k.nodeID == seedNodeID);
             BEAST_EXPECT(k.manifest.empty());
@@ -119,10 +121,10 @@ public:
             c.section(SECTION_VALIDATOR_TOKEN).append(tokenBlob);
             ValidatorKeys k{c, journal};
 
-            if (BEAST_EXPECT(k.keys))
+            if (BEAST_EXPECT(k.keys); k.keys.has_value())
             {
                 BEAST_EXPECT(k.keys->publicKey == tokenPublicKey);
-                BEAST_EXPECT(k.keys->secretKey == tokenSecretKey);
+                BEAST_EXPECT(test::equal(k.keys->secretKey, tokenSecretKey));
             }
             BEAST_EXPECT(k.nodeID == tokenNodeID);
             BEAST_EXPECT(k.manifest == tokenManifest);
diff --git a/src/test/app/ValidatorList_test.cpp b/src/test/app/ValidatorList_test.cpp
index 61d71b1883..679fad800f 100644
--- a/src/test/app/ValidatorList_test.cpp
+++ b/src/test/app/ValidatorList_test.cpp
@@ -56,9 +56,11 @@ private:
         if (seq != std::numeric_limits<std::uint32_t>::max())
         {
             st[sfSigningPubKey] = spk;
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             sign(st, HashPrefix::manifest, *publicKeyType(spk), ssk);
         }
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         sign(st, HashPrefix::manifest, *publicKeyType(pk), sk, sfMasterSignature);
 
         Serializer s;
@@ -74,6 +76,7 @@ private:
         st[sfSequence] = std::numeric_limits<std::uint32_t>::max();
         st[sfPublicKey] = pk;
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         sign(st, HashPrefix::manifest, *publicKeyType(pk), sk, sfMasterSignature);
 
         Serializer s;
@@ -242,6 +245,7 @@ private:
                 trustedKeys->load(localSigningPublicOuter, emptyCfgKeys, emptyCfgPublishers));
             BEAST_EXPECT(trustedKeys->listed(localSigningPublicOuter));
 
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             manifests.applyManifest(*deserializeManifest(cfgManifest));
             BEAST_EXPECT(
                 trustedKeys->load(localSigningPublicOuter, emptyCfgKeys, emptyCfgPublishers));
@@ -297,9 +301,9 @@ private:
             auto const localSigningPublic =
                 parseBase58<PublicKey>(TokenType::NodePublic, cfgKeys.front());
 
-            BEAST_EXPECT(trustedKeys->load(*localSigningPublic, cfgKeys, emptyCfgPublishers));
-
+            BEAST_EXPECT(trustedKeys->load(localSigningPublic, cfgKeys, emptyCfgPublishers));
             BEAST_EXPECT(trustedKeys->localPublicKey() == localSigningPublic);
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(trustedKeys->listed(*localSigningPublic));
             for (auto const& n : configList)
                 BEAST_EXPECT(trustedKeys->listed(n));
@@ -332,6 +336,7 @@ private:
                 app.config().legacy("database_path"),
                 env.journal);
 
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             manifests.applyManifest(*deserializeManifest(cfgManifest));
 
             BEAST_EXPECT(trustedKeys->load(localSigningPublicOuter, cfgKeys, emptyCfgPublishers));
@@ -414,6 +419,7 @@ private:
             auto const pubRevokedSigning = randomKeyPair(KeyType::secp256k1);
             // make this manifest revoked (seq num = max)
             //  -- thus should not be loaded
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             pubManifests.applyManifest(*deserializeManifest(makeManifestString(
                 pubRevokedPublic,
                 pubRevokedSecret,
@@ -452,6 +458,7 @@ private:
             auto const pubRevokedSigning = randomKeyPair(KeyType::secp256k1);
             // make this manifest revoked (seq num = max)
             //  -- thus should not be loaded
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             pubManifests.applyManifest(*deserializeManifest(makeManifestString(
                 pubRevokedPublic,
                 pubRevokedSecret,
@@ -950,6 +957,7 @@ private:
             auto const available = trustedKeys->getAvailable(hexPublic, 0);
             if (BEAST_EXPECT(available))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 auto const& a = *available;
                 BEAST_EXPECT(!a);
             }
@@ -959,6 +967,7 @@ private:
             auto const available = trustedKeys->getAvailable(hexPublic, 3);
             if (BEAST_EXPECT(available))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 auto const& a = *available;
                 BEAST_EXPECT(!a);
             }
@@ -968,6 +977,7 @@ private:
             auto const available = trustedKeys->getAvailable(hexPublic, 1);
             if (BEAST_EXPECT(available))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 auto const& a = *available;
                 BEAST_EXPECT(a[jss::public_key] == hexPublic);
                 BEAST_EXPECT(a[jss::manifest] == manifest);
@@ -984,6 +994,7 @@ private:
             auto const available = trustedKeys->getAvailable(hexPublic, 2);
             if (BEAST_EXPECT(available))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 auto const& a = *available;
                 BEAST_EXPECT(a[jss::public_key] == hexPublic);
                 BEAST_EXPECT(a[jss::manifest] == manifest);
@@ -1110,6 +1121,7 @@ private:
                 masterPublic, masterPrivate, signingPublic1, signingKeys1.second, 1));
 
             BEAST_EXPECT(
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 manifestsOuter.applyManifest(std::move(*m1)) == ManifestDisposition::accepted);
             BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
             BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
@@ -1123,6 +1135,7 @@ private:
             auto m2 = deserializeManifest(makeManifestString(
                 masterPublic, masterPrivate, signingPublic2, signingKeys2.second, 2));
             BEAST_EXPECT(
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 manifestsOuter.applyManifest(std::move(*m2)) == ManifestDisposition::accepted);
             BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
             BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
@@ -1137,9 +1150,12 @@ private:
             activeValidatorsOuter.emplace(calcNodeID(signingPublicMax));
             auto mMax = deserializeManifest(makeRevocationString(masterPublic, masterPrivate));
 
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(mMax->revoked());
             BEAST_EXPECT(
                 manifestsOuter.applyManifest(std::move(*mMax)) == ManifestDisposition::accepted);
+            // NOLINTEND(bugprone-unchecked-optional-access)
+
             BEAST_EXPECT(manifestsOuter.getSigningKey(masterPublic) == masterPublic);
             BEAST_EXPECT(manifestsOuter.revoked(masterPublic));
 
@@ -2355,12 +2371,14 @@ private:
             if (BEAST_EXPECT(msg))
             {
                 BEAST_EXPECT(msg->version() == 1);
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(msg->manifest() == *expected.manifest);
                 BEAST_EXPECT(msg->blob() == expected.blob);
                 BEAST_EXPECT(msg->signature() == expected.signature);
             }
             BEAST_EXPECT(
                 messageWithHash.hash ==
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 sha512Half(*expected.manifest, expected.blob, expected.signature, 1));
         }
 
diff --git a/src/test/app/ValidatorSite_test.cpp b/src/test/app/ValidatorSite_test.cpp
index 5fc290eda5..eaae4c278e 100644
--- a/src/test/app/ValidatorSite_test.cpp
+++ b/src/test/app/ValidatorSite_test.cpp
@@ -155,7 +155,7 @@ private:
             std::vector<Validator> list;
             std::string uri;
             FetchListConfig const& cfg;
-            bool isRetry;
+            bool isRetry{};
         };
         std::vector<publisher> servers;
 
diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp
index 93ac94d7ce..5a5292b06c 100644
--- a/src/test/app/Vault_test.cpp
+++ b/src/test/app/Vault_test.cpp
@@ -3,7 +3,6 @@
 #include <test/jtx/Env.h>
 #include <test/jtx/amount.h>
 #include <test/jtx/mpt.h>
-#include <test/jtx/testline.h>
 
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/unit_test/suite.h>
@@ -2623,13 +2622,13 @@ class Vault_test : public beast::unit_test::suite
 
                 // Turn on noripple on the pseudo account's trust line.
                 // Charlie's is already set.
-                env(trust(issuer, vaultAccount(keylet)["IOU"], tfSetNoRipple), THISLINE);
+                env(trust(issuer, vaultAccount(keylet)["IOU"], tfSetNoRipple));
 
                 {
                     // Charlie cannot deposit
                     auto tx = vault.deposit(
                         {.depositor = charlie, .id = keylet.key, .amount = asset(100)});
-                    env(tx, ter{terNO_RIPPLE}, THISLINE);
+                    env(tx, ter{terNO_RIPPLE});
                     env.close();
                 }
 
@@ -2637,14 +2636,14 @@ class Vault_test : public beast::unit_test::suite
                     PrettyAsset shares = issuanceId(keylet);
                     auto tx1 =
                         vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)});
-                    env(tx1, THISLINE);
+                    env(tx1);
                     env.close();
 
                     // Charlie cannot receive funds
                     auto tx2 = vault.withdraw(
                         {.depositor = owner, .id = keylet.key, .amount = shares(100)});
                     tx2[sfDestination] = charlie.human();
-                    env(tx2, ter{terNO_RIPPLE}, THISLINE);
+                    env(tx2, ter{terNO_RIPPLE});
                     env.close();
 
                     {
@@ -2657,7 +2656,7 @@ class Vault_test : public beast::unit_test::suite
                         env(tx);
                         env.close();
                     }
-                    env(pay(owner, charlie, shares(100)), THISLINE);
+                    env(pay(owner, charlie, shares(100)));
                     env.close();
 
                     // Charlie cannot withdraw
@@ -2666,16 +2665,16 @@ class Vault_test : public beast::unit_test::suite
                     env(tx3, ter{terNO_RIPPLE});
                     env.close();
 
-                    env(pay(charlie, owner, shares(100)), THISLINE);
+                    env(pay(charlie, owner, shares(100)));
                     env.close();
                 }
 
                 tx = vault.withdraw({.depositor = owner, .id = keylet.key, .amount = asset(100)});
-                env(tx, THISLINE);
+                env(tx);
                 env.close();
 
                 // Delete vault with zero balance
-                env(vault.del({.owner = owner, .id = keylet.key}), THISLINE);
+                env(vault.del({.owner = owner, .id = keylet.key}));
             },
             {.charlieRipple = false});
 
@@ -3349,7 +3348,7 @@ class Vault_test : public beast::unit_test::suite
             MPTIssue shares(issuanceId);
             env.memoize(vaultAccount);
 
-            auto const peek = [=, &env, this](std::function<bool(SLE&, SLE&)> fn) -> bool {
+            auto const peek = [keylet, &env, this](std::function<bool(SLE&, SLE&)> fn) -> bool {
                 return env.app().openLedger().modify([&](OpenView& view, beast::Journal j) -> bool {
                     Sandbox sb(&view, tapNONE);
                     auto vault = sb.peek(keylet::vault(keylet.key));
@@ -4500,131 +4499,6 @@ class Vault_test : public beast::unit_test::suite
         }
     }
 
-    void
-    testDelegate()
-    {
-        using namespace test::jtx;
-
-        Env env(*this, testable_amendments());
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
-
-        struct CaseArgs
-        {
-            PrettyAsset asset = xrpIssue();
-        };
-
-        auto const xrpBalance = [this](
-                                    Env const& env, Account const& account) -> std::optional<long> {
-            auto sle = env.le(keylet::account(account.id()));
-            if (BEAST_EXPECT(sle != nullptr))
-                return sle->getFieldAmount(sfBalance).xrp().drops();
-            return std::nullopt;
-        };
-
-        auto testCase = [&, this](auto test, CaseArgs args = {}) {
-            Env env{*this, testable_amendments() | featureSingleAssetVault};
-
-            Vault vault{env};
-
-            // use different initial amount to distinguish the source balance
-            env.fund(XRP(10000), alice);
-            env.fund(XRP(20000), bob);
-            env.fund(XRP(30000), carol);
-            env.close();
-
-            env(delegate::set(
-                carol,
-                alice,
-                {"Payment",
-                 "VaultCreate",
-                 "VaultSet",
-                 "VaultDelete",
-                 "VaultDeposit",
-                 "VaultWithdraw",
-                 "VaultClawback"}));
-
-            test(env, vault, args.asset);
-        };
-
-        testCase([&, this](Env& env, Vault& vault, PrettyAsset const& asset) {
-            testcase("delegated vault creation");
-            auto startBalance = xrpBalance(env, carol);
-            if (!BEAST_EXPECT(startBalance.has_value()))
-                return;
-
-            auto [tx, keylet] = vault.create({.owner = carol, .asset = asset});
-            env(tx, delegate::as(alice));
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance);
-        });
-
-        testCase([&, this](Env& env, Vault& vault, PrettyAsset const& asset) {
-            testcase("delegated deposit and withdrawal");
-            auto [tx, keylet] = vault.create({.owner = carol, .asset = asset});
-            env(tx);
-            env.close();
-
-            auto const amount = 1513;
-            auto const baseFee = env.current()->fees().base;
-
-            auto startBalance = xrpBalance(env, carol);
-            if (!BEAST_EXPECT(startBalance.has_value()))
-                return;
-
-            tx = vault.deposit({.depositor = carol, .id = keylet.key, .amount = asset(amount)});
-            env(tx, delegate::as(alice));
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - amount);
-
-            tx =
-                vault.withdraw({.depositor = carol, .id = keylet.key, .amount = asset(amount - 1)});
-            env(tx, delegate::as(alice));
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - 1);
-
-            tx = vault.withdraw({.depositor = carol, .id = keylet.key, .amount = asset(1)});
-            env(tx);
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - baseFee);
-        });
-
-        testCase([&, this](Env& env, Vault& vault, PrettyAsset const& asset) {
-            testcase("delegated withdrawal same as base fee and deletion");
-            auto [tx, keylet] = vault.create({.owner = carol, .asset = asset});
-            env(tx);
-            env.close();
-
-            auto const amount = 25537;
-            auto const baseFee = env.current()->fees().base;
-
-            auto startBalance = xrpBalance(env, carol);
-            if (!BEAST_EXPECT(startBalance.has_value()))
-                return;
-
-            tx = vault.deposit({.depositor = carol, .id = keylet.key, .amount = asset(amount)});
-            env(tx);
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - amount - baseFee);
-
-            tx = vault.withdraw({.depositor = carol, .id = keylet.key, .amount = asset(baseFee)});
-            env(tx, delegate::as(alice));
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - amount);
-
-            tx = vault.withdraw(
-                {.depositor = carol, .id = keylet.key, .amount = asset(amount - baseFee)});
-            env(tx, delegate::as(alice));
-            env.close();
-            BEAST_EXPECT(xrpBalance(env, carol) == *startBalance - baseFee);
-
-            tx = vault.del({.owner = carol, .id = keylet.key});
-            env(tx, delegate::as(alice));
-            env.close();
-        });
-    }
-
     void
     testVaultClawbackBurnShares()
     {
@@ -4656,7 +4530,7 @@ class Vault_test : public beast::unit_test::suite
             Vault vault{env};
 
             auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
-            env(tx, ter(tesSUCCESS), THISLINE);
+            env(tx, ter(tesSUCCESS));
             env.close();
 
             auto const& vaultSle = env.le(vaultKeylet);
@@ -4666,8 +4540,7 @@ class Vault_test : public beast::unit_test::suite
 
             env(vault.deposit(
                     {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
-                ter(tesSUCCESS),
-                THISLINE);
+                ter(tesSUCCESS));
             env.close();
 
             auto const& [availablePreDefault, totalPreDefault] = vaultAssetBalance(vaultKeylet);
@@ -4680,14 +4553,13 @@ class Vault_test : public beast::unit_test::suite
                      .id = vaultKeylet.key,
                      .holder = depositor,
                      .amount = share(0).value()}),
-                ter(tecNO_PERMISSION),
-                THISLINE);
+                ter(tecNO_PERMISSION));
             env.close();
 
             auto const& sharesAvailable = vaultShareBalance(vaultKeylet);
             auto const& brokerKeylet = keylet::loanbroker(owner.id(), env.seq(owner));
 
-            env(set(owner, vaultKeylet.key), THISLINE);
+            env(set(owner, vaultKeylet.key));
             env.close();
 
             auto const& loanKeylet = keylet::loan(brokerKeylet.key, 1);
@@ -4700,8 +4572,7 @@ class Vault_test : public beast::unit_test::suite
                 paymentTotal(10),
                 sig(sfCounterpartySignature, owner),
                 fee(env.current()->fees().base * 2),
-                ter(tesSUCCESS),
-                THISLINE);
+                ter(tesSUCCESS));
             env.close();
 
             // attempt to clawback shares while there assetsAvailable == 0 and
@@ -4711,13 +4582,12 @@ class Vault_test : public beast::unit_test::suite
                      .id = vaultKeylet.key,
                      .holder = depositor,
                      .amount = share(0).value()}),
-                ter(tecNO_PERMISSION),
-                THISLINE);
+                ter(tecNO_PERMISSION));
             env.close();
 
             env.close(std::chrono::seconds{120 + 60});
 
-            env(manage(owner, loanKeylet.key, tfLoanDefault), ter(tesSUCCESS), THISLINE);
+            env(manage(owner, loanKeylet.key, tfLoanDefault), ter(tesSUCCESS));
 
             auto const& [availablePostDefault, totalPostDefault] = vaultAssetBalance(vaultKeylet);
 
@@ -4746,8 +4616,7 @@ class Vault_test : public beast::unit_test::suite
                     // empty
                     asset.native()                              ? ter(temMALFORMED)
                         : asset.raw().getIssuer() != owner.id() ? ter(tecNO_PERMISSION)
-                                                                : ter(tecPRECISION_LOSS),
-                    THISLINE);
+                                                                : ter(tecPRECISION_LOSS));
                 env.close();
             }
 
@@ -4766,8 +4635,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = share(1).value(),
                     }),
-                    ter(tecLIMIT_EXCEEDED),
-                    THISLINE);
+                    ter(tecLIMIT_EXCEEDED));
                 env.close();
             }
 
@@ -4783,8 +4651,7 @@ class Vault_test : public beast::unit_test::suite
                     }),
                     // when owner is issuer implicit clawback fails
                     asset.native() || asset.raw().getIssuer() != owner.id() ? ter(tesSUCCESS)
-                                                                            : ter(tecWRONG_ASSET),
-                    THISLINE);
+                                                                            : ter(tecWRONG_ASSET));
                 env.close();
             }
 
@@ -4804,8 +4671,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = share(vaultShareBalance(vaultKeylet)).value(),
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
                 env.close();
             }
             {
@@ -4822,8 +4688,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = owner,
                         .amount = share(vaultShareBalance(vaultKeylet)).value(),
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
                 env.close();
             }
 
@@ -4840,8 +4705,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = owner,
                         .amount = share(vaultShareBalance(vaultKeylet)).value(),
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
 
                 // Now the vault is empty, clawback again fails
                 env(vault.clawback({
@@ -4849,8 +4713,7 @@ class Vault_test : public beast::unit_test::suite
                         .id = vaultKeylet.key,
                         .holder = owner,
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
                 env.close();
             }
         };
@@ -4908,15 +4771,14 @@ class Vault_test : public beast::unit_test::suite
             Vault vault{env};
 
             auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
-            env(tx, ter(tesSUCCESS), THISLINE);
+            env(tx, ter(tesSUCCESS));
             env.close();
 
             auto const& vaultSle = env.le(vaultKeylet);
             BEAST_EXPECT(vaultSle != nullptr);
             env(vault.deposit(
                     {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
-                ter(tesSUCCESS),
-                THISLINE);
+                ter(tesSUCCESS));
             env.close();
 
             return std::make_pair(vault, vaultKeylet);
@@ -4939,16 +4801,14 @@ class Vault_test : public beast::unit_test::suite
                         .holder = issuer,
                         .amount = asset(1).value(),
                     }),
-                    ter(temMALFORMED),
-                    THISLINE);
+                    ter(temMALFORMED));
                 // When asset is implicit, clawback fails as no permission.
                 env(vault.clawback({
                         .issuer = issuer,
                         .id = vaultKeylet.key,
                         .holder = issuer,
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
                 return;
             }
 
@@ -4965,8 +4825,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = asset2(1).value(),
                     }),
-                    ter(tecWRONG_ASSET),
-                    THISLINE);
+                    ter(tecWRONG_ASSET));
             }
 
             {
@@ -4979,8 +4838,7 @@ class Vault_test : public beast::unit_test::suite
                         .id = vaultKeylet.key,
                         .holder = issuer,
                     }),
-                    ter(tecWRONG_ASSET),
-                    THISLINE);
+                    ter(tecWRONG_ASSET));
             }
 
             {
@@ -4992,8 +4850,7 @@ class Vault_test : public beast::unit_test::suite
                         .id = vaultKeylet.key,
                         .holder = depositor,
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
 
                 env(vault.clawback({
                         .issuer = owner,
@@ -5001,8 +4858,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = asset(1).value(),
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
             }
 
             {
@@ -5013,8 +4869,7 @@ class Vault_test : public beast::unit_test::suite
                         .id = vaultKeylet.key,
                         .holder = issuer,
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
             }
 
             {
@@ -5032,8 +4887,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = share(1).value(),
                     }),
-                    ter(tecNO_PERMISSION),
-                    THISLINE);
+                    ter(tecNO_PERMISSION));
             }
 
             {
@@ -5048,8 +4902,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = asset(1).value(),
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
             }
 
             {
@@ -5063,8 +4916,7 @@ class Vault_test : public beast::unit_test::suite
                         .holder = depositor,
                         .amount = asset(100).value(),
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
             }
 
             {
@@ -5078,8 +4930,7 @@ class Vault_test : public beast::unit_test::suite
                         .id = vaultKeylet.key,
                         .holder = depositor,
                     }),
-                    ter(tesSUCCESS),
-                    THISLINE);
+                    ter(tesSUCCESS));
             }
         };
 
@@ -5154,19 +5005,19 @@ class Vault_test : public beast::unit_test::suite
             tx[sfData] = "4D65746144617461";
 
             tx[sfAssetsMaximum] = maxInt64;
-            env(tx, ter(tefEXCEPTION), THISLINE);
+            env(tx, ter(tefEXCEPTION));
             env.close();
 
             tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
+            env(tx, ter(tefEXCEPTION));
             env.close();
 
             tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
+            env(tx, ter(tefEXCEPTION));
             env.close();
 
             // This value will be rounded
@@ -5176,7 +5027,7 @@ class Vault_test : public beast::unit_test::suite
             BEAST_EXPECT(decimalTest == "9223372036854775.808");
             tx[sfAssetsMaximum] = decimalTest;
             auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             auto const vaultSle = env.le(newKeylet);
@@ -5199,26 +5050,26 @@ class Vault_test : public beast::unit_test::suite
                 return mptAsset;
             }();
 
-            env(pay(issuer, owner, mptAsset(100'000)), THISLINE);
+            env(pay(issuer, owner, mptAsset(100'000)));
             env.close();
 
             auto [tx, keylet] = vault.create({.owner = owner, .asset = mptAsset});
             tx[sfData] = "4D65746144617461";
 
             tx[sfAssetsMaximum] = maxInt64;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, ter(tefEXCEPTION), THISLINE);
+            env(tx, ter(tefEXCEPTION));
             env.close();
 
             // This value will be rounded
@@ -5228,7 +5079,7 @@ class Vault_test : public beast::unit_test::suite
             BEAST_EXPECT(decimalTest == "922337203685477580.8");
             tx[sfAssetsMaximum] = decimalTest;
             auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             auto const vaultSle = env.le(newKeylet);
@@ -5251,19 +5102,19 @@ class Vault_test : public beast::unit_test::suite
             tx[sfData] = "4D65746144617461";
 
             tx[sfAssetsMaximum] = maxInt64;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = initialXRPPlus1;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = initialXRP;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = maxInt64Plus1;
-            env(tx, THISLINE);
+            env(tx);
             env.close();
 
             tx[sfAssetsMaximum] = "1000000000000000e80";
@@ -5280,7 +5131,7 @@ class Vault_test : public beast::unit_test::suite
                 BEAST_EXPECT(decimalTest == "922337203685477580.8");
                 tx[sfAssetsMaximum] = decimalTest;
                 auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
+                env(tx);
                 env.close();
 
                 auto const vaultSle = env.le(newKeylet);
@@ -5294,7 +5145,7 @@ class Vault_test : public beast::unit_test::suite
             {
                 tx[sfAssetsMaximum] = "9223372036854775807e40";  // max int64 * 10^40
                 auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
+                env(tx);
                 env.close();
 
                 auto const vaultSle = env.le(newKeylet);
@@ -5308,7 +5159,7 @@ class Vault_test : public beast::unit_test::suite
             {
                 tx[sfAssetsMaximum] = "9223372036854775807e-40";  // max int64 * 10^-40
                 auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
+                env(tx);
                 env.close();
 
                 auto const vaultSle = env.le(newKeylet);
@@ -5322,7 +5173,7 @@ class Vault_test : public beast::unit_test::suite
             {
                 tx[sfAssetsMaximum] = "9223372036854775807e-100";  // max int64 * 10^-100
                 auto const newKeylet = keylet::vault(owner.id(), env.seq(owner));
-                env(tx, THISLINE);
+                env(tx);
                 env.close();
 
                 // Field 'AssetsMaximum' may not be explicitly set to default.
@@ -5336,24 +5187,24 @@ class Vault_test : public beast::unit_test::suite
             // What _can't_ IOUs do?
             // 1. Exceed maximum exponent / offset
             tx[sfAssetsMaximum] = "1000000000000000e81";
-            env(tx, ter(tefEXCEPTION), THISLINE);
+            env(tx, ter(tefEXCEPTION));
             env.close();
 
             // 2. Mantissa larger than uint64 max
+            env.set_parse_failure_expected(true);
             try
             {
                 tx[sfAssetsMaximum] = "18446744073709551617e5";  // uint64 max + 1
-                env(tx, THISLINE);
-                BEAST_EXPECT(false);
+                env(tx);
+                BEAST_EXPECTS(false, "Expected parse_error for mantissa larger than uint64 max");
             }
             catch (parse_error const& e)
             {
                 using namespace std::string_literals;
                 BEAST_EXPECT(
-                    e.what() ==
-                    "invalidParamsField 'tx_json.AssetsMaximum' has invalid "
-                    "data."s);
+                    e.what() == "invalidParamsField 'tx_json.AssetsMaximum' has invalid data."s);
             }
+            env.set_parse_failure_expected(false);
         }
     }
 
@@ -5374,7 +5225,6 @@ public:
         testFailedPseudoAccount();
         testScaleIOU();
         testRPC();
-        testDelegate();
         testVaultClawbackBurnShares();
         testVaultClawbackAssets();
         testAssetsMaximum();
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index c74857fa86..f941e059f8 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -84,7 +84,7 @@ struct SEnv
 
     template <class... FN>
     SEnv&
-    multiTx(jtx::JValueVec&& jvv, FN const&... fN)
+    multiTx(jtx::JValueVec const& jvv, FN const&... fN)
     {
         for (auto const& jv : jvv)
             env_(jv, fN...);
@@ -3826,7 +3826,7 @@ private:
         void
         sendAttestations()
         {
-            bool callback_called;
+            bool callback_called = false;
 
             // we have this "do {} while" loop because we want to process
             // all the account create which can reach quorum at this time
@@ -3997,12 +3997,12 @@ private:
     template <class T>
     class SmBase
     {
-    public:
         SmBase(std::shared_ptr<ChainStateTracker> const& chainstate, BridgeDef const& bridge)
             : bridge_(bridge), st_(chainstate)
         {
         }
 
+    public:
         ChainStateTrack&
         srcState()
         {
@@ -4030,6 +4030,8 @@ private:
     protected:
         BridgeDef const& bridge_;
         std::shared_ptr<ChainStateTracker> st_;
+
+        friend T;
     };
 
     // --------------------------------------------------
@@ -4042,7 +4044,7 @@ private:
             std::shared_ptr<ChainStateTracker> const& chainstate,
             BridgeDef const& bridge,
             AccountCreate create)
-            : Base(chainstate, bridge), sm_state(st_initial), cr(std::move(create))
+            : Base(chainstate, bridge), cr(std::move(create))
         {
         }
 
@@ -4074,7 +4076,7 @@ private:
             ChainStateTrack& st = destState();
 
             // check all signers, but start at a random one
-            size_t i;
+            size_t i = 0;
             for (i = 0; i < num_signers; ++i)
             {
                 size_t signer_idx = (rnd + i) % num_signers;
@@ -4155,7 +4157,7 @@ private:
         }
 
     private:
-        SmState sm_state;
+        SmState sm_state{st_initial};
         AccountCreate cr;
     };
 
@@ -4169,7 +4171,7 @@ private:
             std::shared_ptr<ChainStateTracker> const& chainstate,
             BridgeDef const& bridge,
             Transfer xfer)
-            : Base(chainstate, bridge), xfer(std::move(xfer)), sm_state(st_initial)
+            : Base(chainstate, bridge), xfer(std::move(xfer))
         {
         }
 
@@ -4316,7 +4318,7 @@ private:
 
     private:
         Transfer xfer;
-        SmState sm_state;
+        SmState sm_state{st_initial};
     };
 
     // --------------------------------------------------
diff --git a/src/test/app/tx/apply_test.cpp b/src/test/app/tx/apply_test.cpp
index f21af50817..10b0544f49 100644
--- a/src/test/app/tx/apply_test.cpp
+++ b/src/test/app/tx/apply_test.cpp
@@ -31,7 +31,7 @@ public:
             "8B62E6440848314BB85996936E4F595287774684DC2AC6266024BEF";
 
         auto ret = strUnHex(non_fully_canonical_tx);
-        SerialIter sitTrans(makeSlice(*ret));
+        SerialIter sitTrans(makeSlice(*ret));  // NOLINT(bugprone-unchecked-optional-access)
         STTx const tx = *std::make_shared<STTx const>(std::ref(sitTrans));
 
         {
diff --git a/src/test/basics/Buffer_test.cpp b/src/test/basics/Buffer_test.cpp
index 56f440b993..675228c42f 100644
--- a/src/test/basics/Buffer_test.cpp
+++ b/src/test/basics/Buffer_test.cpp
@@ -106,18 +106,18 @@ struct Buffer_test : beast::unit_test::suite
             {  // Move-construct from empty buf
                 Buffer x;
                 Buffer y{std::move(x)};
-                BEAST_EXPECT(sane(x));
-                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(sane(x));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(x.empty());  // NOLINT(bugprone-use-after-move)
                 BEAST_EXPECT(sane(y));
                 BEAST_EXPECT(y.empty());
-                BEAST_EXPECT(x == y);
+                BEAST_EXPECT(x == y);  // NOLINT(bugprone-use-after-move)
             }
 
             {  // Move-construct from non-empty buf
                 Buffer x{b1};
                 Buffer y{std::move(x)};
-                BEAST_EXPECT(sane(x));
-                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(sane(x));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(x.empty());  // NOLINT(bugprone-use-after-move)
                 BEAST_EXPECT(sane(y));
                 BEAST_EXPECT(y == b1);
             }
@@ -129,8 +129,8 @@ struct Buffer_test : beast::unit_test::suite
                 x = std::move(y);
                 BEAST_EXPECT(sane(x));
                 BEAST_EXPECT(x.empty());
-                BEAST_EXPECT(sane(y));
-                BEAST_EXPECT(y.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
             }
 
             {  // Move assign non-empty buf to empty buf
@@ -140,8 +140,8 @@ struct Buffer_test : beast::unit_test::suite
                 x = std::move(y);
                 BEAST_EXPECT(sane(x));
                 BEAST_EXPECT(x == b1);
-                BEAST_EXPECT(sane(y));
-                BEAST_EXPECT(y.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
             }
 
             {  // Move assign empty buf to non-empty buf
@@ -151,8 +151,8 @@ struct Buffer_test : beast::unit_test::suite
                 x = std::move(y);
                 BEAST_EXPECT(sane(x));
                 BEAST_EXPECT(x.empty());
-                BEAST_EXPECT(sane(y));
-                BEAST_EXPECT(y.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
             }
 
             {  // Move assign non-empty buf to non-empty buf
@@ -163,14 +163,14 @@ struct Buffer_test : beast::unit_test::suite
                 x = std::move(y);
                 BEAST_EXPECT(sane(x));
                 BEAST_EXPECT(!x.empty());
-                BEAST_EXPECT(sane(y));
-                BEAST_EXPECT(y.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
 
                 x = std::move(z);
                 BEAST_EXPECT(sane(x));
                 BEAST_EXPECT(!x.empty());
-                BEAST_EXPECT(sane(z));
-                BEAST_EXPECT(z.empty());
+                BEAST_EXPECT(sane(z));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(z.empty());  // NOLINT(bugprone-use-after-move)
             }
         }
 
diff --git a/src/test/basics/PerfLog_test.cpp b/src/test/basics/PerfLog_test.cpp
index a2976301ef..6e73b5f696 100644
--- a/src/test/basics/PerfLog_test.cpp
+++ b/src/test/basics/PerfLog_test.cpp
@@ -793,7 +793,7 @@ public:
         perfLog->start();
 
         // Randomly select a job type and its name.
-        JobType jobType;
+        JobType jobType = jtINVALID;
         std::string jobTypeName;
         {
             auto const& jobTypes = JobTypes::instance();
diff --git a/src/test/basics/StringUtilities_test.cpp b/src/test/basics/StringUtilities_test.cpp
index 65134da8e5..78719e47c6 100644
--- a/src/test/basics/StringUtilities_test.cpp
+++ b/src/test/basics/StringUtilities_test.cpp
@@ -13,6 +13,8 @@ public:
     {
         auto rv = strUnHex(strIn);
         BEAST_EXPECT(rv);
+
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         BEAST_EXPECT(makeSlice(*rv) == makeSlice(strExpected));
     }
 
@@ -92,7 +94,7 @@ public:
             BEAST_EXPECT(pUrl.username.empty());
             BEAST_EXPECT(pUrl.password.empty());
             BEAST_EXPECT(pUrl.domain == "domain");
-            BEAST_EXPECT(*pUrl.port == 234);
+            BEAST_EXPECT(*pUrl.port == 234);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/");
         }
 
@@ -114,7 +116,7 @@ public:
             BEAST_EXPECT(pUrl.username.empty());
             BEAST_EXPECT(pUrl.password.empty());
             BEAST_EXPECT(pUrl.domain == "::1");
-            BEAST_EXPECT(*pUrl.port == 123);
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/path");
         }
 
@@ -125,7 +127,7 @@ public:
             BEAST_EXPECT(pUrl.username == "user");
             BEAST_EXPECT(pUrl.password == "pass");
             BEAST_EXPECT(pUrl.domain == "domain");
-            BEAST_EXPECT(*pUrl.port == 123);
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/abc:321");
         }
 
@@ -136,7 +138,7 @@ public:
             BEAST_EXPECT(pUrl.username == "user");
             BEAST_EXPECT(pUrl.password.empty());
             BEAST_EXPECT(pUrl.domain == "domain");
-            BEAST_EXPECT(*pUrl.port == 123);
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/abc:321");
         }
 
@@ -147,7 +149,7 @@ public:
             BEAST_EXPECT(pUrl.username.empty());
             BEAST_EXPECT(pUrl.password == "pass");
             BEAST_EXPECT(pUrl.domain == "domain");
-            BEAST_EXPECT(*pUrl.port == 123);
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/abc:321");
         }
 
@@ -158,7 +160,7 @@ public:
             BEAST_EXPECT(pUrl.username.empty());
             BEAST_EXPECT(pUrl.password.empty());
             BEAST_EXPECT(pUrl.domain == "domain");
-            BEAST_EXPECT(*pUrl.port == 123);
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(pUrl.path == "/abc:321");
         }
 
diff --git a/src/test/basics/Units_test.cpp b/src/test/basics/Units_test.cpp
index 9712ec91c0..9693c6d181 100644
--- a/src/test/basics/Units_test.cpp
+++ b/src/test/basics/Units_test.cpp
@@ -31,7 +31,7 @@ private:
             auto drops = mulDiv(baseFee, x, f);
 
             BEAST_EXPECT(drops);
-            BEAST_EXPECT(drops.value() == 1000);
+            BEAST_EXPECT(drops.value() == 1000);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT((std::is_same_v<
                           std::remove_reference_t<decltype(*drops)>::unit_type,
                           unit::dropTag>));
@@ -52,7 +52,7 @@ private:
             auto drops = mulDiv(baseFee, x, f);
 
             BEAST_EXPECT(drops);
-            BEAST_EXPECT(drops.value() == 1000);
+            BEAST_EXPECT(drops.value() == 1000);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT((std::is_same_v<
                           std::remove_reference_t<decltype(*drops)>::unit_type,
                           unit::dropTag>));
@@ -73,7 +73,7 @@ private:
             auto drops = mulDiv(x, basefee, referencefee);
 
             BEAST_EXPECT(drops);
-            BEAST_EXPECT(drops.value() == 40);
+            BEAST_EXPECT(drops.value() == 40);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT((std::is_same_v<
                           std::remove_reference_t<decltype(*drops)>::unit_type,
                           unit::dropTag>));
diff --git a/src/test/basics/XRPAmount_test.cpp b/src/test/basics/XRPAmount_test.cpp
index 391917e678..8b8d657123 100644
--- a/src/test/basics/XRPAmount_test.cpp
+++ b/src/test/basics/XRPAmount_test.cpp
@@ -121,7 +121,7 @@ public:
         // since some of them are templated, but not used anywhere else.
         auto make = [&](auto x) -> XRPAmount { return XRPAmount{x}; };
 
-        XRPAmount defaulted;
+        XRPAmount defaulted{};
         (void)defaulted;
         XRPAmount test{0};
         BEAST_EXPECT(test.drops() == 0);
@@ -154,7 +154,7 @@ public:
         BEAST_EXPECT(test.drops() == 200);
         auto testOther = test.dropsAs<std::uint32_t>();
         BEAST_EXPECT(testOther);
-        BEAST_EXPECT(*testOther == 200);
+        BEAST_EXPECT(*testOther == 200);  // NOLINT(bugprone-unchecked-optional-access)
         test = std::numeric_limits<std::uint64_t>::max();
         testOther = test.dropsAs<std::uint32_t>();
         BEAST_EXPECT(!testOther);
diff --git a/src/test/basics/base58_test.cpp b/src/test/basics/base58_test.cpp
index 46e0c7615e..ca62ac02ef 100644
--- a/src/test/basics/base58_test.cpp
+++ b/src/test/basics/base58_test.cpp
@@ -270,7 +270,7 @@ class base58_test : public beast::unit_test::suite
                 }
                 else
                 {
-                    std::array<std::uint8_t, 128> tmpBuf;
+                    std::array<std::uint8_t, 128> tmpBuf{};
                     std::string const s = xrpl::b58_ref::detail::encodeBase58(
                         b256Data.data(), b256Data.size(), tmpBuf.data(), tmpBuf.size());
                     BEAST_EXPECT(s.size());
@@ -394,7 +394,7 @@ class base58_test : public beast::unit_test::suite
         // bytes range from 0-255
         for (int i = 0; i < numTokenTypeIndexes; ++i)
         {
-            std::array<std::uint8_t, 128> b256DataBuf;
+            std::array<std::uint8_t, 128> b256DataBuf{};
             auto const [tokType, tokSize] = tokenTypeAndSize(i);
             for (int d = 0; d <= 255; ++d)
             {
@@ -407,7 +407,7 @@ class base58_test : public beast::unit_test::suite
         constexpr std::size_t iters = 100000;
         for (int i = 0; i < iters; ++i)
         {
-            std::array<std::uint8_t, 128> b256DataBuf;
+            std::array<std::uint8_t, 128> b256DataBuf{};
             auto const [tokType, b256Data] = randomB256TestData(b256DataBuf);
             testIt(tokType, b256Data);
         }
diff --git a/src/test/basics/base_uint_test.cpp b/src/test/basics/base_uint_test.cpp
index 0aa89bcecc..c8f931e2b5 100644
--- a/src/test/basics/base_uint_test.cpp
+++ b/src/test/basics/base_uint_test.cpp
@@ -142,7 +142,7 @@ struct base_uint_test : beast::unit_test::suite
         // Test hash_append by "hashing" with a no-op hasher (h)
         // and then extracting the bytes that were written during hashing
         // back into another base_uint (w) for comparison with the original
-        nonhash<96> h;
+        nonhash<96> h{};
         hash_append(h, u);
         test96 w{std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
         BEAST_EXPECT(w == u);
diff --git a/src/test/beast/IPEndpoint_test.cpp b/src/test/beast/IPEndpoint_test.cpp
index e0eedd4c24..6276f7cd96 100644
--- a/src/test/beast/IPEndpoint_test.cpp
+++ b/src/test/beast/IPEndpoint_test.cpp
@@ -152,7 +152,7 @@ public:
         std::string const& normal = "")
     {
         auto const result = Endpoint::from_string_checked(s);
-        if (!BEAST_EXPECT(result))
+        if (BEAST_EXPECT(result); !result.has_value())
             return;
         if (!BEAST_EXPECT(result->address().is_v4()))
             return;
@@ -171,7 +171,7 @@ public:
         std::string const& normal = "")
     {
         auto result = Endpoint::from_string_checked(s);
-        if (!BEAST_EXPECT(result))
+        if (BEAST_EXPECT(result); !result.has_value())
             return;
         if (!BEAST_EXPECT(result->address().is_v6()))
             return;
diff --git a/src/test/beast/LexicalCast_test.cpp b/src/test/beast/LexicalCast_test.cpp
index 4d55b95278..0c84e075c6 100644
--- a/src/test/beast/LexicalCast_test.cpp
+++ b/src/test/beast/LexicalCast_test.cpp
@@ -198,7 +198,7 @@ public:
         testcase("zero conversion");
 
         {
-            std::int32_t out;
+            std::int32_t out = 0;
 
             expect(lexicalCastChecked(out, "-0"), "0");
             expect(lexicalCastChecked(out, "0"), "0");
@@ -206,7 +206,7 @@ public:
         }
 
         {
-            std::uint32_t out;
+            std::uint32_t out = 0;
 
             expect(!lexicalCastChecked(out, "-0"), "0");
             expect(lexicalCastChecked(out, "0"), "0");
diff --git a/src/test/beast/aged_associative_container_test.cpp b/src/test/beast/aged_associative_container_test.cpp
index 19927c2d35..690f03cd49 100644
--- a/src/test/beast/aged_associative_container_test.cpp
+++ b/src/test/beast/aged_associative_container_test.cpp
@@ -227,7 +227,7 @@ public:
         static typename Base::Key const&
         extract(Value const& value)
         {
-            return value;
+            return value;  // NOLINT(bugprone-return-const-ref-from-parameter)
         }
 
         static Values
diff --git a/src/test/beast/beast_Journal_test.cpp b/src/test/beast/beast_Journal_test.cpp
index 407e9ea7aa..cb190e57a0 100644
--- a/src/test/beast/beast_Journal_test.cpp
+++ b/src/test/beast/beast_Journal_test.cpp
@@ -9,10 +9,10 @@ public:
     class TestSink : public Journal::Sink
     {
     private:
-        int m_count;
+        int m_count{0};
 
     public:
-        TestSink() : Sink(severities::kWarning, false), m_count(0)
+        TestSink() : Sink(severities::kWarning, false)
         {
         }
 
diff --git a/src/test/beast/beast_abstract_clock_test.cpp b/src/test/beast/beast_abstract_clock_test.cpp
index 94b7909820..43a210e128 100644
--- a/src/test/beast/beast_abstract_clock_test.cpp
+++ b/src/test/beast/beast_abstract_clock_test.cpp
@@ -37,8 +37,6 @@ public:
         using clock_type = manual_clock<std::chrono::steady_clock>;
         clock_type c;
 
-        std::stringstream ss;
-
         auto c1 = c.now().time_since_epoch();
         c.set(clock_type::time_point(std::chrono::seconds(1)));
         auto c2 = c.now().time_since_epoch();
diff --git a/src/test/conditions/PreimageSha256_test.cpp b/src/test/conditions/PreimageSha256_test.cpp
index c3508758a7..5c9ec5e552 100644
--- a/src/test/conditions/PreimageSha256_test.cpp
+++ b/src/test/conditions/PreimageSha256_test.cpp
@@ -22,7 +22,7 @@ class PreimageSha256_test : public beast::unit_test::suite
     {
         auto blob = strUnHex(s);
         BEAST_EXPECT(blob);
-        return {blob->data(), blob->size()};
+        return {blob->data(), blob->size()};  // NOLINT(bugprone-unchecked-optional-access)
     }
 
     void
diff --git a/src/test/consensus/LedgerTrie_test.cpp b/src/test/consensus/LedgerTrie_test.cpp
index 586b9231f6..175a8d7616 100644
--- a/src/test/consensus/LedgerTrie_test.cpp
+++ b/src/test/consensus/LedgerTrie_test.cpp
@@ -354,6 +354,8 @@ class LedgerTrie_test : public beast::unit_test::suite
             LedgerHistoryHelper h;
             Ledger genesis = h[""];
             t.insert(genesis);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{0})->id == genesis.id());
             BEAST_EXPECT(t.remove(genesis));
             BEAST_EXPECT(t.getPreferred(Seq{0}) == std::nullopt);
@@ -364,6 +366,8 @@ class LedgerTrie_test : public beast::unit_test::suite
             LedgerTrie<Ledger> t;
             LedgerHistoryHelper h;
             t.insert(h["abc"]);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
         }
         // Single node smaller child support
@@ -372,7 +376,11 @@ class LedgerTrie_test : public beast::unit_test::suite
             LedgerHistoryHelper h;
             t.insert(h["abc"]);
             t.insert(h["abcd"]);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
         }
         // Single node larger child
@@ -381,7 +389,11 @@ class LedgerTrie_test : public beast::unit_test::suite
             LedgerHistoryHelper h;
             t.insert(h["abc"]);
             t.insert(h["abcd"], 2);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abcd"].id());
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abcd"].id());
         }
         // Single node smaller children support
@@ -391,12 +403,16 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abc"]);
             t.insert(h["abcd"]);
             t.insert(h["abce"]);
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
 
             t.insert(h["abc"]);
+
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
         // Single node larger children
         {
@@ -405,12 +421,16 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abc"]);
             t.insert(h["abcd"], 2);
             t.insert(h["abce"]);
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
 
             t.insert(h["abcd"]);
+
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abcd"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abcd"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
         // Tie-breaker by id
         {
@@ -420,10 +440,14 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abce"], 2);
 
             BEAST_EXPECT(h["abce"].id() > h["abcd"].id());
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abce"].id());
 
             t.insert(h["abcd"]);
             BEAST_EXPECT(h["abce"].id() > h["abcd"].id());
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abcd"].id());
         }
 
@@ -436,14 +460,18 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abce"], 2);
             // abce only has a margin of 1, but it owns the tie-breaker
             BEAST_EXPECT(h["abce"].id() > h["abcd"].id());
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abce"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abce"].id());
 
             // Switch support from abce to abcd, tie-breaker now needed
             t.remove(h["abce"]);
             t.insert(h["abcd"]);
+
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
 
         // Single node larger grand child
@@ -453,9 +481,12 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abc"]);
             t.insert(h["abcd"], 2);
             t.insert(h["abcde"], 4);
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abcde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abcde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["abcde"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
 
         // Too much uncommitted support from competing branches
@@ -466,6 +497,7 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abcde"], 2);
             t.insert(h["abcfg"], 2);
             // 'de' and 'fg' are tied without 'abc' vote
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abc"].id());
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["abc"].id());
@@ -473,8 +505,7 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.remove(h["abc"]);
             t.insert(h["abcd"]);
 
-            // 'de' branch has 3 votes to 2, so earlier sequences see it as
-            // preferred
+            // 'de' branch has 3 votes to 2, so earlier sequences see it as preferred
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abcde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["abcde"].id());
 
@@ -482,6 +513,7 @@ class LedgerTrie_test : public beast::unit_test::suite
             // a different branch, you do not yet know if they chose abcd
             // or abcf because of you, so abc remains preferred
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["abc"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
 
         // Changing largestSeq perspective changes preferred branch
@@ -505,12 +537,15 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.insert(h["abde"], 2);
 
             // B has more branch support
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{1})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{2})->id == h["ab"].id());
+
             // But if you last validated D,F or E, you do not yet know
             // if someone used that validation to commit to B or C
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["a"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["a"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
 
             /** One of E advancing to G doesn't change anything
                    A
@@ -526,11 +561,13 @@ class LedgerTrie_test : public beast::unit_test::suite
             t.remove(h["abde"]);
             t.insert(h["abdeg"]);
 
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{1})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{2})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["a"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["a"].id());
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["a"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
 
             /** C advancing to H does advance the seq 3 preferred ledger
                    A
@@ -545,11 +582,14 @@ class LedgerTrie_test : public beast::unit_test::suite
             */
             t.remove(h["ac"]);
             t.insert(h["abh"]);
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{1})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{2})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["a"].id());
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["a"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
 
             /** F advancing to E also moves the preferred ledger forward
                    A
@@ -564,11 +604,14 @@ class LedgerTrie_test : public beast::unit_test::suite
             */
             t.remove(h["acf"]);
             t.insert(h["abde"]);
+
+            // NOLINTBEGIN(bugprone-unchecked-optional-access)
             BEAST_EXPECT(t.getPreferred(Seq{1})->id == h["abde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{2})->id == h["abde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{3})->id == h["abde"].id());
             BEAST_EXPECT(t.getPreferred(Seq{4})->id == h["ab"].id());
             BEAST_EXPECT(t.getPreferred(Seq{5})->id == h["ab"].id());
+            // NOLINTEND(bugprone-unchecked-optional-access)
         }
     }
 
diff --git a/src/test/consensus/NegativeUNL_test.cpp b/src/test/consensus/NegativeUNL_test.cpp
index d03ee3950d..7275566ef7 100644
--- a/src/test/consensus/NegativeUNL_test.cpp
+++ b/src/test/consensus/NegativeUNL_test.cpp
@@ -1304,7 +1304,7 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::suite
                     NodeID myId = history.UNLNodeIDs[3];
                     history.walkHistoryAndAddValidations(
                         [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
-                            std::size_t k;
+                            std::size_t k = 0;
                             if (idx < 2)
                                 k = 0;
                             else if (idx < 4)
@@ -1470,6 +1470,7 @@ class NegativeUNLVoteOffline_test : public beast::unit_test::suite
             if (history.goodHistory)
             {
                 NodeID n1 = calcNodeID(*history.lastLedger()->negativeUNL().begin());
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 NodeID n2 = calcNodeID(*history.lastLedger()->validatorToDisable());
                 history.walkHistoryAndAddValidations(
                     [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
diff --git a/src/test/consensus/Validations_test.cpp b/src/test/consensus/Validations_test.cpp
index f8458e090c..e3c9901398 100644
--- a/src/test/consensus/Validations_test.cpp
+++ b/src/test/consensus/Validations_test.cpp
@@ -998,6 +998,8 @@ class Validations_test : public beast::unit_test::suite
             std::vector<Validation> trustedVals({v});
             auto& vals = harness.vals();
             BEAST_EXPECT(vals.currentTrusted() == trustedVals);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(vals.getPreferred(genesisLedger)->second == v.ledgerID());
             BEAST_EXPECT(vals.getNodesAfter(genesisLedger, genesisLedger.id()) == 0);
 
diff --git a/src/test/core/ClosureCounter_test.cpp b/src/test/core/ClosureCounter_test.cpp
index 5cce837fb0..fc56d7f6c9 100644
--- a/src/test/core/ClosureCounter_test.cpp
+++ b/src/test/core/ClosureCounter_test.cpp
@@ -36,9 +36,9 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             // wrapped() should be callable with no arguments.
-            (*wrapped)();
+            (*wrapped)();  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(evidence == 1);
-            (*wrapped)();
+            (*wrapped)();  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(evidence == 2);
 
             // Destroying the contents of wrapped should decrement voidCounter.
@@ -60,9 +60,9 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             // wrapped() should be callable with one integer argument.
-            (*wrapped)(5);
+            (*wrapped)(5);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(evidence == 5);
-            (*wrapped)(11);
+            (*wrapped)(11);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(evidence == 11);
 
             // Destroying the contents of wrapped should decrement setCounter.
@@ -82,8 +82,8 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             // wrapped() should be callable with two integers.
-            BEAST_EXPECT((*wrapped)(5, 2) == 7);
-            BEAST_EXPECT((*wrapped)(2, -8) == -6);
+            BEAST_EXPECT((*wrapped)(5, 2) == 7);    // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT((*wrapped)(2, -8) == -6);  // NOLINT(bugprone-unchecked-optional-access)
 
             // Destroying the contents of wrapped should decrement sumCounter.
             wrapped = std::nullopt;
@@ -154,7 +154,8 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             TrackedString const strValue("value");
-            TrackedString const result = (*wrapped)(strValue);
+            TrackedString const result =
+                (*wrapped)(strValue);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(result.copies == 2);
             BEAST_EXPECT(result.moves == 1);
             BEAST_EXPECT(result.str == "value!");
@@ -171,7 +172,8 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             TrackedString const strConstLValue("const lvalue");
-            TrackedString const result = (*wrapped)(strConstLValue);
+            TrackedString const result =
+                (*wrapped)(strConstLValue);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(result.copies == 1);
             // BEAST_EXPECT (result.moves == ?); // moves VS == 1, gcc == 0
             BEAST_EXPECT(result.str == "const lvalue!");
@@ -188,7 +190,8 @@ class ClosureCounter_test : public beast::unit_test::suite
             BEAST_EXPECT(wrapped);
 
             TrackedString strLValue("lvalue");
-            TrackedString const result = (*wrapped)(strLValue);
+            TrackedString const result =
+                (*wrapped)(strLValue);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(result.copies == 1);
             BEAST_EXPECT(result.moves == 0);
             BEAST_EXPECT(result.str == "lvalue!");
@@ -204,20 +207,21 @@ class ClosureCounter_test : public beast::unit_test::suite
                 // leaving scope.  So, without intervention, they would
                 // do a copy for the return (June 2017).  An explicit
                 // std::move() was required.
-                return std::move(in += "!");
+                in += "!";
+                return std::move(in);
             });
 
             BEAST_EXPECT(strCounter.count() == 1);
             BEAST_EXPECT(wrapped);
 
-            // Make the string big enough to (probably) avoid the small string
-            // optimization.
+            // Make the string big enough to (probably) avoid the small string optimization.
             TrackedString strRValue("rvalue abcdefghijklmnopqrstuvwxyz");
-            TrackedString const result = (*wrapped)(std::move(strRValue));
+            TrackedString const result =
+                (*wrapped)(std::move(strRValue));  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(result.copies == 0);
             BEAST_EXPECT(result.moves == 1);
             BEAST_EXPECT(result.str == "rvalue abcdefghijklmnopqrstuvwxyz!");
-            BEAST_EXPECT(strRValue.str.size() == 0);
+            BEAST_EXPECT(strRValue.str.size() == 0);  // NOLINT(bugprone-use-after-move)
         }
     }
 
diff --git a/src/test/core/Config_test.cpp b/src/test/core/Config_test.cpp
index 0ce457ec89..c71406cc07 100644
--- a/src/test/core/Config_test.cpp
+++ b/src/test/core/Config_test.cpp
@@ -1280,7 +1280,7 @@ r.ripple.com:51235
         for (auto const& t : tests)
         {
             Section s;
-            s.append(t.line.data());
+            s.append(std::string(t.line));
             BEAST_EXPECT(s.had_trailing_comments() == t.had_comment);
             if (t.field.empty())
             {
@@ -1289,7 +1289,7 @@ r.ripple.com:51235
             else
             {
                 std::string field;
-                BEAST_EXPECTS(set(field, t.field.data(), s), t.line);
+                BEAST_EXPECTS(set(field, std::string(t.field), s), t.line);
                 BEAST_EXPECTS(field == t.expect, t.line);
             }
         }
@@ -1299,6 +1299,7 @@ r.ripple.com:51235
             s.append("online_delete = 3000");
             std::uint32_t od = 0;
             BEAST_EXPECT(set(od, "online_delete", s));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECTS(od == 3000, *(s.get<std::string>("online_delete")));
         }
 
@@ -1307,6 +1308,7 @@ r.ripple.com:51235
             s.append("online_delete = 2000 #my comment on this");
             std::uint32_t od = 0;
             BEAST_EXPECT(set(od, "online_delete", s));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECTS(od == 2000, *(s.get<std::string>("online_delete")));
         }
     }
diff --git a/src/test/core/JobQueue_test.cpp b/src/test/core/JobQueue_test.cpp
index 8289e305a0..bf6a5590e6 100644
--- a/src/test/core/JobQueue_test.cpp
+++ b/src/test/core/JobQueue_test.cpp
@@ -36,7 +36,7 @@ class JobQueue_test : public beast::unit_test::suite
             // The Job should never run, so having the Job access this
             // unprotected variable on the stack should be completely safe.
             // Not recommended for the faint of heart...
-            bool unprotected;
+            bool unprotected = false;
             BEAST_EXPECT(jQueue.addJob(jtCLIENT, "JobAddTest2", [&unprotected]() {
                 unprotected = false;
             }) == false);
@@ -118,7 +118,7 @@ class JobQueue_test : public beast::unit_test::suite
             // The Coro should never run, so having the Coro access this
             // unprotected variable on the stack should be completely safe.
             // Not recommended for the faint of heart...
-            bool unprotected;
+            bool unprotected = false;
             auto const coro = jQueue.postCoro(
                 jtCLIENT, "PostCoroTest3", [&unprotected](std::shared_ptr<JobQueue::Coro> const&) {
                     unprotected = false;
diff --git a/src/test/core/SociDB_test.cpp b/src/test/core/SociDB_test.cpp
index a06193ae86..66b368176d 100644
--- a/src/test/core/SociDB_test.cpp
+++ b/src/test/core/SociDB_test.cpp
@@ -58,7 +58,7 @@ public:
         {
             setupDatabaseDir(getDatabasePath());
         }
-        catch (std::exception const&)
+        catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -68,7 +68,7 @@ public:
         {
             cleanupDatabaseDir(getDatabasePath());
         }
-        catch (std::exception const&)
+        catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
diff --git a/src/test/csf/Digraph_test.cpp b/src/test/csf/Digraph_test.cpp
index a0cb35323d..a183234903 100644
--- a/src/test/csf/Digraph_test.cpp
+++ b/src/test/csf/Digraph_test.cpp
@@ -24,13 +24,15 @@ public:
 
         BEAST_EXPECT(graph.connect('a', 'b', "foobar"));
         BEAST_EXPECT(graph.connected('a', 'b'));
-        BEAST_EXPECT(*graph.edge('a', 'b') == "foobar");
+        BEAST_EXPECT(
+            *graph.edge('a', 'b') == "foobar");  // NOLINT(bugprone-unchecked-optional-access)
 
         BEAST_EXPECT(!graph.connect('a', 'b', "repeat"));
         BEAST_EXPECT(graph.disconnect('a', 'b'));
         BEAST_EXPECT(graph.connect('a', 'b', "repeat"));
         BEAST_EXPECT(graph.connected('a', 'b'));
-        BEAST_EXPECT(*graph.edge('a', 'b') == "repeat");
+        BEAST_EXPECT(
+            *graph.edge('a', 'b') == "repeat");  // NOLINT(bugprone-unchecked-optional-access)
 
         BEAST_EXPECT(graph.connect('a', 'c', "tree"));
 
diff --git a/src/test/jtx.h b/src/test/jtx.h
index 903b029f29..d4b88b0b9e 100644
--- a/src/test/jtx.h
+++ b/src/test/jtx.h
@@ -51,7 +51,6 @@
 #include <test/jtx/tag.h>
 #include <test/jtx/tags.h>
 #include <test/jtx/ter.h>
-#include <test/jtx/testline.h>
 #include <test/jtx/ticket.h>
 #include <test/jtx/token.h>
 #include <test/jtx/trust.h>
diff --git a/src/test/jtx/AMMTest.h b/src/test/jtx/AMMTest.h
index be6e228c0a..78e26b9e40 100644
--- a/src/test/jtx/AMMTest.h
+++ b/src/test/jtx/AMMTest.h
@@ -83,14 +83,14 @@ protected:
      */
     void
     testAMM(
-        std::function<void(jtx::AMM&, jtx::Env&)>&& cb,
+        std::function<void(jtx::AMM&, jtx::Env&)> const& cb,
         std::optional<std::pair<STAmount, STAmount>> const& pool = std::nullopt,
         std::uint16_t tfee = 0,
         std::optional<jtx::ter> const& ter = std::nullopt,
         std::vector<FeatureBitset> const& features = {testable_amendments()});
 
     void
-    testAMM(std::function<void(jtx::AMM&, jtx::Env&)>&& cb, TestAMMArg const& arg);
+    testAMM(std::function<void(jtx::AMM&, jtx::Env&)> const& cb, TestAMMArg const& arg);
 };
 
 class AMMTest : public jtx::AMMTestBase
diff --git a/src/test/jtx/Env.h b/src/test/jtx/Env.h
index 9caf257aa1..2ac0ca7435 100644
--- a/src/test/jtx/Env.h
+++ b/src/test/jtx/Env.h
@@ -31,6 +31,7 @@
 #include <xrpl/protocol/STTx.h>
 
 #include <functional>
+#include <future>
 #include <source_location>
 #include <string>
 #include <tuple>
@@ -393,6 +394,48 @@ public:
         return close(std::chrono::seconds(5));
     }
 
+    /** Close and advance the ledger, then synchronize with the server's
+        io_context to ensure all async operations initiated by the close have
+        been started.
+
+        This function performs the same ledger close as close(), but additionally
+        ensures that all tasks posted to the server's io_context (such as
+        WebSocket subscription message sends) have been initiated before returning.
+
+        What it guarantees:
+        - All async operations posted before syncClose() have been STARTED
+        - For WebSocket sends: async_write_some() has been called
+        - The actual I/O completion may still be pending (async)
+
+        What it does NOT guarantee:
+        - Async operations have COMPLETED
+        - WebSocket messages have been received by clients
+        - However, for localhost connections, the remaining latency is typically
+          microseconds, making tests reliable
+
+        Use this instead of close() when:
+        - Test code immediately checks for subscription messages
+        - Race conditions between test and worker threads must be avoided
+        - Deterministic test behavior is required
+
+        @param timeout Maximum time to wait for the barrier task to execute
+        @return true if close succeeded and barrier executed within timeout,
+                false otherwise
+    */
+    [[nodiscard]] bool
+    syncClose(std::chrono::steady_clock::duration timeout = std::chrono::seconds{1})
+    {
+        XRPL_ASSERT(
+            app().getNumberOfThreads() == 1,
+            "syncClose() is only useful on an application with a single thread");
+        auto const result = close();
+        auto serverBarrier = std::make_shared<std::promise<void>>();
+        auto future = serverBarrier->get_future();
+        boost::asio::post(app().getIOContext(), [serverBarrier]() { serverBarrier->set_value(); });
+        auto const status = future.wait_for(timeout);
+        return result && status == std::future_status::ready;
+    }
+
     /** Turn on JSON tracing.
         With no arguments, trace all
     */
diff --git a/src/test/jtx/Env_test.cpp b/src/test/jtx/Env_test.cpp
index 6d151c27ce..bd1867adb3 100644
--- a/src/test/jtx/Env_test.cpp
+++ b/src/test/jtx/Env_test.cpp
@@ -39,9 +39,9 @@ public:
             a = std::move(b);
             Account c(std::move(a));
         }
-        Account("alice");
-        Account("alice", KeyType::secp256k1);
-        Account("alice", KeyType::ed25519);
+        Account("alice");                      // NOLINT(bugprone-unused-raii)
+        Account("alice", KeyType::secp256k1);  // NOLINT(bugprone-unused-raii)
+        Account("alice", KeyType::ed25519);    // NOLINT(bugprone-unused-raii)
         auto const gw = Account("gw");
         [](AccountID) {}(gw);
         auto const USD = gw["USD"];
@@ -56,11 +56,11 @@ public:
     {
         using namespace jtx;
 
-        PrettyAmount(0);
-        PrettyAmount(1);
-        PrettyAmount(0u);
-        PrettyAmount(1u);
-        PrettyAmount(-1);
+        PrettyAmount(0);   // NOLINT(bugprone-unused-raii)
+        PrettyAmount(1);   // NOLINT(bugprone-unused-raii)
+        PrettyAmount(0u);  // NOLINT(bugprone-unused-raii)
+        PrettyAmount(1u);  // NOLINT(bugprone-unused-raii)
+        PrettyAmount(-1);  // NOLINT(bugprone-unused-raii)
         static_assert(!std::is_trivially_constructible<PrettyAmount, char>::value, "");
         static_assert(!std::is_trivially_constructible<PrettyAmount, unsigned char>::value, "");
         static_assert(!std::is_trivially_constructible<PrettyAmount, short>::value, "");
@@ -533,14 +533,14 @@ public:
         BEAST_EXPECT(*jt1.get<int>() == 7);
         BEAST_EXPECT(!jt1.get<UDT>());
         JTx jt2(std::move(jt1));
-        BEAST_EXPECT(!jt1.get<int>());
-        BEAST_EXPECT(!jt1.get<UDT>());
+        BEAST_EXPECT(!jt1.get<int>());  // NOLINT(bugprone-use-after-move)
+        BEAST_EXPECT(!jt1.get<UDT>());  // NOLINT(bugprone-use-after-move)
         BEAST_EXPECT(jt2.get<int>());
         BEAST_EXPECT(*jt2.get<int>() == 7);
         BEAST_EXPECT(!jt2.get<UDT>());
         jt1 = std::move(jt2);
-        BEAST_EXPECT(!jt2.get<int>());
-        BEAST_EXPECT(!jt2.get<UDT>());
+        BEAST_EXPECT(!jt2.get<int>());  // NOLINT(bugprone-use-after-move)
+        BEAST_EXPECT(!jt2.get<UDT>());  // NOLINT(bugprone-use-after-move)
         BEAST_EXPECT(jt1.get<int>());
         BEAST_EXPECT(*jt1.get<int>() == 7);
         BEAST_EXPECT(!jt1.get<UDT>());
diff --git a/src/test/jtx/JTx.h b/src/test/jtx/JTx.h
index 90fbb8a6b6..bf43d0aa75 100644
--- a/src/test/jtx/JTx.h
+++ b/src/test/jtx/JTx.h
@@ -38,9 +38,6 @@ struct JTx
     // Functions that sign something else after the mainSigners, such as
     // sfCounterpartySignature
     std::vector<std::function<void(Env&, JTx&)>> postSigners;
-    // Metadata about the unit test itself
-    // The line where the JTx was constructed
-    std::optional<int> testLine = std::nullopt;
 
     JTx() = default;
     JTx(JTx const&) = default;
diff --git a/src/test/jtx/TrustedPublisherServer.h b/src/test/jtx/TrustedPublisherServer.h
index 529383c622..dc7682bb72 100644
--- a/src/test/jtx/TrustedPublisherServer.h
+++ b/src/test/jtx/TrustedPublisherServer.h
@@ -129,7 +129,7 @@ public:
 
     // TrustedPublisherServer must be accessed through a shared_ptr.
     // This constructor is only public so std::make_shared has access.
-    // The function`make_TrustedPublisherServer` should be used to create
+    // The function `make_TrustedPublisherServer` should be used to create
     // instances.
     // The `futures` member is expected to be structured as
     // effective / expiration time point pairs for use in version 2 UNLs
@@ -249,7 +249,7 @@ public:
     {
         error_code ec;
         acceptor_.close(ec);
-        // TODO consider making this join
+        // TODO: consider making this join
         // any running do_peer threads
     }
 
diff --git a/src/test/jtx/did.h b/src/test/jtx/did.h
index 9cd98a1324..e6b06f8f7c 100644
--- a/src/test/jtx/did.h
+++ b/src/test/jtx/did.h
@@ -53,7 +53,7 @@ public:
     }
 };
 
-/** Sets the optional Attestation on a DIDSet. */
+/** Sets the optional Data on a DIDSet. */
 class data
 {
 private:
diff --git a/src/test/jtx/envconfig.h b/src/test/jtx/envconfig.h
index f2f67f935b..e4a1975e74 100644
--- a/src/test/jtx/envconfig.h
+++ b/src/test/jtx/envconfig.h
@@ -73,6 +73,8 @@ std::unique_ptr<Config> admin_localnet(std::unique_ptr<Config>);
 
 std::unique_ptr<Config> secure_gateway_localnet(std::unique_ptr<Config>);
 
+std::unique_ptr<Config> single_thread_io(std::unique_ptr<Config>);
+
 /// @brief adjust configuration with params needed to be a validator
 ///
 /// this is intended for use with envconfig, as in
diff --git a/src/test/jtx/impl/AMM.cpp b/src/test/jtx/impl/AMM.cpp
index faf47259dc..e1f6137a10 100644
--- a/src/test/jtx/impl/AMM.cpp
+++ b/src/test/jtx/impl/AMM.cpp
@@ -1,12 +1,13 @@
 #include <test/jtx/AMM.h>
 #include <test/jtx/Env.h>
 
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/AmountConversions.h>
 #include <xrpl/protocol/ApiVersion.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 namespace test {
@@ -627,7 +628,8 @@ AMM::bid(BidArg const& arg)
             amm->isFieldPresent(sfAuctionSlot));
         if (amm->isFieldPresent(sfAuctionSlot))
         {
-            auto const& auctionSlot = static_cast<STObject const&>(amm->peekAtField(sfAuctionSlot));
+            auto const& auctionSlot =
+                safe_downcast<STObject const&>(amm->peekAtField(sfAuctionSlot));
             lastPurchasePrice_ = auctionSlot[sfPrice].iou();
         }
     }
@@ -719,7 +721,8 @@ AMM::expectAuctionSlot(auto&& cb) const
             amm->isFieldPresent(sfAuctionSlot));
         if (amm->isFieldPresent(sfAuctionSlot))
         {
-            auto const& auctionSlot = static_cast<STObject const&>(amm->peekAtField(sfAuctionSlot));
+            auto const& auctionSlot =
+                safe_downcast<STObject const&>(amm->peekAtField(sfAuctionSlot));
             if (auctionSlot.isFieldPresent(sfAccount))
             {
                 // This could fail in pre-fixInnerObjTemplate tests
diff --git a/src/test/jtx/impl/AMMTest.cpp b/src/test/jtx/impl/AMMTest.cpp
index 01ba5069bf..eb39408fbd 100644
--- a/src/test/jtx/impl/AMMTest.cpp
+++ b/src/test/jtx/impl/AMMTest.cpp
@@ -82,18 +82,17 @@ AMMTestBase::AMMTestBase()
 
 void
 AMMTestBase::testAMM(
-    std::function<void(jtx::AMM&, jtx::Env&)>&& cb,
+    std::function<void(jtx::AMM&, jtx::Env&)> const& cb,
     std::optional<std::pair<STAmount, STAmount>> const& pool,
     std::uint16_t tfee,
     std::optional<jtx::ter> const& ter,
     std::vector<FeatureBitset> const& vfeatures)
 {
-    testAMM(
-        std::move(cb), TestAMMArg{.pool = pool, .tfee = tfee, .ter = ter, .features = vfeatures});
+    testAMM(cb, TestAMMArg{.pool = pool, .tfee = tfee, .ter = ter, .features = vfeatures});
 }
 
 void
-AMMTestBase::testAMM(std::function<void(jtx::AMM&, jtx::Env&)>&& cb, TestAMMArg const& arg)
+AMMTestBase::testAMM(std::function<void(jtx::AMM&, jtx::Env&)> const& cb, TestAMMArg const& arg)
 {
     using namespace jtx;
 
@@ -264,6 +263,7 @@ AMMTest::find_paths(
                 Json::Value p;
                 p["Paths"] = path[jss::paths_computed];
                 STParsedJSONObject po("generic", p);
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 paths = po.object->getFieldPathSet(sfPaths);
             }
         }
diff --git a/src/test/jtx/impl/Env.cpp b/src/test/jtx/impl/Env.cpp
index df86aaa2e4..35531634f4 100644
--- a/src/test/jtx/impl/Env.cpp
+++ b/src/test/jtx/impl/Env.cpp
@@ -419,16 +419,15 @@ Env::postconditions(
     Json::Value const& jr,
     std::source_location const& loc)
 {
-    auto const line = jt.testLine ? " (" + to_string(*jt.testLine) + ")" : "";
     auto const locStr = std::string("(") + loc.file_name() + ":" + to_string(loc.line()) + ")";
-    bool bad = !test.expect(parsed.ter, "apply " + locStr + ": No ter result!" + line);
+    bool bad = !test.expect(parsed.ter, "apply " + locStr + ": No ter result!");
     bad =
         (jt.ter && parsed.ter &&
          !test.expect(
              *parsed.ter == *jt.ter,
              "apply " + locStr + ": Got " + transToken(*parsed.ter) + " (" +
                  transHuman(*parsed.ter) + "); Expected " + transToken(*jt.ter) + " (" +
-                 transHuman(*jt.ter) + ")" + line));
+                 transHuman(*jt.ter) + ")"));
     using namespace std::string_literals;
     bad = (jt.rpcCode &&
            !test.expect(
@@ -438,7 +437,7 @@ Env::postconditions(
                                    : "NO RESULT") +
                    " (" + parsed.rpcMessage + "); Expected " +
                    RPC::get_error_info(jt.rpcCode->first).token.c_str() + " (" +
-                   jt.rpcCode->second + ")" + line)) ||
+                   jt.rpcCode->second + ")")) ||
         bad;
     // If we have an rpcCode (just checked), then the rpcException check is
     // optional - the 'error' field may not be defined, but if it is, it must
@@ -450,7 +449,7 @@ Env::postconditions(
                     (!jt.rpcException->second || parsed.rpcException == *jt.rpcException->second)),
                "apply " + locStr + ": Got RPC result "s + parsed.rpcError + " (" +
                    parsed.rpcException + "); Expected " + jt.rpcException->first + " (" +
-                   jt.rpcException->second.value_or("n/a") + ")" + line)) ||
+                   jt.rpcException->second.value_or("n/a") + ")")) ||
         bad;
     if (bad)
     {
@@ -587,10 +586,10 @@ Env::st(JTx const& jt)
     {
         return sterilize(STTx{std::move(*obj)});
     }
-    catch (std::exception const&)
+    catch (...)
     {
+        return nullptr;
     }
-    return nullptr;
 }
 
 std::shared_ptr<STTx const>
@@ -613,10 +612,10 @@ Env::ust(JTx const& jt)
     {
         return std::make_shared<STTx const>(std::move(*obj));
     }
-    catch (std::exception const&)
+    catch (...)
     {
+        return nullptr;
     }
-    return nullptr;
 }
 
 Json::Value
diff --git a/src/test/jtx/impl/JSONRPCClient.cpp b/src/test/jtx/impl/JSONRPCClient.cpp
index df41ed39be..b635050984 100644
--- a/src/test/jtx/impl/JSONRPCClient.cpp
+++ b/src/test/jtx/impl/JSONRPCClient.cpp
@@ -41,7 +41,7 @@ class JSONRPCClient : public AbstractClient
             if (!pp.port)
                 Throw<std::runtime_error>("Use fixConfigPorts with auto ports");
 
-            return {*pp.ip, *pp.port};
+            return {*pp.ip, *pp.port};  // NOLINT(bugprone-unchecked-optional-access)
         }
         Throw<std::runtime_error>("Missing HTTP port");
         return {};  // Silence compiler control paths return value warning
diff --git a/src/test/jtx/impl/Oracle.cpp b/src/test/jtx/impl/Oracle.cpp
index c9d8c0ce27..9c75b21973 100644
--- a/src/test/jtx/impl/Oracle.cpp
+++ b/src/test/jtx/impl/Oracle.cpp
@@ -216,7 +216,6 @@ Oracle::set(UpdateArg const& arg)
             return s;
         assert(s.size() <= 20);
         // anything else must be 160-bit hex string
-        std::string h = strHex(s);
         return strHex(s).append(40 - s.size() * 2, '0');
     };
     for (auto const& data : arg.series)
@@ -226,9 +225,10 @@ Oracle::set(UpdateArg const& arg)
         price[jss::BaseAsset] = assetToStr(std::get<0>(data));
         price[jss::QuoteAsset] = assetToStr(std::get<1>(data));
         if (std::get<2>(data))
-            price[jss::AssetPrice] = *std::get<2>(data);
+            price[jss::AssetPrice] =
+                *std::get<2>(data);  // NOLINT(bugprone-unchecked-optional-access)
         if (std::get<3>(data))
-            price[jss::Scale] = *std::get<3>(data);
+            price[jss::Scale] = *std::get<3>(data);  // NOLINT(bugprone-unchecked-optional-access)
         priceData[jss::PriceData] = price;
         dataSeries.append(priceData);
     }
@@ -273,7 +273,7 @@ Oracle::ledgerEntry(
         toJson(jvParams[jss::oracle][jss::oracle_document_id], *documentID);
     if (index)
     {
-        std::uint32_t i;
+        std::uint32_t i = 0;
         if (boost::conversion::try_lexical_convert(*index, i))
             jvParams[jss::oracle][jss::ledger_index] = i;
         else
@@ -339,8 +339,8 @@ validDocumentID(AnyValue const& v)
     }
     catch (...)
     {
+        return false;
     }
-    return false;
 }
 
 }  // namespace oracle
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index 2b92eb5ec3..a51357c9b5 100644
--- a/src/test/jtx/impl/WSClient.cpp
+++ b/src/test/jtx/impl/WSClient.cpp
@@ -27,7 +27,7 @@ class WSClientImpl : public WSClient
     {
         Json::Value jv;
 
-        explicit msg(Json::Value&& jv_) : jv(jv_)
+        explicit msg(Json::Value&& jv_) : jv(std::move(jv_))
         {
         }
     };
@@ -55,7 +55,7 @@ class WSClientImpl : public WSClient
             if (!pp.port)
                 Throw<std::runtime_error>("Use fixConfigPorts with auto ports");
 
-            return {*pp.ip, *pp.port};
+            return {*pp.ip, *pp.port};  // NOLINT(bugprone-unchecked-optional-access)
         }
         Throw<std::runtime_error>("Missing WebSocket port");
         return {};  // Silence compiler control paths return value warning
@@ -107,6 +107,7 @@ class WSClientImpl : public WSClient
                                           {
                                               stream_.cancel();
                                           }
+                                          // NOLINTNEXTLINE(bugprone-empty-catch)
                                           catch (boost::system::system_error const&)
                                           {
                                               // ignored
diff --git a/src/test/jtx/impl/batch.cpp b/src/test/jtx/impl/batch.cpp
index ee636ddcb7..c21711ab17 100644
--- a/src/test/jtx/impl/batch.cpp
+++ b/src/test/jtx/impl/batch.cpp
@@ -75,6 +75,7 @@ sig::operator()(Env& env, JTx& jt) const
         Serializer msg;
         serializeBatch(msg, stx.getFlags(), stx.getBatchTransactionIDs());
         finishMultiSigningData(e.acct.id(), msg);
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const sig = xrpl::sign(*publicKeyType(e.sig.pk().slice()), e.sig.sk(), msg.slice());
         jo[sfTxnSignature.getJsonName()] = strHex(Slice{sig.data(), sig.size()});
     }
@@ -113,6 +114,7 @@ msig::operator()(Env& env, JTx& jt) const
         Serializer msg;
         serializeBatch(msg, stx.getFlags(), stx.getBatchTransactionIDs());
         finishMultiSigningData(e.acct.id(), msg);
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const sig = xrpl::sign(*publicKeyType(e.sig.pk().slice()), e.sig.sk(), msg.slice());
         iso[sfTxnSignature.getJsonName()] = strHex(Slice{sig.data(), sig.size()});
     }
diff --git a/src/test/jtx/impl/envconfig.cpp b/src/test/jtx/impl/envconfig.cpp
index 31034f3b63..e31e687c3d 100644
--- a/src/test/jtx/impl/envconfig.cpp
+++ b/src/test/jtx/impl/envconfig.cpp
@@ -87,6 +87,12 @@ secure_gateway_localnet(std::unique_ptr<Config> cfg)
     (*cfg)[PORT_WS].set("secure_gateway", "127.0.0.0/8");
     return cfg;
 }
+std::unique_ptr<Config>
+single_thread_io(std::unique_ptr<Config> cfg)
+{
+    cfg->IO_WORKERS = 1;
+    return cfg;
+}
 
 auto constexpr defaultseed = "shUwVw52ofnCUX5m7kPTKzJdr4HEH";
 
diff --git a/src/test/jtx/impl/ledgerStateFixes.cpp b/src/test/jtx/impl/ledgerStateFixes.cpp
index 04860a5e3a..e5a7495a44 100644
--- a/src/test/jtx/impl/ledgerStateFixes.cpp
+++ b/src/test/jtx/impl/ledgerStateFixes.cpp
@@ -2,7 +2,7 @@
 
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/LedgerStateFix.h>
+#include <xrpl/tx/transactors/system/LedgerStateFix.h>
 
 namespace xrpl {
 namespace test {
diff --git a/src/test/jtx/impl/permissioned_domains.cpp b/src/test/jtx/impl/permissioned_domains.cpp
index fffcaa91a1..60d653e956 100644
--- a/src/test/jtx/impl/permissioned_domains.cpp
+++ b/src/test/jtx/impl/permissioned_domains.cpp
@@ -109,6 +109,7 @@ credentialsFromJson(
         obj = credential[jss::Credential];
         auto const& issuer = obj[jss::Issuer];
         auto const& credentialType = obj["CredentialType"];
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access): used only in tests
         auto blob = strUnHex(credentialType.asString()).value();
         ret.push_back({human2Acc.at(issuer.asString()), std::string(blob.begin(), blob.end())});
     }
diff --git a/src/test/jtx/impl/testline.cpp b/src/test/jtx/impl/testline.cpp
deleted file mode 100644
index fbcb1d2de7..0000000000
--- a/src/test/jtx/impl/testline.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <test/jtx/testline.h>
-
-namespace xrpl {
-namespace test {
-namespace jtx {
-
-void
-testline::operator()(Env&, JTx& jt) const
-{
-    jt.testLine = line_;
-}
-
-}  // namespace jtx
-}  // namespace test
-}  // namespace xrpl
diff --git a/src/test/jtx/impl/token.cpp b/src/test/jtx/impl/token.cpp
index 59f8c822fb..9db79361eb 100644
--- a/src/test/jtx/impl/token.cpp
+++ b/src/test/jtx/impl/token.cpp
@@ -3,7 +3,7 @@
 
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/jss.h>
-#include <xrpl/tx/transactors/NFT/NFTokenMint.h>
+#include <xrpl/tx/transactors/nft/NFTokenMint.h>
 
 namespace xrpl {
 namespace test {
diff --git a/src/test/jtx/testline.h b/src/test/jtx/testline.h
deleted file mode 100644
index e2be1f0276..0000000000
--- a/src/test/jtx/testline.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <test/jtx/Env.h>
-
-namespace xrpl {
-namespace test {
-namespace jtx {
-
-/** Store the line number of the current test in a JTx.
-
-    Intended to help debug failing transaction submission tests.
-*/
-class testline
-{
-private:
-    int line_;
-
-public:
-    explicit testline(int line) : line_(line)
-    {
-    }
-
-    void
-    operator()(Env&, JTx& jt) const;
-};
-
-#define THISLINE testline(__LINE__)
-
-}  // namespace jtx
-}  // namespace test
-}  // namespace xrpl
diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp
index 80ecdba2d5..bae29445c2 100644
--- a/src/test/ledger/View_test.cpp
+++ b/src/test/ledger/View_test.cpp
@@ -88,7 +88,7 @@ class View_test : public beast::unit_test::suite
         auto const next = v.succ(k(id).key);
         if (answer)
         {
-            if (BEAST_EXPECT(next))
+            if (BEAST_EXPECT(next); next.has_value())
                 BEAST_EXPECT(*next == k(*answer).key);
         }
         else
diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp
index b537e3abb7..e334283052 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -550,6 +550,7 @@ public:
                     p[1] = 1 - p[0];
                     for (int q = 0; q < 2; ++q)
                     {
+                        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
                         switch (p[q])
                         {
                             case 0: {
@@ -637,7 +638,7 @@ public:
 
         for (auto const& config_string : config_strings)
         {
-            Params params;
+            Params params{};
             params.items = default_items;
             params.threads = threads;
             for (auto i = default_repeat; i--;)
diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp
index 578dd3670e..2177646eaa 100644
--- a/src/test/nodestore/import_test.cpp
+++ b/src/test/nodestore/import_test.cpp
@@ -339,7 +339,7 @@ public:
         }
         // Create data file with values
         std::size_t nitems = 0;
-        dat_file_header dh;
+        dat_file_header dh{};
         dh.version = currentVersion;
         dh.uid = make_uid();
         dh.appnum = 1;
@@ -406,7 +406,7 @@ public:
         if (ec)
             Throw<nudb::system_error>(ec);
         // Create key file
-        key_file_header kh;
+        key_file_header kh{};
         kh.version = currentVersion;
         kh.uid = dh.uid;
         kh.appnum = dh.appnum;
@@ -465,7 +465,7 @@ public:
             {
                 auto const offset = r.offset();
                 // Data Record or Spill Record
-                std::size_t size;
+                std::size_t size = 0;
                 auto is = r.prepare(field<uint48_t>::size, ec);  // Size
                 if (ec)
                     Throw<nudb::system_error>(ec);
diff --git a/src/test/nodestore/varint_test.cpp b/src/test/nodestore/varint_test.cpp
index 7ef624e777..f6145a9f52 100644
--- a/src/test/nodestore/varint_test.cpp
+++ b/src/test/nodestore/varint_test.cpp
@@ -17,11 +17,11 @@ public:
         testcase("encode, decode");
         for (auto const v : vv)
         {
-            std::array<std::uint8_t, varint_traits<std::size_t>::max> vi;
+            std::array<std::uint8_t, varint_traits<std::size_t>::max> vi{};
             auto const n0 = write_varint(vi.data(), v);
             expect(n0 > 0, "write error");
             expect(n0 == size_varint(v), "size error");
-            std::size_t v1;
+            std::size_t v1 = 0;
             auto const n1 = read_varint(vi.data(), n0, v1);
             expect(n1 == n0, "read error");
             expect(v == v1, "wrong value");
diff --git a/src/test/overlay/cluster_test.cpp b/src/test/overlay/cluster_test.cpp
index 60fd5d62b3..6fa4604f78 100644
--- a/src/test/overlay/cluster_test.cpp
+++ b/src/test/overlay/cluster_test.cpp
@@ -121,7 +121,7 @@ public:
         {
             auto member = c->member(node);
             BEAST_EXPECT(static_cast<bool>(member));
-            BEAST_EXPECT(member->empty());
+            BEAST_EXPECT(member->empty());  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         // Updating too quickly: should fail
@@ -129,7 +129,7 @@ public:
         {
             auto member = c->member(node);
             BEAST_EXPECT(static_cast<bool>(member));
-            BEAST_EXPECT(member->empty());
+            BEAST_EXPECT(member->empty());  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         using namespace std::chrono_literals;
@@ -140,7 +140,7 @@ public:
         {
             auto member = c->member(node);
             BEAST_EXPECT(static_cast<bool>(member));
-            BEAST_EXPECT(member->compare(name) == 0);
+            BEAST_EXPECT(member->compare(name) == 0);  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         // Updating the name (non-empty doesn't go to empty)
@@ -149,7 +149,7 @@ public:
         {
             auto member = c->member(node);
             BEAST_EXPECT(static_cast<bool>(member));
-            BEAST_EXPECT(member->compare(name) == 0);
+            BEAST_EXPECT(member->compare(name) == 0);  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         // Updating the name (non-empty updates to new non-empty)
@@ -158,7 +158,8 @@ public:
         {
             auto member = c->member(node);
             BEAST_EXPECT(static_cast<bool>(member));
-            BEAST_EXPECT(member->compare("test") == 0);
+            BEAST_EXPECT(
+                member->compare("test") == 0);  // NOLINT(bugprone-unchecked-optional-access)
         }
     }
 
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index bf6d8aac1c..7e105e9f85 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -249,7 +249,7 @@ public:
         Validator& validator,
         PeerSPtr peer,
         Latency const& latency = {milliseconds(5), milliseconds(15)})
-        : validator_(validator), peer_(peer), latency_(latency), up_(true)
+        : validator_(validator), peer_(peer), latency_(latency)
     {
         auto sp = peer_.lock();
         assert(sp);
@@ -294,7 +294,7 @@ private:
     Validator& validator_;
     PeerWPtr peer_;
     Latency latency_;
-    bool up_;
+    bool up_{true};
 };
 
 /** Simulate Validator */
@@ -468,10 +468,11 @@ public:
     {
         auto validator = m->getValidatorKey();
         assert(validator);
-        if (!squelch_.expireSquelch(*validator))
+        if (!squelch_.expireSquelch(*validator))  // NOLINT(bugprone-unchecked-optional-access)
             return;
 
-        overlay_.updateSlotAndSquelch({}, *validator, id(), f);
+        overlay_.updateSlotAndSquelch(
+            {}, *validator, id(), f);  // NOLINT(bugprone-unchecked-optional-access)
     }
 
     /** Remote Peer (Directly connected Peer) */
@@ -552,7 +553,7 @@ public:
     addPeer(bool useCache = true)
     {
         PeerSPtr peer{};
-        Peer::id_t id;
+        Peer::id_t id = 0;
         if (peersCache_.empty() || !useCache)
         {
             peer = std::make_shared<PeerSim>(*this, logs_.journal("Squelch"));
@@ -900,8 +901,8 @@ protected:
         std::uint32_t cnt_ = 0;
         std::uint32_t handledCnt_ = 0;
         bool isSelected_ = false;
-        Peer::id_t peer_;
-        std::uint16_t validator_;
+        Peer::id_t peer_{};
+        std::uint16_t validator_{};
         std::optional<PublicKey> key_;
         time_point<ManualClock> time_;
         bool handled_ = false;
@@ -1448,7 +1449,7 @@ vp_base_squelch_max_selected_peers=2
 
     struct Handler : public reduce_relay::SquelchHandler
     {
-        Handler() : maxDuration_(0)
+        Handler()
         {
         }
         void
@@ -1461,7 +1462,7 @@ vp_base_squelch_max_selected_peers=2
         unsquelch(PublicKey const&, Peer::id_t) const override
         {
         }
-        mutable int maxDuration_;
+        mutable int maxDuration_{0};
     };
 
     void
diff --git a/src/test/peerfinder/PeerFinder_test.cpp b/src/test/peerfinder/PeerFinder_test.cpp
index 2a9290ac3e..038ed438f0 100644
--- a/src/test/peerfinder/PeerFinder_test.cpp
+++ b/src/test/peerfinder/PeerFinder_test.cpp
@@ -123,7 +123,6 @@ public:
                 if (!BEAST_EXPECT(
                         logic.onConnected(slot, beast::IP::Endpoint::from_string("65.0.0.2:5"))))
                     return;
-                std::string s = ".";
                 if (!BEAST_EXPECT(logic.activate(slot, pk, false) == PeerFinder::Result::success))
                     return;
                 logic.on_closed(slot);
diff --git a/src/test/protocol/Hooks_test.cpp b/src/test/protocol/Hooks_test.cpp
index f4b33f7e4d..a280fd6bd4 100644
--- a/src/test/protocol/Hooks_test.cpp
+++ b/src/test/protocol/Hooks_test.cpp
@@ -134,6 +134,7 @@ class Hooks_test : public beast::unit_test::suite
                 }
 
                 case STI_ACCOUNT: {
+                    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                     AccountID id = *parseBase58<AccountID>("rwfSjJNK2YQuN64bSWn7T2eY9FJAyAPYJT");
                     dummy.setAccountID(f, id);
                     BEAST_EXPECT(dummy.getAccountID(f) == id);
diff --git a/src/test/protocol/MultiApiJson_test.cpp b/src/test/protocol/MultiApiJson_test.cpp
index ccf719e349..0da511b976 100644
--- a/src/test/protocol/MultiApiJson_test.cpp
+++ b/src/test/protocol/MultiApiJson_test.cpp
@@ -556,7 +556,7 @@ struct MultiApiJson_test : beast::unit_test::suite
             static_assert([](auto&& v) {
                 return !requires {
                     v.visitor(
-                        std::move(v),  // cannot bind rvalue
+                        decltype(v){},  // cannot bind rvalue
                         1,
                         [](Json::Value&, auto) {});
                 };
@@ -830,6 +830,7 @@ struct MultiApiJson_test : beast::unit_test::suite
 
             // Rvalue MultivarJson visitor only binds to regular reference
             static_assert([](auto&& v) {
+                // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
                 return !requires { std::forward<decltype(v)>(v).visit(1, [](Json::Value&&) {}); };
             }(std::move(s1)));
             static_assert([](auto&& v) {
@@ -846,6 +847,7 @@ struct MultiApiJson_test : beast::unit_test::suite
                 };
             }(std::move(s1)));
             static_assert([](auto&& v) {
+                // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
                 return !requires { std::forward<decltype(v)>(v).visit()(1, [](Json::Value&&) {}); };
             }(std::move(s1)));
             static_assert([](auto&& v) {
diff --git a/src/test/protocol/PublicKey_test.cpp b/src/test/protocol/PublicKey_test.cpp
index 9a7808db7e..053e945a7b 100644
--- a/src/test/protocol/PublicKey_test.cpp
+++ b/src/test/protocol/PublicKey_test.cpp
@@ -17,7 +17,7 @@ public:
     {
         struct Table
         {
-            int val[256];
+            int val[256]{};
             Table()
             {
                 std::fill(val, val + 256, 0);
@@ -370,7 +370,8 @@ public:
                 auto const skj = parseBase58<PublicKey>(TokenType::NodePublic, sj);
                 BEAST_EXPECT(skj && (keys[j] == *skj));
 
-                BEAST_EXPECT((*ski == *skj) == (i == j));
+                BEAST_EXPECT(
+                    (*ski == *skj) == (i == j));  // NOLINT(bugprone-unchecked-optional-access)
             }
         }
     }
@@ -389,7 +390,7 @@ public:
                 TokenType::NodePublic, "n94a1u4jAz288pZLtw6yFWVbi89YamiC6JBXPVUj5zmExe5fTVg9");
             BEAST_EXPECT(pk2);
 
-            BEAST_EXPECT(pk1 == *pk2);
+            BEAST_EXPECT(pk1 == *pk2);  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         testBase58(KeyType::secp256k1);
@@ -405,7 +406,7 @@ public:
                 TokenType::NodePublic, "nHUeeJCSY2dM71oxM8Cgjouf5ekTuev2mwDpc374aLMxzDLXNmjf");
             BEAST_EXPECT(pk2);
 
-            BEAST_EXPECT(pk1 == *pk2);
+            BEAST_EXPECT(pk1 == *pk2);  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         testBase58(KeyType::ed25519);
diff --git a/src/test/protocol/STAccount_test.cpp b/src/test/protocol/STAccount_test.cpp
index 76b633df80..cab5df9631 100644
--- a/src/test/protocol/STAccount_test.cpp
+++ b/src/test/protocol/STAccount_test.cpp
@@ -106,7 +106,7 @@ struct STAccount_test : public beast::unit_test::suite
         auto const s = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
         if (auto const parsed = parseBase58<AccountID>(s); BEAST_EXPECT(parsed))
         {
-            BEAST_EXPECT(toBase58(*parsed) == s);
+            BEAST_EXPECT(toBase58(*parsed) == s);  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         {
diff --git a/src/test/protocol/STObject_test.cpp b/src/test/protocol/STObject_test.cpp
index 058df3ba82..b809ffccad 100644
--- a/src/test/protocol/STObject_test.cpp
+++ b/src/test/protocol/STObject_test.cpp
@@ -169,8 +169,8 @@ public:
             BEAST_EXPECT(st[sf1Outer] == 1);
             BEAST_EXPECT(st[sf2Outer] == 2);
             except<STObject::FieldErr>([&]() { st[sf3Outer]; });
-            BEAST_EXPECT(*st[~sf1Outer] == 1);
-            BEAST_EXPECT(*st[~sf2Outer] == 2);
+            BEAST_EXPECT(*st[~sf1Outer] == 1);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(*st[~sf2Outer] == 2);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(st[~sf3Outer] == std::nullopt);
             BEAST_EXPECT(!!st[~sf1Outer]);
             BEAST_EXPECT(!!st[~sf2Outer]);
@@ -200,9 +200,9 @@ public:
             BEAST_EXPECT(st[sf1Outer] == 1);
             BEAST_EXPECT(st[sf2Outer] == 2);
             BEAST_EXPECT(st[sf3Outer] == 0);
-            BEAST_EXPECT(*st[~sf1Outer] == 1);
-            BEAST_EXPECT(*st[~sf2Outer] == 2);
-            BEAST_EXPECT(*st[~sf3Outer] == 0);
+            BEAST_EXPECT(*st[~sf1Outer] == 1);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(*st[~sf2Outer] == 2);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(*st[~sf3Outer] == 0);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(!!st[~sf1Outer]);
             BEAST_EXPECT(!!st[~sf2Outer]);
             BEAST_EXPECT(!!st[~sf3Outer]);
@@ -351,7 +351,7 @@ public:
                 Buffer b(1);
                 BEAST_EXPECT(!b.empty());
                 st[sf4] = std::move(b);
-                BEAST_EXPECT(b.empty());
+                BEAST_EXPECT(b.empty());  // NOLINT(bugprone-use-after-move)
                 BEAST_EXPECT(Slice(st[sf4]).size() == 1);
                 st[~sf4] = std::nullopt;
                 BEAST_EXPECT(!~st[~sf4]);
@@ -370,7 +370,7 @@ public:
                 BEAST_EXPECT(!!~st[~sf5]);
                 Buffer b(1);
                 st[sf5] = std::move(b);
-                BEAST_EXPECT(b.empty());
+                BEAST_EXPECT(b.empty());  // NOLINT(bugprone-use-after-move)
                 BEAST_EXPECT(Slice(st[sf5]).size() == 1);
                 st[~sf4] = std::nullopt;
                 BEAST_EXPECT(!~st[~sf4]);
@@ -399,7 +399,7 @@ public:
             st[sf] = std::move(v);
             auto const& cst = st;
             BEAST_EXPECT(cst[sf].size() == 2);
-            BEAST_EXPECT(cst[~sf]->size() == 2);
+            BEAST_EXPECT(cst[~sf]->size() == 2);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(cst[sf][0] == 1);
             BEAST_EXPECT(cst[sf][1] == 2);
             static_assert(
diff --git a/src/test/protocol/STParsedJSON_test.cpp b/src/test/protocol/STParsedJSON_test.cpp
index 6838f557a9..97da346015 100644
--- a/src/test/protocol/STParsedJSON_test.cpp
+++ b/src/test/protocol/STParsedJSON_test.cpp
@@ -27,7 +27,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfCloseResolution] = 255;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfCloseResolution));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU8(sfCloseResolution) == 255);
         }
 
@@ -37,7 +39,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfCloseResolution] = 255u;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfCloseResolution));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU8(sfCloseResolution) == 255);
         }
 
@@ -47,7 +51,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfCloseResolution] = "255";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfCloseResolution));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU8(sfCloseResolution) == 255);
         }
 
@@ -57,6 +63,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfCloseResolution] = 0;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU8(sfCloseResolution) == 0);
         }
 
@@ -103,7 +110,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerEntryType] = 65535;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerEntryType));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU16(sfLedgerEntryType) == 65535);
         }
 
@@ -113,7 +122,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerEntryType] = 65535u;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerEntryType));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU16(sfLedgerEntryType) == 65535);
         }
 
@@ -123,7 +134,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerEntryType] = "65535";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerEntryType));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU16(sfLedgerEntryType) == 65535);
         }
 
@@ -133,6 +146,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerEntryType] = 0;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU16(sfLedgerEntryType) == 0);
         }
 
@@ -194,7 +208,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNetworkID] = 4294967295u;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNetworkID));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU32(sfNetworkID) == 4294967295u);
         }
 
@@ -204,7 +220,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNetworkID] = "4294967295";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNetworkID));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU32(sfNetworkID) == 4294967295u);
         }
 
@@ -214,6 +232,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNetworkID] = 0;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU32(sfNetworkID) == 0);
         }
 
@@ -259,7 +278,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfIndexNext] = "ffffffffffffffff";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfIndexNext));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU64(sfIndexNext) == 18446744073709551615ull);
         }
 
@@ -269,6 +290,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfIndexNext] = 0;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldU64(sfIndexNext) == 0ull);
         }
 
@@ -333,7 +355,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfEmailHash] = "0123456789ABCDEF0123456789ABCDEF";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfEmailHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash).size() == 16);
             std::array<uint8_t, 16> expected = {
                 0x01,
@@ -352,6 +376,7 @@ class STParsedJSON_test : public beast::unit_test::suite
                 0xAB,
                 0xCD,
                 0xEF};
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash) == uint128{expected});
         }
 
@@ -361,7 +386,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfEmailHash] = "0123456789abcdef0123456789abcdef";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfEmailHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash).size() == 16);
         }
 
@@ -371,7 +398,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfEmailHash] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfEmailHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h128 = obj.object->getFieldH128(sfEmailHash);
             BEAST_EXPECT(h128.size() == 16);
             bool allZero = std::all_of(h128.begin(), h128.end(), [](auto b) { return b == 0; });
@@ -436,11 +465,14 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfTakerPaysCurrency] = "0123456789ABCDEF0123456789ABCDEF01234567";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfTakerPaysCurrency));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency).size() == 20);
             std::array<uint8_t, 20> expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD,
                                                 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB,
                                                 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67};
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency) == uint160{expected});
         }
         // Valid lowercase hex string for UInt160
@@ -449,7 +481,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfTakerPaysCurrency] = "0123456789abcdef0123456789abcdef01234567";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfTakerPaysCurrency));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency).size() == 20);
         }
 
@@ -459,7 +493,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfTakerPaysCurrency] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfTakerPaysCurrency));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h160 = obj.object->getFieldH160(sfTakerPaysCurrency);
             BEAST_EXPECT(h160.size() == 20);
             bool allZero = std::all_of(h160.begin(), h160.end(), [](auto b) { return b == 0; });
@@ -516,11 +552,14 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfMPTokenIssuanceID] = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfMPTokenIssuanceID));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID).size() == 24);
             std::array<uint8_t, 24> expected = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID) == uint192{expected});
         }
 
@@ -530,7 +569,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfMPTokenIssuanceID] = "ffffffffffffffffffffffffffffffffffffffffffffffff";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfMPTokenIssuanceID));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID).size() == 24);
         }
 
@@ -540,7 +581,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfMPTokenIssuanceID] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfMPTokenIssuanceID));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h192 = obj.object->getFieldH192(sfMPTokenIssuanceID);
             BEAST_EXPECT(h192.size() == 24);
             bool allZero = std::all_of(h192.begin(), h192.end(), [](auto b) { return b == 0; });
@@ -608,12 +651,15 @@ class STParsedJSON_test : public beast::unit_test::suite
                 "EF";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash).size() == 32);
             std::array<uint8_t, 32> expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
                                                 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
                                                 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
                                                 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash) == uint256{expected});
         }
         // Valid lowercase hex string for UInt256
@@ -624,7 +670,9 @@ class STParsedJSON_test : public beast::unit_test::suite
                 "ef";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash).size() == 32);
         }
 
@@ -634,7 +682,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerHash] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerHash));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h256 = obj.object->getFieldH256(sfLedgerHash);
             BEAST_EXPECT(h256.size() == 32);
             bool allZero = std::all_of(h256.begin(), h256.end(), [](auto b) { return b == 0; });
@@ -704,8 +754,12 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLoanScale] = minInt32;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             if (BEAST_EXPECT(obj.object->isFieldPresent(sfLoanScale)))
+            {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->getFieldI32(sfLoanScale) == minInt32);
+            }
         }
 
         // max value
@@ -715,8 +769,12 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLoanScale] = maxInt32;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             if (BEAST_EXPECT(obj.object->isFieldPresent(sfLoanScale)))
+            {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->getFieldI32(sfLoanScale) == maxInt32);
+            }
         }
 
         // max uint value
@@ -726,9 +784,13 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLoanScale] = maxUInt32;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             if (BEAST_EXPECT(obj.object->isFieldPresent(sfLoanScale)))
+            {
                 BEAST_EXPECT(
+                    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                     obj.object->getFieldI32(sfLoanScale) == static_cast<int32_t>(maxUInt32));
+            }
         }
 
         // Test with string value
@@ -737,8 +799,12 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLoanScale] = "2147483647";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             if (BEAST_EXPECT(obj.object->isFieldPresent(sfLoanScale)))
+            {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->getFieldI32(sfLoanScale) == 2147483647u);
+            }
         }
 
         // Test with string negative value
@@ -748,8 +814,12 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLoanScale] = std::to_string(value);
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             if (BEAST_EXPECT(obj.object->isFieldPresent(sfLoanScale)))
+            {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->getFieldI32(sfLoanScale) == value);
+            }
         }
 
         // Test out of range value for int32 (negative)
@@ -803,8 +873,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfPublicKey] = "DEADBEEF";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfPublicKey));
-            auto const& blob = obj.object->getFieldVL(sfPublicKey);
+            auto const& blob =
+                obj.object->getFieldVL(sfPublicKey);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(blob.size() == 4);
             BEAST_EXPECT(blob[0] == 0xDE);
             BEAST_EXPECT(blob[1] == 0xAD);
@@ -818,8 +890,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfPublicKey] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfPublicKey));
-            auto const& blob = obj.object->getFieldVL(sfPublicKey);
+            auto const& blob =
+                obj.object->getFieldVL(sfPublicKey);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(blob.size() == 0);
         }
 
@@ -829,8 +903,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfPublicKey] = "deadbeef";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfPublicKey));
-            auto const& blob = obj.object->getFieldVL(sfPublicKey);
+            auto const& blob =
+                obj.object->getFieldVL(sfPublicKey);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(blob.size() == 4);
             BEAST_EXPECT(blob[0] == 0xDE);
             BEAST_EXPECT(blob[1] == 0xAD);
@@ -880,8 +956,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfHashes] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfHashes));
-            auto const& vec = obj.object->getFieldV256(sfHashes);
+            auto const& vec =
+                obj.object->getFieldV256(sfHashes);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(vec.size() == 2);
             BEAST_EXPECT(to_string(vec[0]) == arr[0u].asString());
             BEAST_EXPECT(to_string(vec[1]) == arr[1u].asString());
@@ -893,8 +971,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfHashes] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfHashes));
-            auto const& vec = obj.object->getFieldV256(sfHashes);
+            auto const& vec =
+                obj.object->getFieldV256(sfHashes);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(vec.size() == 0);
         }
 
@@ -959,8 +1039,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfAccount] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfAccount));
-            auto const& acct = obj.object->getAccountID(sfAccount);
+            auto const& acct =
+                obj.object->getAccountID(sfAccount);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(acct.size() == 20);
             BEAST_EXPECT(toBase58(acct) == "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh");
         }
@@ -971,8 +1053,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfAccount] = "000102030405060708090A0B0C0D0E0F10111213";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfAccount));
-            auto const& acct = obj.object->getAccountID(sfAccount);
+            auto const& acct =
+                obj.object->getAccountID(sfAccount);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(acct.size() == 20);
         }
 
@@ -1043,7 +1127,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfBaseAsset] = "USD";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfBaseAsset));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& curr = obj.object->getFieldCurrency(sfBaseAsset);
             BEAST_EXPECT(curr.currency().size() == 20);
         }
@@ -1054,7 +1140,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfBaseAsset] = "EUR";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfBaseAsset));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& curr = obj.object->getFieldCurrency(sfBaseAsset);
             BEAST_EXPECT(curr.currency().size() == 20);
         }
@@ -1064,7 +1152,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value j;
             j[sfBaseAsset] = "0123456789ABCDEF01230123456789ABCDEF0123";
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfBaseAsset));
                 auto const& curr = obj.object->getFieldCurrency(sfBaseAsset);
@@ -1086,7 +1174,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfBaseAsset] = "usd";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfBaseAsset));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& curr = obj.object->getFieldCurrency(sfBaseAsset);
             BEAST_EXPECT(curr.currency().size() == 20);
         }
@@ -1113,7 +1203,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfBaseAsset] = "";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfBaseAsset));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& curr = obj.object->getFieldCurrency(sfBaseAsset);
             BEAST_EXPECT(curr.currency().size() == 20);
         }
@@ -1145,7 +1237,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfAmount] = "100000000000000000";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfAmount));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldAmount(sfAmount) == STAmount(100000000000000000ull));
         }
 
@@ -1155,7 +1249,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfAmount] = 4294967295u;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfAmount));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldAmount(sfAmount) == STAmount(4294967295u));
         }
 
@@ -1211,7 +1307,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             STParsedJSONObject obj("Test", j);
             if (BEAST_EXPECT(obj.object.has_value()))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->isFieldPresent(sfPaths));
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 auto const& ps = obj.object->getFieldPathSet(sfPaths);
                 BEAST_EXPECT(!ps.empty());
                 BEAST_EXPECT(ps.size() == 1);
@@ -1240,8 +1338,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfPaths] = pathset;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
-            BEAST_EXPECT(obj.object->isFieldPresent(sfPaths));
-            auto const& ps = obj.object->getFieldPathSet(sfPaths);
+            BEAST_EXPECT(
+                obj.object->isFieldPresent(sfPaths));  // NOLINT(bugprone-unchecked-optional-access)
+            auto const& ps =
+                obj.object->getFieldPathSet(sfPaths);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(!ps.empty());
         }
 
@@ -1391,8 +1491,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             STParsedJSONObject obj("Test", j);
             if (BEAST_EXPECT(obj.object.has_value()))
             {
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 BEAST_EXPECT(obj.object->isFieldPresent(sfAsset));
-                auto const& issueField = (*obj.object)[sfAsset];
+                auto const& issueField =
+                    (*obj.object)[sfAsset];  // NOLINT(bugprone-unchecked-optional-access)
                 auto const issue = issueField.value().get<Issue>();
                 BEAST_EXPECT(issue.currency.size() == 20);
                 BEAST_EXPECT(to_string(issue.currency) == "USD");
@@ -1410,7 +1512,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issueJson["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfAsset] = issueJson;
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfAsset));
                 auto const& issueField = (*obj.object)[sfAsset];
@@ -1427,7 +1529,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issueJson["mpt_issuance_id"] = "0000000000000000000000004D5054494431323334234234";
             j[sfAsset] = issueJson;
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfAsset));
                 auto const& issueField = (*obj.object)[sfAsset];
@@ -1529,7 +1631,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["IssuingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfXChainBridge));
                 auto const& bridgeField = (*obj.object)[sfXChainBridge];
@@ -1554,7 +1656,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["IssuingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfXChainBridge));
                 auto const& bridgeField = (*obj.object)[sfXChainBridge];
@@ -1708,7 +1810,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNumber] = 12345;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(12345, 0));
         }
 
@@ -1718,7 +1822,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNumber] = 12345u;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(12345, 0));
         }
 
@@ -1728,7 +1834,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNumber] = "67890";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(67890, 0));
         }
 
@@ -1738,7 +1846,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNumber] = -42;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(-42, 0));
         }
 
@@ -1748,7 +1858,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfNumber] = "-123";
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(-123, 0));
         }
 
@@ -1757,7 +1869,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value j;
             j[sfNumber] = "3.14159";
             STParsedJSONObject obj("Test", j);
-            if (BEAST_EXPECT(obj.object.has_value()))
+            if (BEAST_EXPECT(obj.object); obj.object.has_value())
             {
                 BEAST_EXPECT(obj.object->isFieldPresent(sfNumber));
                 BEAST_EXPECT(obj.object->getFieldNumber(sfNumber).value() == Number(314159, -5));
@@ -1809,7 +1921,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfTransactionMetaData] = objVal;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfTransactionMetaData));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& result = obj.object->peekFieldObject(sfTransactionMetaData);
             BEAST_EXPECT(result.getFieldU8(sfTransactionResult) == 1);
         }
@@ -1856,6 +1970,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfTransactionMetaData] = obj;
             STParsedJSONObject parsed("Test", j);
             BEAST_EXPECT(parsed.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(parsed.object->isFieldPresent(sfTransactionMetaData));
         }
 
@@ -1893,7 +2008,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfSignerEntries] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfSignerEntries));
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& result = obj.object->getFieldArray(sfSignerEntries);
             if (BEAST_EXPECT(result.size() == 1))
             {
@@ -1965,6 +2082,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfSignerEntries] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->isFieldPresent(sfSignerEntries));
         }
 
@@ -2038,6 +2156,7 @@ class STParsedJSON_test : public beast::unit_test::suite
                 if (BEAST_EXPECT(parsed.object))
                 {
                     std::string const& serialized(
+                        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                         to_string(parsed.object->getJson(JsonOptions::none)));
                     BEAST_EXPECT(serialized == goodJson);
                 }
@@ -2062,6 +2181,7 @@ class STParsedJSON_test : public beast::unit_test::suite
                 if (BEAST_EXPECT(parsed.object))
                 {
                     std::string const& serialized(
+                        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                         to_string(parsed.object->getJson(JsonOptions::none)));
                     BEAST_EXPECT(serialized == expectedJson);
                 }
@@ -2086,6 +2206,7 @@ class STParsedJSON_test : public beast::unit_test::suite
                 if (BEAST_EXPECT(parsed.object))
                 {
                     std::string const& serialized(
+                        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                         to_string(parsed.object->getJson(JsonOptions::none)));
                     BEAST_EXPECT(serialized == expectedJson);
                 }
@@ -2194,6 +2315,7 @@ class STParsedJSON_test : public beast::unit_test::suite
                 if (BEAST_EXPECT(parsed.object))
                 {
                     std::string const& serialized(
+                        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                         to_string(parsed.object->getJson(JsonOptions::none)));
                     BEAST_EXPECT(serialized == expectedJson);
                 }
diff --git a/src/test/protocol/STTx_test.cpp b/src/test/protocol/STTx_test.cpp
index 86e5e88d0a..93cfd16d3d 100644
--- a/src/test/protocol/STTx_test.cpp
+++ b/src/test/protocol/STTx_test.cpp
@@ -1343,10 +1343,11 @@ public:
         }
 
         STParsedJSONObject parsed("test", j.getJson(JsonOptions::none));
-        if (!parsed.object)
+        if (!parsed.object.has_value())
+        {
             fail("Unable to build object from json");
-
-        if (STObject(j) != parsed.object)
+        }
+        else if (STObject(j) != parsed.object)
         {
             log << "ORIG: " << j.getJson(JsonOptions::none) << '\n'
                 << "BUILT " << parsed.object->getJson(JsonOptions::none) << std::endl;
@@ -1474,7 +1475,7 @@ public:
         // Signer {
         //     Account: "...",
         //     TxnSignature: "...",
-        //     PublicKey: "...""
+        //     PublicKey: "..."
         // }
         // Make one well formed Signer and several mal-formed ones.  See
         // whether the serializer lets the good one through and catches
diff --git a/src/test/protocol/SecretKey_test.cpp b/src/test/protocol/SecretKey_test.cpp
index de21c7d88b..43065d4e40 100644
--- a/src/test/protocol/SecretKey_test.cpp
+++ b/src/test/protocol/SecretKey_test.cpp
@@ -1,3 +1,5 @@
+#include <test/unit_test/utils.h>
+
 #include <xrpl/beast/unit_test.h>
 #include <xrpl/beast/utility/rngfill.h>
 #include <xrpl/crypto/csprng.h>
@@ -70,12 +72,16 @@ public:
         {
             auto const canonicality = ecdsaCanonicality(makeSlice(sig));
             BEAST_EXPECT(canonicality);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(*canonicality == ECDSACanonicality::fullyCanonical);
         }
 
         {
             auto const canonicality = ecdsaCanonicality(makeSlice(non));
             BEAST_EXPECT(canonicality);
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(*canonicality != ECDSACanonicality::fullyCanonical);
         }
 
@@ -95,6 +101,8 @@ public:
             auto const [pk, sk] = randomKeyPair(KeyType::secp256k1);
 
             BEAST_EXPECT(pk == derivePublicKey(KeyType::secp256k1, sk));
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(*publicKeyType(pk) == KeyType::secp256k1);
 
             for (std::size_t j = 0; j < 32; j++)
@@ -133,7 +141,7 @@ public:
             auto const [pk, sk] = randomKeyPair(type);
 
             BEAST_EXPECT(pk == derivePublicKey(type, sk));
-            BEAST_EXPECT(*publicKeyType(pk) == type);
+            BEAST_EXPECT(*publicKeyType(pk) == type);  // NOLINT(bugprone-unchecked-optional-access)
 
             for (std::size_t j = 0; j < 32; j++)
             {
@@ -183,7 +191,7 @@ public:
                 TokenType::NodePrivate, "pnen77YEeUd4fFKG7iycBWcwKpTaeFRkW2WFostaATy1DSupwXe");
             BEAST_EXPECT(sk2);
 
-            BEAST_EXPECT(sk1 == *sk2);
+            BEAST_EXPECT(test::equal(sk1, *sk2));  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         {
@@ -193,7 +201,7 @@ public:
                 TokenType::NodePrivate, "paKv46LztLqK3GaKz1rG2nQGN6M4JLyRtxFBYFTw4wAVHtGys36");
             BEAST_EXPECT(sk2);
 
-            BEAST_EXPECT(sk1 == *sk2);
+            BEAST_EXPECT(test::equal(sk1, *sk2));  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         // Try converting short, long and malformed data
@@ -261,20 +269,21 @@ public:
             BEAST_EXPECT(!si.empty());
 
             auto const ski = parseBase58<SecretKey>(TokenType::NodePrivate, si);
-            BEAST_EXPECT(ski && keys[i] == *ski);
+            BEAST_EXPECT(ski && test::equal(keys[i], *ski));
 
             for (std::size_t j = i; j != keys.size(); ++j)
             {
-                BEAST_EXPECT((keys[i] == keys[j]) == (i == j));
+                BEAST_EXPECT(test::equal(keys[i], keys[j]) == (i == j));
 
                 auto const sj = toBase58(TokenType::NodePrivate, keys[j]);
 
                 BEAST_EXPECT((si == sj) == (i == j));
 
                 auto const skj = parseBase58<SecretKey>(TokenType::NodePrivate, sj);
-                BEAST_EXPECT(skj && keys[j] == *skj);
+                BEAST_EXPECT(skj && test::equal(keys[j], *skj));
 
-                BEAST_EXPECT((*ski == *skj) == (i == j));
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+                BEAST_EXPECT(test::equal(*ski, *skj) == (i == j));
             }
         }
     }
@@ -292,8 +301,9 @@ public:
             auto kp = generateKeyPair(KeyType::secp256k1, Seed{makeSlice(test.seed)});
 
             BEAST_EXPECT(kp.first == PublicKey{makeSlice(test.pubkey)});
-            BEAST_EXPECT(kp.second == SecretKey{makeSlice(test.seckey)});
-            BEAST_EXPECT(calcAccountID(kp.first) == *id);
+            BEAST_EXPECT(test::equal(kp.second, SecretKey{makeSlice(test.seckey)}));
+            BEAST_EXPECT(
+                calcAccountID(kp.first) == *id);  // NOLINT(bugprone-unchecked-optional-access)
         }
     }
 
@@ -310,8 +320,9 @@ public:
             auto kp = generateKeyPair(KeyType::ed25519, Seed{makeSlice(test.seed)});
 
             BEAST_EXPECT(kp.first == PublicKey{makeSlice(test.pubkey)});
-            BEAST_EXPECT(kp.second == SecretKey{makeSlice(test.seckey)});
-            BEAST_EXPECT(calcAccountID(kp.first) == *id);
+            BEAST_EXPECT(test::equal(kp.second, SecretKey{makeSlice(test.seckey)}));
+            BEAST_EXPECT(
+                calcAccountID(kp.first) == *id);  // NOLINT(bugprone-unchecked-optional-access)
         }
     }
 
diff --git a/src/test/protocol/Seed_test.cpp b/src/test/protocol/Seed_test.cpp
index 9f0ce68c46..d516ec3e59 100644
--- a/src/test/protocol/Seed_test.cpp
+++ b/src/test/protocol/Seed_test.cpp
@@ -50,7 +50,7 @@ public:
         auto const seed2 = parseBase58<Seed>(toBase58(seed1));
 
         BEAST_EXPECT(static_cast<bool>(seed2));
-        BEAST_EXPECT(equal(seed1, *seed2));
+        BEAST_EXPECT(equal(seed1, *seed2));  // NOLINT(bugprone-unchecked-optional-access)
         return toBase58(seed1);
     }
 
@@ -93,7 +93,7 @@ public:
             auto const seed2 = parseBase58<Seed>(toBase58(seed1));
 
             BEAST_EXPECT(static_cast<bool>(seed2));
-            BEAST_EXPECT(equal(seed1, *seed2));
+            BEAST_EXPECT(equal(seed1, *seed2));  // NOLINT(bugprone-unchecked-optional-access)
         }
     }
 
diff --git a/src/test/rpc/AccountCurrencies_test.cpp b/src/test/rpc/AccountCurrencies_test.cpp
index c317bfc31c..bb8ccf0a85 100644
--- a/src/test/rpc/AccountCurrencies_test.cpp
+++ b/src/test/rpc/AccountCurrencies_test.cpp
@@ -142,7 +142,7 @@ class AccountCurrencies_test : public beast::unit_test::suite
 
         // now form a payment for each currency
         for (auto const& c : gwCurrencies)
-            env(pay(gw, alice, c.value()(50)));
+            env(pay(gw, alice, c.value()(50)));  // NOLINT(bugprone-unchecked-optional-access)
 
         // send_currencies should be populated now
         result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
diff --git a/src/test/rpc/AccountInfo_test.cpp b/src/test/rpc/AccountInfo_test.cpp
index a67eef996d..518398f9ea 100644
--- a/src/test/rpc/AccountInfo_test.cpp
+++ b/src/test/rpc/AccountInfo_test.cpp
@@ -502,11 +502,12 @@ public:
             Json::Value params;
             params[jss::account] = account.human();
             auto const info = env.rpc("json", "account_info", to_string(params));
+            auto const name = std::string(fName);
 
             std::optional<bool> res;
             if (info[jss::result][jss::status] == "success" &&
-                info[jss::result][jss::account_flags].isMember(fName.data()))
-                res.emplace(info[jss::result][jss::account_flags][fName.data()].asBool());
+                info[jss::result][jss::account_flags].isMember(name))
+                res.emplace(info[jss::result][jss::account_flags][name].asBool());
 
             return res;
         };
@@ -528,7 +529,7 @@ public:
             env.close();
             auto const f1 = getAccountFlag(asf.first, alice);
             BEAST_EXPECT(f1.has_value());
-            BEAST_EXPECT(!f1.value());
+            BEAST_EXPECT(!f1.value());  // NOLINT(bugprone-unchecked-optional-access)
 
             // Set a flag and check that account_info returns results
             // as expected
@@ -536,7 +537,7 @@ public:
             env.close();
             auto const f2 = getAccountFlag(asf.first, alice);
             BEAST_EXPECT(f2.has_value());
-            BEAST_EXPECT(f2.value());
+            BEAST_EXPECT(f2.value());  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         static constexpr std::array<std::pair<std::string_view, std::uint32_t>, 4>
@@ -554,7 +555,7 @@ public:
             env.close();
             auto const f1 = getAccountFlag(asf.first, alice);
             BEAST_EXPECT(f1.has_value());
-            BEAST_EXPECT(!f1.value());
+            BEAST_EXPECT(!f1.value());  // NOLINT(bugprone-unchecked-optional-access)
 
             // Set a flag and check that account_info returns results
             // as expected
@@ -562,7 +563,7 @@ public:
             env.close();
             auto const f2 = getAccountFlag(asf.first, alice);
             BEAST_EXPECT(f2.has_value());
-            BEAST_EXPECT(f2.value());
+            BEAST_EXPECT(f2.value());  // NOLINT(bugprone-unchecked-optional-access)
         }
 
         static constexpr std::pair<std::string_view, std::uint32_t> allowTrustLineClawbackFlag{
@@ -573,14 +574,14 @@ public:
             // must use bob's account because alice has noFreeze set
             auto const f1 = getAccountFlag(allowTrustLineClawbackFlag.first, bob);
             BEAST_EXPECT(f1.has_value());
-            BEAST_EXPECT(!f1.value());
+            BEAST_EXPECT(!f1.value());  // NOLINT(bugprone-unchecked-optional-access)
 
             // Set allowTrustLineClawback
             env(fset(bob, allowTrustLineClawbackFlag.second));
             env.close();
             auto const f2 = getAccountFlag(allowTrustLineClawbackFlag.first, bob);
             BEAST_EXPECT(f2.has_value());
-            BEAST_EXPECT(f2.value());
+            BEAST_EXPECT(f2.value());  // NOLINT(bugprone-unchecked-optional-access)
         }
         else
         {
@@ -594,14 +595,14 @@ public:
         {
             auto const f1 = getAccountFlag(allowTrustLineLockingFlag.first, bob);
             BEAST_EXPECT(f1.has_value());
-            BEAST_EXPECT(!f1.value());
+            BEAST_EXPECT(!f1.value());  // NOLINT(bugprone-unchecked-optional-access)
 
             // Set allowTrustLineLocking
             env(fset(bob, allowTrustLineLockingFlag.second));
             env.close();
             auto const f2 = getAccountFlag(allowTrustLineLockingFlag.first, bob);
             BEAST_EXPECT(f2.has_value());
-            BEAST_EXPECT(f2.value());
+            BEAST_EXPECT(f2.value());  // NOLINT(bugprone-unchecked-optional-access)
         }
         else
         {
diff --git a/src/test/rpc/AccountObjects_test.cpp b/src/test/rpc/AccountObjects_test.cpp
index 7c1877136d..090f2a43b9 100644
--- a/src/test/rpc/AccountObjects_test.cpp
+++ b/src/test/rpc/AccountObjects_test.cpp
@@ -7,7 +7,7 @@
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/protocol/nft.h>
-#include <xrpl/tx/transactors/NFT/NFTokenMint.h>
+#include <xrpl/tx/transactors/nft/NFTokenMint.h>
 
 #include <boost/utility/string_ref.hpp>
 
diff --git a/src/test/rpc/Book_test.cpp b/src/test/rpc/Book_test.cpp
index c9d93b87a6..7ebe6e97ae 100644
--- a/src/test/rpc/Book_test.cpp
+++ b/src/test/rpc/Book_test.cpp
@@ -30,7 +30,7 @@ class Book_test : public beast::unit_test::suite
         {
             auto sleOfferDir = view->read(keylet::page(key.value()));
             uint256 offerIndex;
-            unsigned int bookEntry;
+            unsigned int bookEntry = 0;
             cdirFirst(*view, sleOfferDir->key(), sleOfferDir, bookEntry, offerIndex);
             auto sleOffer = view->read(keylet::offer(offerIndex));
             dir = to_string(sleOffer->getFieldH256(sfBookDirectory));
diff --git a/src/test/rpc/DeliveredAmount_test.cpp b/src/test/rpc/DeliveredAmount_test.cpp
index e024e249c3..c156a566b0 100644
--- a/src/test/rpc/DeliveredAmount_test.cpp
+++ b/src/test/rpc/DeliveredAmount_test.cpp
@@ -287,7 +287,6 @@ class DeliveredAmount_test : public beast::unit_test::suite
             env.require(balance(carol, USD(0)));
 
             env.close();
-            std::string index;
             Json::Value jvParams;
             jvParams[jss::ledger_index] = 4u;
             jvParams[jss::transactions] = true;
diff --git a/src/test/rpc/DepositAuthorized_test.cpp b/src/test/rpc/DepositAuthorized_test.cpp
index 755609439c..9d6de94ccc 100644
--- a/src/test/rpc/DepositAuthorized_test.cpp
+++ b/src/test/rpc/DepositAuthorized_test.cpp
@@ -398,24 +398,16 @@ public:
 
         {
             static std::vector<std::string> const credIds = {
-                "18004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "28004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "38004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "48004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "58004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "68004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "78004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "88004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4",
-                "98004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
-                "E4"};
+                "18004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "28004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "38004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "48004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "58004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "68004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "78004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "88004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+                "98004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288BE4",
+            };
             assert(credIds.size() > maxCredentialsArraySize);
 
             testcase("deposit_authorized too long credentials");
diff --git a/src/test/rpc/Feature_test.cpp b/src/test/rpc/Feature_test.cpp
index cecd1304ff..a7cafd5564 100644
--- a/src/test/rpc/Feature_test.cpp
+++ b/src/test/rpc/Feature_test.cpp
@@ -2,6 +2,7 @@
 
 #include <xrpl/ledger/AmendmentTable.h>
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/jss.h>
 
 namespace xrpl {
@@ -94,7 +95,8 @@ class Feature_test : public beast::unit_test::suite
         {
             (void)vote;
             auto const registered = getRegisteredFeature(feature);
-            if (BEAST_EXPECT(registered))
+
+            if (BEAST_EXPECT(registered); registered.has_value())
             {
                 BEAST_EXPECT(featureToName(*registered) == feature);
                 BEAST_EXPECT(
@@ -168,16 +170,18 @@ class Feature_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env{*this};
 
-        auto jrr = env.rpc("feature", "fixAMMOverflowOffer")[jss::result];
+        std::string const name = "fixAMMOverflowOffer";
+        auto jrr = env.rpc("feature", name)[jss::result];
         BEAST_EXPECTS(jrr[jss::status] == jss::success, "status");
         jrr.removeMember(jss::status);
         BEAST_EXPECT(jrr.size() == 1);
-        BEAST_EXPECT(jrr.isMember(
-            "12523DF04B553A0B1AD74F42DDB741DE8DC06A03FC089A0EF197E"
-            "2A87F1D8107"));
+        auto const expected = to_string(sha512Half(Slice(name.data(), name.size())));
+        char const sha[] = "12523DF04B553A0B1AD74F42DDB741DE8DC06A03FC089A0EF197E2A87F1D8107";
+        BEAST_EXPECT(expected == sha);
+        BEAST_EXPECT(jrr.isMember(expected));
         auto feature = *(jrr.begin());
 
-        BEAST_EXPECTS(feature[jss::name] == "fixAMMOverflowOffer", "name");
+        BEAST_EXPECTS(feature[jss::name] == name, "name");
         BEAST_EXPECTS(!feature[jss::enabled].asBool(), "enabled");
         BEAST_EXPECTS(feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(), "vetoed");
         BEAST_EXPECTS(feature[jss::supported].asBool(), "supported");
@@ -186,6 +190,37 @@ class Feature_test : public beast::unit_test::suite
         jrr = env.rpc("feature", "fMM")[jss::result];
         BEAST_EXPECT(jrr[jss::error] == "badFeature");
         BEAST_EXPECT(jrr[jss::error_message] == "Feature unknown or invalid.");
+
+        // Test feature name size checks
+        constexpr auto ok63Name = [] {
+            return "123456789012345678901234567890123456789012345678901234567890123";
+        };
+        static_assert(validFeatureNameSize(ok63Name));
+
+        constexpr auto bad64Name = [] {
+            return "1234567890123456789012345678901234567890123456789012345678901234";
+        };
+        static_assert(!validFeatureNameSize(bad64Name));
+
+        constexpr auto ok31Name = [] { return "1234567890123456789012345678901"; };
+        static_assert(validFeatureNameSize(ok31Name));
+
+        constexpr auto bad32Name = [] { return "12345678901234567890123456789012"; };
+        static_assert(!validFeatureNameSize(bad32Name));
+
+        constexpr auto ok33Name = [] { return "123456789012345678901234567890123"; };
+        static_assert(validFeatureNameSize(ok33Name));
+
+        // Test feature character set checks
+        constexpr auto okName = [] { return "AMM_123"; };
+        static_assert(validFeatureName(okName));
+
+        // First character is Greek Capital Alpha, visually confusable with ASCII 'A'
+        constexpr auto badName = [] { return "ΑMM_123"; };
+        static_assert(!validFeatureName(badName));
+
+        constexpr auto badEmoji = [] { return "🔥"; };
+        static_assert(!validFeatureName(badEmoji));
     }
 
     void
diff --git a/src/test/rpc/GatewayBalances_test.cpp b/src/test/rpc/GatewayBalances_test.cpp
index 6415f6a51f..0deb1fc627 100644
--- a/src/test/rpc/GatewayBalances_test.cpp
+++ b/src/test/rpc/GatewayBalances_test.cpp
@@ -223,6 +223,45 @@ public:
         expect(jv[jss::result][jss::obligations]["USD"] == maxUSD.getText());
     }
 
+    void
+    testGWBWithMPT()
+    {
+        testcase("Gateway Balances with MPT Escrow");
+        using namespace std::chrono_literals;
+        using namespace jtx;
+
+        // Ensure MPT is enabled
+        FeatureBitset features = testable_amendments() | featureMPTokensV1;
+        Env env(*this, features);
+
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+
+        env.fund(XRP(10000), alice, bob);
+        env.close();
+
+        // Create MPT issuance (Alice) with Escrow capability
+        MPTTester mpt(env, alice, {.holders = {bob}, .fund = false});
+        mpt.create({.flags = tfMPTCanEscrow});
+
+        // Authorize Bob and fund him
+        mpt.authorize({.account = bob, .holderCount = 1});
+        mpt.pay(alice, bob, 1000);
+
+        // Bob creates an escrow of MPT to Alice.
+        auto const MPT = mpt["MPT"];
+        env(escrow::create(bob, alice, MPT(100)), escrow::finish_time(env.now() + 10s));
+        env.close();
+
+        // Query gateway_balances for Bob.
+        auto wsc = makeWSClient(env.app().config());
+        Json::Value qry;
+        qry[jss::account] = bob.human();
+
+        auto jv = wsc->invoke("gateway_balances", qry);
+        expect(jv[jss::status] == "success");
+    }
+
     void
     run() override
     {
@@ -233,7 +272,7 @@ public:
             testGWB(feature);
             testGWBApiVersions(feature);
         }
-
+        testGWBWithMPT();
         testGWBOverflow();
     }
 };
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
index b900afa178..5facd683a5 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -233,6 +233,7 @@ public:
                 Oracle oracle(
                     env,
                     {.owner = oracles[i].first,
+                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                      .documentID = asUInt(*oracles[i].second),
                      .fee = baseFee},
                     false);
@@ -247,6 +248,7 @@ public:
                 Oracle oracle(
                     env,
                     {.owner = oracles[i].first,
+                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                      .documentID = asUInt(*oracles[i].second),
                      .fee = baseFee},
                     false);
@@ -286,6 +288,7 @@ public:
                 Oracle oracle(
                     env,
                     {.owner = oracles[i].first,
+                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                      .documentID = asUInt(*oracles[i].second),
                      .fee = baseFee},
                     false);
diff --git a/src/test/rpc/KeyGeneration_test.cpp b/src/test/rpc/KeyGeneration_test.cpp
index 3bffb9dc83..dc46a66c07 100644
--- a/src/test/rpc/KeyGeneration_test.cpp
+++ b/src/test/rpc/KeyGeneration_test.cpp
@@ -294,7 +294,7 @@ public:
 
                 auto ret = keypairForSignature(params, error);
                 BEAST_EXPECT(!contains_error(error));
-                if (BEAST_EXPECT(ret))
+                if (BEAST_EXPECT(ret); ret.has_value())
                 {
                     BEAST_EXPECT(ret->first.size() != 0);
                     BEAST_EXPECT(ret->first == publicKey);
@@ -308,7 +308,7 @@ public:
 
                 auto ret = keypairForSignature(params, error);
                 BEAST_EXPECT(!contains_error(error));
-                if (BEAST_EXPECT(ret))
+                if (BEAST_EXPECT(ret); ret.has_value())
                 {
                     BEAST_EXPECT(ret->first.size() != 0);
                     BEAST_EXPECT(ret->first == publicKey);
@@ -322,7 +322,7 @@ public:
 
                 auto ret = keypairForSignature(params, error);
                 BEAST_EXPECT(!contains_error(error));
-                if (BEAST_EXPECT(ret))
+                if (BEAST_EXPECT(ret); ret.has_value())
                 {
                     BEAST_EXPECT(ret->first.size() != 0);
                     BEAST_EXPECT(ret->first == publicKey);
@@ -341,7 +341,7 @@ public:
 
             auto ret = keypairForSignature(params, error);
             BEAST_EXPECT(!contains_error(error));
-            if (BEAST_EXPECT(ret))
+            if (BEAST_EXPECT(ret); ret.has_value())
             {
                 BEAST_EXPECT(ret->first.size() != 0);
                 BEAST_EXPECT(ret->first == publicKey);
@@ -357,7 +357,7 @@ public:
 
             auto ret = keypairForSignature(params, error);
             BEAST_EXPECT(!contains_error(error));
-            if (BEAST_EXPECT(ret))
+            if (BEAST_EXPECT(ret); ret.has_value())
             {
                 BEAST_EXPECT(ret->first.size() != 0);
                 BEAST_EXPECT(ret->first == publicKey);
@@ -373,7 +373,7 @@ public:
 
             auto ret = keypairForSignature(params, error);
             BEAST_EXPECT(!contains_error(error));
-            if (BEAST_EXPECT(ret))
+            if (BEAST_EXPECT(ret); ret.has_value())
             {
                 BEAST_EXPECT(ret->first.size() != 0);
                 BEAST_EXPECT(ret->first == publicKey);
@@ -695,7 +695,7 @@ public:
                 auto ret = keypairForSignature(params, error);
 
                 BEAST_EXPECT(!contains_error(error));
-                if (BEAST_EXPECT(ret))
+                if (BEAST_EXPECT(ret); ret.has_value())
                 {
                     BEAST_EXPECT(ret->first.size() != 0);
                     BEAST_EXPECT(toBase58(calcAccountID(ret->first)) == addr);
@@ -726,7 +726,7 @@ public:
                 auto ret = keypairForSignature(params, error);
 
                 BEAST_EXPECT(!contains_error(error));
-                if (BEAST_EXPECT(ret))
+                if (BEAST_EXPECT(ret); ret.has_value())
                 {
                     BEAST_EXPECT(ret->first.size() != 0);
                     BEAST_EXPECT(toBase58(calcAccountID(ret->first)) == addr);
diff --git a/src/test/rpc/LedgerData_test.cpp b/src/test/rpc/LedgerData_test.cpp
index e139ba24b4..1cce3d1383 100644
--- a/src/test/rpc/LedgerData_test.cpp
+++ b/src/test/rpc/LedgerData_test.cpp
@@ -210,7 +210,7 @@ public:
             if (BEAST_EXPECT(jrr.isMember(jss::ledger)))
             {
                 auto data = strUnHex(jrr[jss::ledger][jss::ledger_data].asString());
-                if (BEAST_EXPECT(data))
+                if (BEAST_EXPECT(data); data.has_value())
                 {
                     Serializer s(data->data(), data->size());
                     std::uint32_t seq = 0;
diff --git a/src/test/rpc/LedgerEntry_test.cpp b/src/test/rpc/LedgerEntry_test.cpp
index 9d274b3549..ffc4329109 100644
--- a/src/test/rpc/LedgerEntry_test.cpp
+++ b/src/test/rpc/LedgerEntry_test.cpp
@@ -2583,13 +2583,10 @@ class LedgerEntry_test : public beast::unit_test::suite
         env(check::create(env.master, alice, XRP(100)));
         env.close();
 
-        std::string const ledgerHash{to_string(env.closed()->header().hash)};
-        {
-            // Request a check.
-            Json::Value const jrr = env.rpc("ledger_entry", to_string(checkId.key))[jss::result];
-            BEAST_EXPECT(jrr[jss::node][sfLedgerEntryType.jsonName] == jss::Check);
-            BEAST_EXPECT(jrr[jss::node][sfSendMax.jsonName] == "100000000");
-        }
+        // Request a check.
+        Json::Value const jrr = env.rpc("ledger_entry", to_string(checkId.key))[jss::result];
+        BEAST_EXPECT(jrr[jss::node][sfLedgerEntryType.jsonName] == jss::Check);
+        BEAST_EXPECT(jrr[jss::node][sfSendMax.jsonName] == "100000000");
     }
 
 public:
@@ -2753,7 +2750,6 @@ class LedgerEntry_XChain_test : public beast::unit_test::suite,
         scEnv(xchain_create_claim_id(scBob, jvb, reward, mcBob));
         scEnv.close();
 
-        std::string bridge_index;
         {
             // request the xchain_claim_id via RPC
             Json::Value jvParams;
diff --git a/src/test/rpc/Peers_test.cpp b/src/test/rpc/Peers_test.cpp
index 8e4e560f3e..d72ad6d878 100644
--- a/src/test/rpc/Peers_test.cpp
+++ b/src/test/rpc/Peers_test.cpp
@@ -53,8 +53,8 @@ class Peers_test : public beast::unit_test::suite
                 continue;
             if (!BEAST_EXPECT((*it).isMember(jss::tag)))
                 continue;
-            auto tag = (*it)[jss::tag].asString();
-            BEAST_EXPECTS((*it)[jss::tag].asString() == nodes[key], key);
+            auto const tag = (*it)[jss::tag].asString();
+            BEAST_EXPECTS(tag == nodes[key], key);
         }
         BEAST_EXPECT(peers.isMember(jss::peers) && peers[jss::peers].isNull());
     }
diff --git a/src/test/rpc/ServerDefinitions_test.cpp b/src/test/rpc/ServerDefinitions_test.cpp
index 69533939cd..a2c45cfa65 100644
--- a/src/test/rpc/ServerDefinitions_test.cpp
+++ b/src/test/rpc/ServerDefinitions_test.cpp
@@ -1,6 +1,9 @@
 #include <test/jtx.h>
 
 #include <xrpl/beast/unit_test.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SOTemplate.h>
+#include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
 
 namespace xrpl {
@@ -81,43 +84,371 @@ public:
                 BEAST_EXPECT(types["Hash384"].asUInt() == 22);
                 BEAST_EXPECT(types["Hash512"].asUInt() == 23);
             }
-        }
 
-        // test providing the same hash
-        {
-            Env env(*this);
-            auto const firstResult = env.rpc("server_definitions");
-            auto const hash = firstResult[jss::result][jss::hash].asString();
-            auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+            // test the properties of the LEDGER_ENTRY_FLAGS section
+            {
+                BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
+                Json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
 
-            auto const result = env.rpc("json", "server_definitions", hashParam);
-            BEAST_EXPECT(!result[jss::result].isMember(jss::error));
-            BEAST_EXPECT(result[jss::result][jss::status] == "success");
-            BEAST_EXPECT(!result[jss::result].isMember(jss::FIELDS));
-            BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
-            BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_RESULTS));
-            BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_TYPES));
-            BEAST_EXPECT(!result[jss::result].isMember(jss::TYPES));
-            BEAST_EXPECT(result[jss::result].isMember(jss::hash));
-        }
+                // sanity test the mapped value of a few arbitrarily chosen flags
+                BEAST_EXPECT(leFlags["AccountRoot"]["lsfDisallowXRP"] == 0x00080000);
+                BEAST_EXPECT(leFlags["AccountRoot"]["lsfDepositAuth"] == 0x01000000);
+                BEAST_EXPECT(leFlags["AccountRoot"]["lsfAllowTrustLineClawback"] == 0x80000000);
 
-        // test providing a different hash
-        {
-            Env env(*this);
-            std::string const hash =
-                "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
-                "D1";
-            auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+                BEAST_EXPECT(leFlags["RippleState"]["lsfHighFreeze"] == 0x00800000);
+                BEAST_EXPECT(leFlags["RippleState"]["lsfAMMNode"] == 0x01000000);
 
-            auto const result = env.rpc("json", "server_definitions", hashParam);
-            BEAST_EXPECT(!result[jss::result].isMember(jss::error));
-            BEAST_EXPECT(result[jss::result][jss::status] == "success");
-            BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
-            BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
-            BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
-            BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
-            BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
-            BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+                BEAST_EXPECT(leFlags["DirNode"]["lsfNFTokenBuyOffers"] == 0x00000001);
+                BEAST_EXPECT(leFlags["MPTokenIssuance"]["lsfMPTCanTrade"] == 0x00000010);
+                BEAST_EXPECT(leFlags["Credential"]["lsfAccepted"] == 0x00010000);
+                BEAST_EXPECT(leFlags["Loan"]["lsfLoanImpaired"] == 0x00020000);
+                BEAST_EXPECT(leFlags["Vault"]["lsfVaultPrivate"] == 0x00010000);
+                BEAST_EXPECT(leFlags["MPToken"]["lsfMPTAuthorized"] == 0x00000002);
+            }
+
+            // validate the correctness of few chosen transaction flags
+            {
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
+                Json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
+
+                BEAST_EXPECT(txFlags["universal"]["tfFullyCanonicalSig"] == 0x80000000);
+                BEAST_EXPECT(txFlags["universal"]["tfInnerBatchTxn"] == 0x40000000);
+
+                BEAST_EXPECT(txFlags["AccountSet"]["tfRequireAuth"] == 0x00040000);
+                BEAST_EXPECT(txFlags["AccountSet"]["tfAllowXRP"] == 0x00200000);
+
+                BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTLock"] == 0x00000001);
+                BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTUnlock"] == 0x00000002);
+
+                BEAST_EXPECT(txFlags["AMMDeposit"]["tfLPToken"] == 0x00010000);
+                BEAST_EXPECT(txFlags["AMMDeposit"]["tfLimitLPToken"] == 0x00400000);
+            }
+
+            // validate the correctness of the AccountSpecificFlags section
+            {
+                BEAST_EXPECT(result[jss::result].isMember(jss::ACCOUNT_SET_FLAGS));
+                Json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
+
+                BEAST_EXPECT(asFlags["asfDisallowXRP"] == 3);
+                BEAST_EXPECT(asFlags["asfGlobalFreeze"] == 7);
+                BEAST_EXPECT(asFlags["asfDisallowIncomingNFTokenOffer"] == 12);
+                BEAST_EXPECT(asFlags["asfDisallowIncomingTrustline"] == 15);
+            }
+
+            // test the response fields of the TRANSACTION_FORMATS section
+            {
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
+                Json::Value const& txnFormats = result[jss::result][jss::TRANSACTION_FORMATS];
+
+                // first validate the contents of "common"
+                {
+                    BEAST_EXPECT(txnFormats.isMember("common"));
+                    Json::Value const& section = txnFormats["common"];
+
+                    BEAST_EXPECT(section[0u][jss::name] == "TransactionType");
+                    BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[1u][jss::name] == "Flags");
+                    BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[2u][jss::name] == "SourceTag");
+                    BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[3u][jss::name] == "Account");
+                    BEAST_EXPECT(section[3u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[4u][jss::name] == "Sequence");
+                    BEAST_EXPECT(section[4u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[5u][jss::name] == "PreviousTxnID");
+                    BEAST_EXPECT(section[5u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[6u][jss::name] == "LastLedgerSequence");
+                    BEAST_EXPECT(section[6u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[7u][jss::name] == "AccountTxnID");
+                    BEAST_EXPECT(section[7u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[8u][jss::name] == "Fee");
+                    BEAST_EXPECT(section[8u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[9u][jss::name] == "OperationLimit");
+                    BEAST_EXPECT(section[9u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[10u][jss::name] == "Memos");
+                    BEAST_EXPECT(section[10u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[11u][jss::name] == "SigningPubKey");
+                    BEAST_EXPECT(section[11u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[12u][jss::name] == "TicketSequence");
+                    BEAST_EXPECT(section[12u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[13u][jss::name] == "TxnSignature");
+                    BEAST_EXPECT(section[13u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[14u][jss::name] == "Signers");
+                    BEAST_EXPECT(section[14u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[15u][jss::name] == "NetworkID");
+                    BEAST_EXPECT(section[15u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[16u][jss::name] == "Delegate");
+                    BEAST_EXPECT(section[16u][jss::optionality] == soeOPTIONAL);
+                }
+
+                // validate the contents of four arbitrarily selected transactions validate the
+                // format of the OracleSet transaction
+                {
+                    BEAST_EXPECT(txnFormats.isMember("OracleSet"));
+                    Json::Value const& section = txnFormats["OracleSet"];
+
+                    BEAST_EXPECT(section[0u][jss::name] == "OracleDocumentID");
+                    BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[1u][jss::name] == "Provider");
+                    BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[2u][jss::name] == "URI");
+                    BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[3u][jss::name] == "AssetClass");
+                    BEAST_EXPECT(section[3u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[4u][jss::name] == "LastUpdateTime");
+                    BEAST_EXPECT(section[4u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[5u][jss::name] == "PriceDataSeries");
+                    BEAST_EXPECT(section[5u][jss::optionality] == soeREQUIRED);
+                }
+
+                // validate the format of the PermissionedDomainDelete transaction
+                {
+                    BEAST_EXPECT(txnFormats.isMember("PermissionedDomainDelete"));
+                    Json::Value const& section = txnFormats["PermissionedDomainDelete"];
+
+                    BEAST_EXPECT(section[0u][jss::name] == "DomainID");
+                    BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
+                }
+
+                // validate the format of the Clawback transaction
+                {
+                    BEAST_EXPECT(txnFormats.isMember("Clawback"));
+                    Json::Value const& section = txnFormats["Clawback"];
+
+                    BEAST_EXPECT(section[0u][jss::name] == "Amount");
+                    BEAST_EXPECT(section[0u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(section[1u][jss::name] == "Holder");
+                    BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
+                }
+
+                // validate the format of the SetFee transaction
+                {
+                    BEAST_EXPECT(txnFormats.isMember("SetFee"));
+                    Json::Value const& section = txnFormats["SetFee"];
+
+                    BEAST_EXPECT(section[0u][jss::name] == "LedgerSequence");
+                    BEAST_EXPECT(section[0u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[1u][jss::name] == "BaseFee");
+                    BEAST_EXPECT(section[1u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[2u][jss::name] == "ReferenceFeeUnits");
+                    BEAST_EXPECT(section[2u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[3u][jss::name] == "ReserveBase");
+                    BEAST_EXPECT(section[3u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[4u][jss::name] == "ReserveIncrement");
+                    BEAST_EXPECT(section[4u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[5u][jss::name] == "BaseFeeDrops");
+                    BEAST_EXPECT(section[5u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[6u][jss::name] == "ReserveBaseDrops");
+                    BEAST_EXPECT(section[6u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(section[7u][jss::name] == "ReserveIncrementDrops");
+                    BEAST_EXPECT(section[7u][jss::optionality] == soeOPTIONAL);
+                }
+            }
+
+            // test the properties of the LEDGER_ENTRY_FORMATS section in server_definitions
+            // response
+            {
+                BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
+
+                // Note: For the purposes of software maintenance, this test does not exhaustively
+                // validate all the LEDGER_ENTRY_FORMATS
+
+                // check "common" first
+                {
+                    Json::Value const& observedCommonLedgerEntry =
+                        result[jss::result][jss::LEDGER_ENTRY_FORMATS]["common"];
+
+                    BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::name] == "LedgerIndex");
+                    BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::name] == "LedgerEntryType");
+                    BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::name] == "Flags");
+                    BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::optionality] == soeREQUIRED);
+                }
+
+                // test the contents of an arbitrary ledger-entry (DID)
+                {
+                    Json::Value const& observedDIDLedgerEntry =
+                        result[jss::result][jss::LEDGER_ENTRY_FORMATS]["DID"];
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::name] == "Account");
+                    BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::name] == "DIDDocument");
+                    BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::name] == "URI");
+                    BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::name] == "Data");
+                    BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::name] == "OwnerNode");
+                    BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::name] == "PreviousTxnID");
+                    BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::optionality] == soeREQUIRED);
+
+                    BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::name] == "PreviousTxnLgrSeq");
+                    BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::optionality] == soeREQUIRED);
+                }
+
+                // test the contents of an arbitrary ledger-entry (NegativeUNL)
+                {
+                    Json::Value const& observedNunlLedgerEntry =
+                        result[jss::result][jss::LEDGER_ENTRY_FORMATS]["NegativeUNL"];
+
+                    BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::name] == "DisabledValidators");
+                    BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::name] == "ValidatorToDisable");
+                    BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::name] == "ValidatorToReEnable");
+                    BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::name] == "PreviousTxnID");
+                    BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::optionality] == soeOPTIONAL);
+
+                    BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::name] == "PreviousTxnLgrSeq");
+                    BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::optionality] == soeOPTIONAL);
+                }
+            }
+
+            // Exhaustive test: verify all transaction flags from getAllTxFlags() appear in the
+            // output
+            {
+                Json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
+
+                for (auto const& [txName, flagMap] : getAllTxFlags())
+                {
+                    BEAST_EXPECT(txFlags.isMember(txName));
+                    if (txFlags.isMember(txName))
+                    {
+                        for (auto const& [flagName, flagValue] : flagMap)
+                        {
+                            BEAST_EXPECT(txFlags[txName].isMember(flagName));
+                            if (txFlags[txName].isMember(flagName))
+                            {
+                                BEAST_EXPECT(txFlags[txName][flagName].asUInt() == flagValue);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Exhaustive test: verify all ledger entry flags from getAllLedgerFlags() appear in the
+            // output
+            {
+                Json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
+
+                for (auto const& [ledgerType, flagMap] : getAllLedgerFlags())
+                {
+                    BEAST_EXPECT(leFlags.isMember(ledgerType));
+                    if (leFlags.isMember(ledgerType))
+                    {
+                        for (auto const& [flagName, flagValue] : flagMap)
+                        {
+                            BEAST_EXPECT(leFlags[ledgerType].isMember(flagName));
+                            if (leFlags[ledgerType].isMember(flagName))
+                            {
+                                BEAST_EXPECT(leFlags[ledgerType][flagName].asUInt() == flagValue);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Exhaustive test: verify all AccountSet flags from getAsfFlagMap() appear in the
+            // output
+            {
+                Json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
+
+                for (auto const& [flagName, flagValue] : getAsfFlagMap())
+                {
+                    BEAST_EXPECT(asFlags.isMember(flagName));
+                    if (asFlags.isMember(flagName))
+                    {
+                        BEAST_EXPECT(asFlags[flagName].asInt() == flagValue);
+                    }
+                }
+            }
+
+            // test providing the same hash
+            {
+                Env env(*this);
+                auto const firstResult = env.rpc("server_definitions");
+                auto const hash = firstResult[jss::result][jss::hash].asString();
+                auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+
+                auto const result = env.rpc("json", "server_definitions", hashParam);
+                BEAST_EXPECT(!result[jss::result].isMember(jss::error));
+                BEAST_EXPECT(result[jss::result][jss::status] == "success");
+                BEAST_EXPECT(!result[jss::result].isMember(jss::FIELDS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_RESULTS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_TYPES));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FLAGS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FORMATS));
+                BEAST_EXPECT(!result[jss::result].isMember(jss::TYPES));
+                BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+            }
+
+            // test providing a different hash
+            {
+                Env env(*this);
+                std::string const hash =
+                    "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
+                    "D1";
+                auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
+
+                auto const result = env.rpc("json", "server_definitions", hashParam);
+                BEAST_EXPECT(!result[jss::result].isMember(jss::error));
+                BEAST_EXPECT(result[jss::result][jss::status] == "success");
+                BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
+                BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
+                BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
+                BEAST_EXPECT(result[jss::result].isMember(jss::hash));
+            }
         }
     }
 
diff --git a/src/test/rpc/Simulate_test.cpp b/src/test/rpc/Simulate_test.cpp
index fc96e76c90..d20123a680 100644
--- a/src/test/rpc/Simulate_test.cpp
+++ b/src/test/rpc/Simulate_test.cpp
@@ -41,7 +41,7 @@ class Simulate_test : public beast::unit_test::suite
         else
         {
             auto const unHexed = strUnHex(result[jss::tx_blob].asString());
-            SerialIter sitTrans(makeSlice(*unHexed));
+            SerialIter sitTrans(makeSlice(*unHexed));  // NOLINT(bugprone-unchecked-optional-access)
             tx_json = STObject(std::ref(sitTrans), sfGeneric).getJson(JsonOptions::none);
         }
         BEAST_EXPECT(tx_json[jss::TransactionType] == tx[jss::TransactionType]);
@@ -87,6 +87,7 @@ class Simulate_test : public beast::unit_test::suite
             // It is technically not a valid STObject, so the following line
             // will crash
             STParsedJSONObject const parsed(std::string(jss::tx_json), tx);
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const tx_blob = strHex(parsed.object->getSerializer().peekData());
             if (BEAST_EXPECT(parsed.object.has_value()))
             {
@@ -136,7 +137,7 @@ class Simulate_test : public beast::unit_test::suite
         if (txResult.isMember(jss::meta_blob))
         {
             auto unHexed = strUnHex(txResult[jss::meta_blob].asString());
-            SerialIter sitTrans(makeSlice(*unHexed));
+            SerialIter sitTrans(makeSlice(*unHexed));  // NOLINT(bugprone-unchecked-optional-access)
             return STObject(std::ref(sitTrans), sfGeneric).getJson(JsonOptions::none);
         }
 
diff --git a/src/test/rpc/Subscribe_test.cpp b/src/test/rpc/Subscribe_test.cpp
index d83711324d..e96286aefc 100644
--- a/src/test/rpc/Subscribe_test.cpp
+++ b/src/test/rpc/Subscribe_test.cpp
@@ -26,7 +26,7 @@ public:
     {
         using namespace std::chrono_literals;
         using namespace jtx;
-        Env env(*this);
+        Env env{*this, single_thread_io(envconfig())};
         auto wsc = makeWSClient(env.app().config());
         Json::Value stream;
 
@@ -92,7 +92,7 @@ public:
     {
         using namespace std::chrono_literals;
         using namespace jtx;
-        Env env(*this);
+        Env env{*this, single_thread_io(envconfig())};
         auto wsc = makeWSClient(env.app().config());
         Json::Value stream;
 
@@ -114,7 +114,7 @@ public:
 
         {
             // Accept a ledger
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream update
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -125,7 +125,7 @@ public:
 
         {
             // Accept another ledger
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream update
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -150,7 +150,7 @@ public:
     {
         using namespace std::chrono_literals;
         using namespace jtx;
-        Env env(*this);
+        Env env(*this, single_thread_io(envconfig()));
         auto baseFee = env.current()->fees().base.drops();
         auto wsc = makeWSClient(env.app().config());
         Json::Value stream;
@@ -171,7 +171,7 @@ public:
 
         {
             env.fund(XRP(10000), "alice");
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream update for payment transaction
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -195,7 +195,7 @@ public:
             }));
 
             env.fund(XRP(10000), "bob");
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream update for payment transaction
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -249,12 +249,12 @@ public:
         {
             // Transaction that does not affect stream
             env.fund(XRP(10000), "carol");
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             BEAST_EXPECT(!wsc->getMsg(10ms));
 
             // Transactions concerning alice
             env.trust(Account("bob")["USD"](100), "alice");
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream updates
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -288,6 +288,7 @@ public:
         using namespace jtx;
         Env env(*this, envconfig([](std::unique_ptr<Config> cfg) {
             cfg->FEES.reference_fee = 10;
+            cfg = single_thread_io(std::move(cfg));
             return cfg;
         }));
         auto wsc = makeWSClient(env.app().config());
@@ -310,7 +311,7 @@ public:
 
         {
             env.fund(XRP(10000), "alice");
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // Check stream update for payment transaction
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
@@ -360,7 +361,7 @@ public:
     testManifests()
     {
         using namespace jtx;
-        Env env(*this);
+        Env env(*this, single_thread_io(envconfig()));
         auto wsc = makeWSClient(env.app().config());
         Json::Value stream;
 
@@ -394,12 +395,12 @@ public:
     {
         using namespace jtx;
 
-        Env env{*this, envconfig(validator, ""), features};
+        Env env{*this, single_thread_io(envconfig(validator, "")), features};
         auto& cfg = env.app().config();
         if (!BEAST_EXPECT(cfg.section(SECTION_VALIDATION_SEED).empty()))
             return;
         auto const parsedseed = parseBase58<Seed>(cfg.section(SECTION_VALIDATION_SEED).values()[0]);
-        if (!BEAST_EXPECT(parsedseed))
+        if (BEAST_EXPECT(parsedseed); not parsedseed.has_value())
             return;
 
         std::string const valPublicKey = toBase58(
@@ -483,7 +484,7 @@ public:
             // at least one flag ledger.
             while (env.closed()->header().seq < 300)
             {
-                env.close();
+                BEAST_EXPECT(env.syncClose());
                 using namespace std::chrono_literals;
                 BEAST_EXPECT(wsc->findMsg(5s, validValidationFields));
             }
@@ -505,7 +506,7 @@ public:
     {
         using namespace jtx;
         testcase("Subscribe by url");
-        Env env{*this};
+        Env env{*this, single_thread_io(envconfig())};
 
         Json::Value jv;
         jv[jss::url] = "http://localhost/events";
@@ -536,7 +537,7 @@ public:
         auto const method = subscribe ? "subscribe" : "unsubscribe";
         testcase << "Error cases for " << method;
 
-        Env env{*this};
+        Env env{*this, single_thread_io(envconfig())};
         auto wsc = makeWSClient(env.app().config());
 
         {
@@ -572,7 +573,7 @@ public:
         }
 
         {
-            Env env_nonadmin{*this, no_admin(envconfig())};
+            Env env_nonadmin{*this, single_thread_io(no_admin(envconfig()))};
             Json::Value jv;
             jv[jss::url] = "no-url";
             auto jr = env_nonadmin.rpc("json", method, to_string(jv))[jss::result];
@@ -801,13 +802,17 @@ public:
          * return {true, true} if received numReplies replies and also
          * received a tx with the account_history_tx_first == true
          */
-        auto getTxHash = [](WSClient& wsc, IdxHashVec& v, int numReplies) -> std::pair<bool, bool> {
+        auto getTxHash = [](WSClient& wsc,
+                            IdxHashVec& v,
+                            int numReplies,
+                            std::chrono::milliseconds timeout =
+                                std::chrono::milliseconds{5000}) -> std::pair<bool, bool> {
             bool first_flag = false;
 
             for (int i = 0; i < numReplies; ++i)
             {
                 std::uint32_t idx{0};
-                auto reply = wsc.getMsg(100ms);
+                auto reply = wsc.getMsg(timeout);
                 if (reply)
                 {
                     auto r = *reply;
@@ -834,12 +839,13 @@ public:
          * send payments between the two accounts a and b,
          * and close ledgersToClose ledgers
          */
-        auto sendPayments = [](Env& env,
-                               Account const& a,
-                               Account const& b,
-                               int newTxns,
-                               std::uint32_t ledgersToClose,
-                               int numXRP = 10) {
+        auto sendPayments = [this](
+                                Env& env,
+                                Account const& a,
+                                Account const& b,
+                                int newTxns,
+                                std::uint32_t ledgersToClose,
+                                int numXRP = 10) {
             env.memoize(a);
             env.memoize(b);
             for (int i = 0; i < newTxns; ++i)
@@ -852,7 +858,7 @@ public:
                     jtx::sig(jtx::autofill));
             }
             for (int i = 0; i < ledgersToClose; ++i)
-                env.close();
+                BEAST_EXPECT(env.syncClose());
             return newTxns;
         };
 
@@ -945,7 +951,7 @@ public:
              *
              * also test subscribe to the account before it is created
              */
-            Env env(*this);
+            Env env(*this, single_thread_io(envconfig()));
             auto wscTxHistory = makeWSClient(env.app().config());
             Json::Value request;
             request[jss::account_history_tx_stream] = Json::objectValue;
@@ -980,7 +986,7 @@ public:
             BEAST_EXPECT(goodSubRPC(jv));
 
             sendPayments(env, env.master, alice, 1, 1);
-            r = getTxHash(*wscTxHistory, vec, 1);
+            r = getTxHash(*wscTxHistory, vec, 1, 10ms);
             BEAST_EXPECT(!r.first);
         }
         {
@@ -988,7 +994,7 @@ public:
              * subscribe genesis account tx history without txns
              * subscribe to bob's account after it is created
              */
-            Env env(*this);
+            Env env(*this, single_thread_io(envconfig()));
             auto wscTxHistory = makeWSClient(env.app().config());
             Json::Value request;
             request[jss::account_history_tx_stream] = Json::objectValue;
@@ -998,7 +1004,8 @@ public:
             if (!BEAST_EXPECT(goodSubRPC(jv)))
                 return;
             IdxHashVec genesisFullHistoryVec;
-            if (!BEAST_EXPECT(!getTxHash(*wscTxHistory, genesisFullHistoryVec, 1).first))
+            BEAST_EXPECT(env.syncClose());
+            if (!BEAST_EXPECT(!getTxHash(*wscTxHistory, genesisFullHistoryVec, 1, 10ms).first))
                 return;
 
             /*
@@ -1016,6 +1023,7 @@ public:
             if (!BEAST_EXPECT(goodSubRPC(jv)))
                 return;
             IdxHashVec bobFullHistoryVec;
+            BEAST_EXPECT(env.syncClose());
             r = getTxHash(*wscTxHistory, bobFullHistoryVec, 1);
             if (!BEAST_EXPECT(r.first && r.second))
                 return;
@@ -1050,6 +1058,7 @@ public:
                 "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             jv = wscTxHistory->invoke("subscribe", request);
             genesisFullHistoryVec.clear();
+            BEAST_EXPECT(env.syncClose());
             BEAST_EXPECT(getTxHash(*wscTxHistory, genesisFullHistoryVec, 31).second);
             jv = wscTxHistory->invoke("unsubscribe", request);
 
@@ -1062,13 +1071,13 @@ public:
              * subscribe account and subscribe account tx history
              * and compare txns streamed
              */
-            Env env(*this);
+            Env env(*this, single_thread_io(envconfig()));
             auto wscAccount = makeWSClient(env.app().config());
             auto wscTxHistory = makeWSClient(env.app().config());
 
             std::array<Account, 2> accounts = {alice, bob};
             env.fund(XRP(222222), accounts);
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // subscribe account
             Json::Value stream = Json::objectValue;
@@ -1131,18 +1140,18 @@ public:
              * alice issues USD to carol
              * mix USD and XRP payments
              */
-            Env env(*this);
+            Env env(*this, single_thread_io(envconfig()));
             auto const USD_a = alice["USD"];
 
             std::array<Account, 2> accounts = {alice, carol};
             env.fund(XRP(333333), accounts);
             env.trust(USD_a(20000), carol);
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             auto mixedPayments = [&]() -> int {
                 sendPayments(env, alice, carol, 1, 0);
                 env(pay(alice, carol, USD_a(100)));
-                env.close();
+                BEAST_EXPECT(env.syncClose());
                 return 2;
             };
 
@@ -1152,10 +1161,11 @@ public:
             request[jss::account_history_tx_stream][jss::account] = carol.human();
             auto ws = makeWSClient(env.app().config());
             auto jv = ws->invoke("subscribe", request);
+            BEAST_EXPECT(env.syncClose());
             {
                 // take out existing txns from the stream
                 IdxHashVec tempVec;
-                getTxHash(*ws, tempVec, 100);
+                getTxHash(*ws, tempVec, 100, 1000ms);
             }
 
             auto count = mixedPayments();
@@ -1169,10 +1179,10 @@ public:
             /*
              * long transaction history
              */
-            Env env(*this);
+            Env env(*this, single_thread_io(envconfig()));
             std::array<Account, 2> accounts = {alice, carol};
             env.fund(XRP(444444), accounts);
-            env.close();
+            BEAST_EXPECT(env.syncClose());
 
             // many payments, and close lots of ledgers
             auto oneRound = [&](int numPayments) {
@@ -1185,10 +1195,11 @@ public:
             request[jss::account_history_tx_stream][jss::account] = carol.human();
             auto wscLong = makeWSClient(env.app().config());
             auto jv = wscLong->invoke("subscribe", request);
+            BEAST_EXPECT(env.syncClose());
             {
                 // take out existing txns from the stream
                 IdxHashVec tempVec;
-                getTxHash(*wscLong, tempVec, 100);
+                getTxHash(*wscLong, tempVec, 100, 1000ms);
             }
 
             // repeat the payments many rounds
@@ -1222,7 +1233,7 @@ public:
             jtx::testable_amendments() | featurePermissionedDomains | featureCredentials |
             featurePermissionedDEX};
 
-        Env env(*this, all);
+        Env env(*this, single_thread_io(envconfig()), all);
         PermissionedDEX permDex(env);
         auto const alice = permDex.alice;
         auto const bob = permDex.bob;
@@ -1241,10 +1252,10 @@ public:
         if (!BEAST_EXPECT(jv[jss::status] == "success"))
             return;
         env(offer(alice, XRP(10), USD(10)), domain(domainID), txflags(tfHybrid));
-        env.close();
+        BEAST_EXPECT(env.syncClose());
 
         env(pay(bob, carol, USD(5)), path(~USD), sendmax(XRP(5)), domain(domainID));
-        env.close();
+        BEAST_EXPECT(env.syncClose());
 
         BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
             if (jv[jss::changes].size() != 1)
@@ -1284,9 +1295,9 @@ public:
         Account const bob{"bob"};
         Account const broker{"broker"};
 
-        Env env{*this, features};
+        Env env{*this, single_thread_io(envconfig()), features};
         env.fund(XRP(10000), alice, bob, broker);
-        env.close();
+        BEAST_EXPECT(env.syncClose());
 
         auto wsc = test::makeWSClient(env.app().config());
         Json::Value stream;
@@ -1350,12 +1361,12 @@ public:
             // Verify the NFTokenIDs are correct in the NFTokenMint tx meta
             uint256 const nftId1{token::getNextID(env, alice, 0u, tfTransferable)};
             env(token::mint(alice, 0u), txflags(tfTransferable));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId1);
 
             uint256 const nftId2{token::getNextID(env, alice, 0u, tfTransferable)};
             env(token::mint(alice, 0u), txflags(tfTransferable));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId2);
 
             // Alice creates one sell offer for each NFT
@@ -1363,32 +1374,32 @@ public:
             // meta
             uint256 const aliceOfferIndex1 = keylet::nftoffer(alice, env.seq(alice)).key;
             env(token::createOffer(alice, nftId1, drops(1)), txflags(tfSellNFToken));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(aliceOfferIndex1);
 
             uint256 const aliceOfferIndex2 = keylet::nftoffer(alice, env.seq(alice)).key;
             env(token::createOffer(alice, nftId2, drops(1)), txflags(tfSellNFToken));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(aliceOfferIndex2);
 
             // Alice cancels two offers she created
             // Verify the NFTokenIDs are correct in the NFTokenCancelOffer tx
             // meta
             env(token::cancelOffer(alice, {aliceOfferIndex1, aliceOfferIndex2}));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenIDsInCancelOffer({nftId1, nftId2});
 
             // Bobs creates a buy offer for nftId1
             // Verify the offer id is correct in the NFTokenCreateOffer tx meta
             auto const bobBuyOfferIndex = keylet::nftoffer(bob, env.seq(bob)).key;
             env(token::createOffer(bob, nftId1, drops(1)), token::owner(alice));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(bobBuyOfferIndex);
 
             // Alice accepts bob's buy offer
             // Verify the NFTokenID is correct in the NFTokenAcceptOffer tx meta
             env(token::acceptBuyOffer(alice, bobBuyOfferIndex));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId1);
         }
 
@@ -1397,7 +1408,7 @@ public:
             // Alice mints a NFT
             uint256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
             env(token::mint(alice, 0u), txflags(tfTransferable));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId);
 
             // Alice creates sell offer and set broker as destination
@@ -1405,18 +1416,18 @@ public:
             env(token::createOffer(alice, nftId, drops(1)),
                 token::destination(broker),
                 txflags(tfSellNFToken));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(offerAliceToBroker);
 
             // Bob creates buy offer
             uint256 const offerBobToBroker = keylet::nftoffer(bob, env.seq(bob)).key;
             env(token::createOffer(bob, nftId, drops(1)), token::owner(alice));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(offerBobToBroker);
 
             // Check NFTokenID meta for NFTokenAcceptOffer in brokered mode
             env(token::brokerOffers(broker, offerBobToBroker, offerAliceToBroker));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId);
         }
 
@@ -1426,24 +1437,24 @@ public:
             // Alice mints a NFT
             uint256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
             env(token::mint(alice, 0u), txflags(tfTransferable));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenID(nftId);
 
             // Alice creates 2 sell offers for the same NFT
             uint256 const aliceOfferIndex1 = keylet::nftoffer(alice, env.seq(alice)).key;
             env(token::createOffer(alice, nftId, drops(1)), txflags(tfSellNFToken));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(aliceOfferIndex1);
 
             uint256 const aliceOfferIndex2 = keylet::nftoffer(alice, env.seq(alice)).key;
             env(token::createOffer(alice, nftId, drops(1)), txflags(tfSellNFToken));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(aliceOfferIndex2);
 
             // Make sure the metadata only has 1 nft id, since both offers are
             // for the same nft
             env(token::cancelOffer(alice, {aliceOfferIndex1, aliceOfferIndex2}));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenIDsInCancelOffer({nftId});
         }
 
@@ -1451,7 +1462,7 @@ public:
         {
             uint256 const aliceMintWithOfferIndex1 = keylet::nftoffer(alice, env.seq(alice)).key;
             env(token::mint(alice), token::amount(XRP(0)));
-            env.close();
+            BEAST_EXPECT(env.syncClose());
             verifyNFTokenOfferID(aliceMintWithOfferIndex1);
         }
     }
diff --git a/src/test/rpc/Transaction_test.cpp b/src/test/rpc/Transaction_test.cpp
index ebe3f3135d..fa76f62cdf 100644
--- a/src/test/rpc/Transaction_test.cpp
+++ b/src/test/rpc/Transaction_test.cpp
@@ -305,6 +305,7 @@ class Transaction_test : public beast::unit_test::suite
             uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 *RPC::encodeCTID(startLegSeq + i, txnIdx, netID),
                 BINARY,
                 to_string(startLegSeq),
@@ -316,6 +317,7 @@ class Transaction_test : public beast::unit_test::suite
         }
 
         auto const tx = env.jt(noop(alice), seq(env.seq(alice))).stx;
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const ctid = *RPC::encodeCTID(endLegSeq, tx->getSeqValue(), netID);
         for (int deltaEndSeq = 0; deltaEndSeq < 2; ++deltaEndSeq)
         {
@@ -340,6 +342,7 @@ class Transaction_test : public beast::unit_test::suite
             uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 *RPC::encodeCTID(startLegSeq + i, txnIdx, netID),
                 BINARY,
                 to_string(endLegSeq + 1),
@@ -399,6 +402,7 @@ class Transaction_test : public beast::unit_test::suite
             uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                 *RPC::encodeCTID(endLegSeq, txnIdx, netID),
                 to_string(startLegSeq),
                 to_string(deletedLedger - 1));
@@ -594,7 +598,7 @@ class Transaction_test : public beast::unit_test::suite
 
             Json::Value jsonTx;
             jsonTx[jss::binary] = false;
-            jsonTx[jss::ctid] = *ctid;
+            jsonTx[jss::ctid] = *ctid;  // NOLINT(bugprone-unchecked-optional-access)
             jsonTx[jss::id] = 1;
             auto const jrr = env.rpc("json", "tx", to_string(jsonTx))[jss::result];
             BEAST_EXPECT(jrr[jss::ctid] == ctid);
@@ -614,6 +618,7 @@ class Transaction_test : public beast::unit_test::suite
             env(pay(alice, bob, XRP(10)));
             env.close();
 
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             std::string const ctid = *RPC::encodeCTID(startLegSeq, 0, netID);
             auto isUpper = [](char c) { return std::isupper(c) != 0; };
 
@@ -670,7 +675,8 @@ class Transaction_test : public beast::unit_test::suite
             if (jrr.isMember(jss::ctid))
             {
                 auto const ctid = RPC::encodeCTID(ledgerSeq, 0, netID);
-                BEAST_EXPECT(jrr[jss::ctid] == *ctid);
+                BEAST_EXPECT(
+                    jrr[jss::ctid] == *ctid);  // NOLINT(bugprone-unchecked-optional-access)
             }
         }
 
@@ -687,6 +693,7 @@ class Transaction_test : public beast::unit_test::suite
             env(pay(alice, bob, XRP(10)));
             env.close();
 
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const ctid = *RPC::encodeCTID(startLegSeq, 0, netID + 1);
             Json::Value jsonTx;
             jsonTx[jss::binary] = false;
diff --git a/src/test/rpc/ValidatorInfo_test.cpp b/src/test/rpc/ValidatorInfo_test.cpp
index 41fa95940b..d4769f40fb 100644
--- a/src/test/rpc/ValidatorInfo_test.cpp
+++ b/src/test/rpc/ValidatorInfo_test.cpp
@@ -46,27 +46,15 @@ public:
 
         using namespace jtx;
         std::vector<std::string> const tokenBlob = {
-            "    "
-            "eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT"
-            "\n",
-            " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFua"
-            "WZl "
-            "    \n",
-            "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZD"
-            "eE"
-            "\n",
-            "\t "
-            "hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4U0tG"
-            "\t  "
-            "\t\n",
-            "bjdNTzJmZGtjd1JRSWhBT25ndTlzQUtxWFlvdUorbDJWMFcrc0FPa1ZCK1pSUzZQU2"
-            "\n",
-            "hsSkFmVXNYZkFpQnNWSkdlc2FhZE9KYy9hQVpva1MxdnltR21WcmxIUEtXWDNZeXd1"
-            "\n",
-            "NmluOEhBU1FLUHVnQkQ2N2tNYVJGR3ZtcEFUSGxHS0pkdkRGbFdQWXk1QXFEZWRGdj"
-            "\n",
-            "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0ifQ=="
-            "\n"};
+            "    eyJ2YWxpZGF0aW9uX3NlY3JldF9rZXkiOiI5ZWQ0NWY4NjYyNDFjYzE4YTI3NDdiNT\n",
+            " \tQzODdjMDYyNTkwNzk3MmY0ZTcxOTAyMzFmYWE5Mzc0NTdmYTlkYWY2IiwibWFuaWZl     \n",
+            "\tc3QiOiJKQUFBQUFGeEllMUZ0d21pbXZHdEgyaUNjTUpxQzlnVkZLaWxHZncxL3ZDeE\n",
+            "\t hYWExwbGMyR25NaEFrRTFhZ3FYeEJ3RHdEYklENk9NU1l1TTBGREFscEFnTms4U0tG\t  \t\n",
+            "bjdNTzJmZGtjd1JRSWhBT25ndTlzQUtxWFlvdUorbDJWMFcrc0FPa1ZCK1pSUzZQU2\n",
+            "hsSkFmVXNYZkFpQnNWSkdlc2FhZE9KYy9hQVpva1MxdnltR21WcmxIUEtXWDNZeXd1\n",
+            "NmluOEhBU1FLUHVnQkQ2N2tNYVJGR3ZtcEFUSGxHS0pkdkRGbFdQWXk1QXFEZWRGdj\n",
+            "VUSmEydzBpMjFlcTNNWXl3TFZKWm5GT3I3QzBrdzJBaVR6U0NqSXpkaXRROD0ifQ==\n",
+        };
 
         std::string const master_key = "nHBt9fsb4849WmZiCds4r5TXyBeQjqnH5kzPtqgMAQMgi39YZRPa";
         std::string const ephemeral_key = "n9KsDYGKhABVc4wK5u3MnVhgPinyJimyKGpr9VJYuBaY8EnJXR2x";
diff --git a/src/test/server/ServerStatus_test.cpp b/src/test/server/ServerStatus_test.cpp
index dc92375428..49ee3d2079 100644
--- a/src/test/server/ServerStatus_test.cpp
+++ b/src/test/server/ServerStatus_test.cpp
@@ -87,7 +87,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
             std::random_device rd;
             std::mt19937 e{rd()};
             std::uniform_int_distribution<> d(0, 255);
-            std::array<std::uint8_t, 16> key;
+            std::array<std::uint8_t, 16> key{};
             for (auto& v : key)
                 v = d(e);
             req.insert("Sec-WebSocket-Key", base64_encode(key.data(), key.size()));
@@ -132,7 +132,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
     void
     doRequest(
         boost::asio::yield_context& yield,
-        boost::beast::http::request<boost::beast::http::string_body>&& req,
+        boost::beast::http::request<boost::beast::http::string_body> const& req,
         std::string const& host,
         uint16_t port,
         bool secure,
@@ -195,6 +195,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
     {
         auto const port = env.app().config()["port_ws"].get<std::uint16_t>("port");
         auto ip = env.app().config()["port_ws"].get<std::string>("ip");
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         doRequest(yield, makeWSUpgrade(*ip, *port), *ip, *port, secure, resp, ec);
         return;
     }
@@ -211,6 +212,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
     {
         auto const port = env.app().config()["port_rpc"].get<std::uint16_t>("port");
         auto const ip = env.app().config()["port_rpc"].get<std::string>("ip");
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         doRequest(yield, makeHTTPRequest(*ip, *port, body, fields), *ip, *port, secure, resp, ec);
         return;
     }
@@ -286,6 +288,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                     "admin_password");
 
             // 1 - FAILS with wrong pass
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user, *password + "_")[jss::result];
             BEAST_EXPECT(jrr["error"] == proto_ws ? "forbidden" : "noPermission");
             BEAST_EXPECT(
@@ -293,6 +296,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                                                  : "You don't have permission for this command.");
 
             // 2 - FAILS with password in an object
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user, *password, true)[jss::result];
             BEAST_EXPECT(jrr["error"] == proto_ws ? "forbidden" : "noPermission");
             BEAST_EXPECT(
@@ -300,6 +304,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                                                  : "You don't have permission for this command.");
 
             // 3 - FAILS with wrong user
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user + "_", *password)[jss::result];
             BEAST_EXPECT(jrr["error"] == proto_ws ? "forbidden" : "noPermission");
             BEAST_EXPECT(
@@ -314,6 +319,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                                                  : "You don't have permission for this command.");
 
             // 5 - SUCCEEDS with proper credentials
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             jrr = makeAdminRequest(env, proto, *user, *password)[jss::result];
             BEAST_EXPECT(jrr["status"] == "success");
         }
@@ -418,7 +424,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
 
         boost::system::error_code ec;
         response<string_body> resp;
-        auto req = makeWSUpgrade(*ip, *port);
+        auto req = makeWSUpgrade(*ip, *port);  // NOLINT(bugprone-unchecked-optional-access)
 
         // truncate the request message to near the value of the version header
         auto req_string = boost::lexical_cast<std::string>(req);
@@ -428,7 +434,8 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         ip::tcp::resolver r{ios};
         boost::beast::multi_buffer sb;
 
-        auto it = r.async_resolve(*ip, std::to_string(*port), yield[ec]);
+        auto it = r.async_resolve(
+            *ip, std::to_string(*port), yield[ec]);  // NOLINT(bugprone-unchecked-optional-access)
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
 
@@ -509,8 +516,10 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         doHTTPRequest(env, yield, secure, resp, ec, to_string(jr), auth);
         BEAST_EXPECT(resp.result() == boost::beast::http::status::forbidden);
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const user = env.app().config().section("port_rpc").get<std::string>("user").value();
         auto const pass =
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             env.app().config().section("port_rpc").get<std::string>("password").value();
 
         // try with the correct user/pass, but not encoded
@@ -538,7 +547,10 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                     return cfg;
                 })};
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const port = env.app().config()["port_rpc"].get<std::uint16_t>("port").value();
+
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const ip = env.app().config()["port_rpc"].get<std::string>("ip").value();
 
         boost::system::error_code ec;
@@ -596,7 +608,9 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
                     return cfg;
                 })};
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const port = env.app().config()["port_ws"].get<std::uint16_t>("port").value();
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const ip = env.app().config()["port_ws"].get<std::string>("ip").value();
         boost::beast::http::response<boost::beast::http::string_body> resp;
         boost::system::error_code ec;
@@ -615,7 +629,9 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         using namespace test::jtx;
         Env env{*this};
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const port = env.app().config()["port_ws"].get<std::uint16_t>("port").value();
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const ip = env.app().config()["port_ws"].get<std::string>("ip").value();
         boost::beast::http::response<boost::beast::http::string_body> resp;
         boost::system::error_code ec;
@@ -636,7 +652,9 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         using namespace boost::beast::http;
         Env env{*this};
 
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const port = env.app().config()["port_ws"].get<std::uint16_t>("port").value();
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
         auto const ip = env.app().config()["port_ws"].get<std::string>("ip").value();
         boost::system::error_code ec;
 
@@ -748,7 +766,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         response<string_body> resp;
 
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
@@ -784,7 +811,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
 
         // but status does not indicate a problem
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
@@ -795,7 +831,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         env.app().config().ELB_SUPPORT = true;
 
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
@@ -849,7 +894,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         response<string_body> resp;
 
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
@@ -888,7 +942,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         // but status does not indicate because it still relies on ELB
         // being enabled
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
@@ -898,7 +961,16 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         env.app().config().ELB_SUPPORT = true;
 
         doRequest(
-            yield, makeHTTPRequest(*ip_ws, *port_ws, "", {}), *ip_ws, *port_ws, false, resp, ec);
+            yield,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            makeHTTPRequest(*ip_ws, *port_ws, "", {}),
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *ip_ws,
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            *port_ws,
+            false,
+            resp,
+            ec);
 
         if (!BEAST_EXPECTS(!ec, ec.message()))
             return;
diff --git a/src/test/server/Server_test.cpp b/src/test/server/Server_test.cpp
index f7250de7fa..bc12d98659 100644
--- a/src/test/server/Server_test.cpp
+++ b/src/test/server/Server_test.cpp
@@ -100,8 +100,8 @@ public:
         Handoff
         onHandoff(
             Session& session,
-            std::unique_ptr<stream_type>&& bundle,
-            http_request_type&& request,
+            std::unique_ptr<stream_type> const& bundle,
+            http_request_type const& request,
             boost::asio::ip::tcp::endpoint remote_address)
         {
             return Handoff{};
@@ -110,7 +110,7 @@ public:
         Handoff
         onHandoff(
             Session& session,
-            http_request_type&& request,
+            http_request_type const& request,
             boost::asio::ip::tcp::endpoint remote_address)
         {
             return Handoff{};
@@ -232,7 +232,7 @@ public:
             return;
 
         boost::system::error_code ec;
-        s.shutdown(socket::shutdown_both, ec);
+        s.shutdown(socket::shutdown_both, ec);  // NOLINT(bugprone-unused-return-value)
 
         std::this_thread::sleep_for(std::chrono::seconds(1));
     }
@@ -268,7 +268,7 @@ public:
             return;
 
         boost::system::error_code ec;
-        s.shutdown(socket::shutdown_both, ec);
+        s.shutdown(socket::shutdown_both, ec);  // NOLINT(bugprone-unused-return-value)
     }
 
     void
@@ -308,8 +308,8 @@ public:
             Handoff
             onHandoff(
                 Session& session,
-                std::unique_ptr<stream_type>&& bundle,
-                http_request_type&& request,
+                std::unique_ptr<stream_type> const& bundle,
+                http_request_type const& request,
                 boost::asio::ip::tcp::endpoint remote_address)
             {
                 return Handoff{};
@@ -318,7 +318,7 @@ public:
             Handoff
             onHandoff(
                 Session& session,
-                http_request_type&& request,
+                http_request_type const& request,
                 boost::asio::ip::tcp::endpoint remote_address)
             {
                 return Handoff{};
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
index 8919241996..471ad91e95 100644
--- a/src/test/shamap/FetchPack_test.cpp
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -45,7 +45,7 @@ public:
             bool fromFilter,
             SHAMapHash const& nodeHash,
             std::uint32_t ledgerSeq,
-            Blob&& nodeData,
+            Blob&& nodeData,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
             SHAMapNodeType type) const override
         {
         }
diff --git a/src/test/unit_test/utils.h b/src/test/unit_test/utils.h
new file mode 100644
index 0000000000..1f6ee58436
--- /dev/null
+++ b/src/test/unit_test/utils.h
@@ -0,0 +1,19 @@
+#include <xrpl/protocol/SecretKey.h>
+
+#include <cstring>
+
+namespace xrpl {
+namespace test {
+
+/// Compare two SecretKey objects for equality.
+/// SecretKey::operator== is deleted, so a named function is used
+/// to avoid member-function lookup shadowing free-function overloads.
+inline bool
+equal(SecretKey const& lhs, SecretKey const& rhs)
+{
+    return lhs.size() == SecretKey::size_ && rhs.size() == SecretKey::size_ &&
+        std::memcmp(lhs.data(), rhs.data(), SecretKey::size_) == 0;
+}
+
+}  // namespace test
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/CMakeLists.txt b/src/tests/libxrpl/CMakeLists.txt
index cfa056b0aa..6bcb6aff89 100644
--- a/src/tests/libxrpl/CMakeLists.txt
+++ b/src/tests/libxrpl/CMakeLists.txt
@@ -14,7 +14,10 @@ target_link_libraries(xrpl.helpers.test PRIVATE xrpl.libxrpl)
 
 # Common library dependencies for the rest of the tests.
 add_library(xrpl.imports.test INTERFACE)
-target_link_libraries(xrpl.imports.test INTERFACE gtest::gtest xrpl.libxrpl xrpl.helpers.test)
+target_link_libraries(
+    xrpl.imports.test
+    INTERFACE gtest::gtest xrpl.libxrpl xrpl.helpers.test
+)
 
 # One test for each module.
 xrpl_add_test(basics)
@@ -30,8 +33,8 @@ target_link_libraries(xrpl.test.json PRIVATE xrpl.imports.test)
 add_dependencies(xrpl.tests xrpl.test.json)
 
 # Network unit tests are currently not supported on Windows
-if (NOT WIN32)
+if(NOT WIN32)
     xrpl_add_test(net)
     target_link_libraries(xrpl.test.net PRIVATE xrpl.imports.test)
     add_dependencies(xrpl.tests xrpl.test.net)
-endif ()
+endif()
diff --git a/src/tests/libxrpl/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
new file mode 100644
index 0000000000..3bcee92276
--- /dev/null
+++ b/src/tests/libxrpl/basics/Mutex.cpp
@@ -0,0 +1,288 @@
+#include <xrpl/basics/Mutex.hpp>
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <vector>
+
+using namespace xrpl;
+
+struct MutexMakeTest : ::testing::Test
+{
+};
+
+TEST_F(MutexMakeTest, default_constructor)
+{
+    auto m = Mutex<int>::make();
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 0);
+}
+
+TEST_F(MutexMakeTest, single_argument)
+{
+    auto m = Mutex<int>::make(42);
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexMakeTest, string_argument)
+{
+    auto m = Mutex<std::string>::make("test");
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "test");
+}
+
+TEST_F(MutexMakeTest, move_only_type)
+{
+    auto m = Mutex<std::unique_ptr<int>>::make(std::make_unique<int>(100));
+    auto lock = m.lock();
+    EXPECT_NE(lock->get(), nullptr);
+    EXPECT_EQ(**lock, 100);
+}
+
+struct MutexDirectConstructionTest : ::testing::Test
+{
+};
+
+TEST_F(MutexDirectConstructionTest, default_constructor)
+{
+    // Test default construction with a type that has a non-trivial
+    // default constructor
+    Mutex<std::string> m;
+    auto lock = m.lock();
+    EXPECT_TRUE(lock->empty());
+}
+
+TEST_F(MutexDirectConstructionTest, default_initialization)
+{
+    Mutex<int> m;
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 0);
+}
+
+TEST_F(MutexDirectConstructionTest, constructor_with_value)
+{
+    Mutex<int> m(42);
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexDirectConstructionTest, constructor_with_string)
+{
+    Mutex<std::string> m(std::string("hello"));
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "hello");
+}
+
+struct MutexLockNonConstTest : ::testing::Test
+{
+};
+
+TEST_F(MutexLockNonConstTest, operator_star)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(*lock, 10);
+        *lock = 20;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 20);
+}
+
+TEST_F(MutexLockNonConstTest, get_method)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock.get(), 10);
+        lock.get() = 30;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(lock.get(), 30);
+}
+
+TEST_F(MutexLockNonConstTest, operator_arrow)
+{
+    Mutex<std::string> m(std::string("test"));
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->size(), 4);
+        lock->append(" string");
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "test string");
+}
+
+TEST_F(MutexLockNonConstTest, multiple_modifications)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        *lock = 20;
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock.get(), 20);
+        lock.get() = 30;
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(*lock, 30);
+    }
+}
+
+struct MutexLockConstTest : ::testing::Test
+{
+};
+
+TEST_F(MutexLockConstTest, operator_star)
+{
+    Mutex<int> const m(42);
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexLockConstTest, get_method)
+{
+    Mutex<int> const m(42);
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(lock.get())>>);
+    EXPECT_EQ(lock.get(), 42);
+}
+
+TEST_F(MutexLockConstTest, operator_arrow)
+{
+    Mutex<std::string> const m(std::string("test"));
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->size(), 4);
+    EXPECT_EQ(lock->at(0), 't');
+}
+
+struct MutexConstCorrectnessTest : ::testing::Test
+{
+};
+
+TEST_F(MutexConstCorrectnessTest, non_const_allows_modification)
+{
+    Mutex<std::vector<int>> m({1, 2, 3, 4, 5});
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->size(), 5);
+        lock->push_back(6);
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(lock->size(), 6);
+    EXPECT_EQ(lock->back(), 6);
+}
+
+TEST_F(MutexConstCorrectnessTest, const_reference_provides_const_access)
+{
+    Mutex<std::vector<int>> m({1, 2, 3, 4, 5, 6});
+    Mutex<std::vector<int>> const& const_ref = m;
+    auto lock = const_ref.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->size(), 6);
+    EXPECT_EQ(lock->at(5), 6);
+}
+
+struct MutexDifferentLockTypesTest : ::testing::Test
+{
+};
+
+TEST_F(MutexDifferentLockTypesTest, lock_guard)
+{
+    Mutex<int> m(0);
+    {
+        auto lock = m.lock();
+        *lock = 1;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 1);
+}
+
+TEST_F(MutexDifferentLockTypesTest, unique_lock)
+{
+    Mutex<int> m(0);
+    auto lock = m.lock<std::unique_lock>();
+    EXPECT_EQ(*lock, 0);
+    *lock = 2;
+
+    std::unique_lock<std::mutex>& ul = lock;
+    ul.unlock();
+    ul.lock();
+    EXPECT_EQ(*lock, 2);
+}
+
+struct MutexSharedMutexTest : ::testing::Test
+{
+};
+
+TEST_F(MutexSharedMutexTest, shared_lock_for_const_access)
+{
+    Mutex<int, std::shared_mutex> m(100);
+    Mutex<int, std::shared_mutex> const& const_ref = m;
+    auto lock = const_ref.lock<std::shared_lock>();
+    EXPECT_EQ(*lock, 100);
+}
+
+TEST_F(MutexSharedMutexTest, unique_lock_for_mutable_access)
+{
+    Mutex<int, std::shared_mutex> m(100);
+    {
+        auto lock = m.lock<std::unique_lock>();
+        *lock = 200;
+    }
+    auto lock = m.lock<std::shared_lock>();
+    EXPECT_EQ(*lock, 200);
+}
+
+struct MutexComplexTypeTest : ::testing::Test
+{
+    struct Data
+    {
+        int x;
+        std::string y;
+
+        Data(int x_, std::string y_) : x(x_), y(std::move(y_))
+        {
+        }
+    };
+};
+
+TEST_F(MutexComplexTypeTest, construct_and_access)
+{
+    auto m = Mutex<Data>::make(42, "hello");
+    auto lock = m.lock();
+    EXPECT_EQ(lock->x, 42);
+    EXPECT_EQ(lock->y, "hello");
+}
+
+TEST_F(MutexComplexTypeTest, modify_fields)
+{
+    auto m = Mutex<Data>::make(42, "hello");
+    {
+        auto lock = m.lock();
+        lock->x = 100;
+        lock->y = "world";
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->x, 100);
+        EXPECT_EQ(lock->y, "world");
+    }
+}
+
+TEST_F(MutexComplexTypeTest, const_access_to_fields)
+{
+    auto const m = Mutex<Data>::make(42, "hello");
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->x, 42);
+    EXPECT_EQ(lock->y, "hello");
+}
diff --git a/src/tests/libxrpl/basics/Slice.cpp b/src/tests/libxrpl/basics/Slice.cpp
index 8fef0d61a3..0e5e0877d0 100644
--- a/src/tests/libxrpl/basics/Slice.cpp
+++ b/src/tests/libxrpl/basics/Slice.cpp
@@ -44,8 +44,8 @@ TEST(Slice, equality_and_inequality)
     }
 
     // Test slices of equal size but pointing to different data:
-    std::array<std::uint8_t, sizeof(data)> a;
-    std::array<std::uint8_t, sizeof(data)> b;
+    std::array<std::uint8_t, sizeof(data)> a{};
+    std::array<std::uint8_t, sizeof(data)> b{};
 
     for (std::size_t i = 0; i != sizeof(data); ++i)
         a[i] = b[i] = data[i];
diff --git a/src/tests/libxrpl/basics/mulDiv.cpp b/src/tests/libxrpl/basics/mulDiv.cpp
index c98c3fd61a..725bef399e 100644
--- a/src/tests/libxrpl/basics/mulDiv.cpp
+++ b/src/tests/libxrpl/basics/mulDiv.cpp
@@ -14,30 +14,30 @@ TEST(mulDiv, mulDiv)
 
     auto result = mulDiv(85, 20, 5);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 340);
+    EXPECT_EQ(*result, 340);  // NOLINT(bugprone-unchecked-optional-access)
     result = mulDiv(20, 85, 5);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 340);
+    EXPECT_EQ(*result, 340);  // NOLINT(bugprone-unchecked-optional-access)
 
     result = mulDiv(0, max - 1, max - 3);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 0);
+    EXPECT_EQ(*result, 0);  // NOLINT(bugprone-unchecked-optional-access)
     result = mulDiv(max - 1, 0, max - 3);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 0);
+    EXPECT_EQ(*result, 0);  // NOLINT(bugprone-unchecked-optional-access)
 
     result = mulDiv(max, 2, max / 2);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 4);
+    EXPECT_EQ(*result, 4);  // NOLINT(bugprone-unchecked-optional-access)
     result = mulDiv(max, 1000, max / 1000);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 1000000);
+    EXPECT_EQ(*result, 1000000);  // NOLINT(bugprone-unchecked-optional-access)
     result = mulDiv(max, 1000, max / 1001);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 1001000);
+    EXPECT_EQ(*result, 1001000);  // NOLINT(bugprone-unchecked-optional-access)
     result = mulDiv(max32 + 1, max32 + 1, 5);
     ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(*result, 3689348814741910323);
+    EXPECT_EQ(*result, 3689348814741910323);  // NOLINT(bugprone-unchecked-optional-access)
 
     // Overflow
     result = mulDiv(max - 1, max - 2, 5);
diff --git a/src/tests/libxrpl/basics/scope.cpp b/src/tests/libxrpl/basics/scope.cpp
index 309a41ec04..8efa4a84b1 100644
--- a/src/tests/libxrpl/basics/scope.cpp
+++ b/src/tests/libxrpl/basics/scope.cpp
@@ -35,7 +35,7 @@ TEST(scope, scope_exit)
             scope_exit x{[&i]() { i = 5; }};
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -47,7 +47,7 @@ TEST(scope, scope_exit)
             x.release();
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -85,7 +85,7 @@ TEST(scope, scope_fail)
             scope_fail x{[&i]() { i = 5; }};
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -97,7 +97,7 @@ TEST(scope, scope_fail)
             x.release();
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -135,7 +135,7 @@ TEST(scope, scope_success)
             scope_success x{[&i]() { i = 5; }};
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -147,7 +147,7 @@ TEST(scope, scope_success)
             x.release();
             throw 1;
         }
-        catch (...)
+        catch (...)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp
index cbca7c88a8..a7b7387ba1 100644
--- a/src/tests/libxrpl/json/Value.cpp
+++ b/src/tests/libxrpl/json/Value.cpp
@@ -761,16 +761,16 @@ TEST(json_value, move)
     EXPECT_EQ(v1.asDouble(), 2.5);
 
     Json::Value v2 = std::move(v1);
-    EXPECT_FALSE(v1);
+    EXPECT_FALSE(v1);  // NOLINT(bugprone-use-after-move)
     EXPECT_TRUE(v2.isDouble());
     EXPECT_EQ(v2.asDouble(), 2.5);
-    EXPECT_NE(v1, v2);
+    EXPECT_NE(v1, v2);  // NOLINT(bugprone-use-after-move)
 
     v1 = std::move(v2);
     EXPECT_TRUE(v1.isDouble());
     EXPECT_EQ(v1.asDouble(), 2.5);
-    EXPECT_FALSE(v2);
-    EXPECT_NE(v1, v2);
+    EXPECT_FALSE(v2);   // NOLINT(bugprone-use-after-move)
+    EXPECT_NE(v1, v2);  // NOLINT(bugprone-use-after-move)
 }
 
 TEST(json_value, comparisons)
@@ -1348,7 +1348,7 @@ TEST(json_value, memory_leak)
 
         // Note that the type() == nullValue check is implementation
         // specific and not guaranteed to be valid in the future.
-        EXPECT_EQ(temp.type(), Json::nullValue);
+        EXPECT_EQ(temp.type(), Json::nullValue);  // NOLINT(bugprone-use-after-move)
     }
 }
 
diff --git a/src/tests/libxrpl/net/HTTPClient.cpp b/src/tests/libxrpl/net/HTTPClient.cpp
index 1e93d47c3c..36159cb089 100644
--- a/src/tests/libxrpl/net/HTTPClient.cpp
+++ b/src/tests/libxrpl/net/HTTPClient.cpp
@@ -33,7 +33,7 @@ private:
     boost::asio::ip::tcp::endpoint endpoint_;
     bool running_{true};
     bool finished_{false};
-    unsigned short port_;
+    unsigned short port_{0};
 
     // Custom headers to return
     std::map<std::string, std::string> customHeaders_;
@@ -43,7 +43,7 @@ private:
     beast::Journal j_;
 
 public:
-    TestHTTPServer() : acceptor_(ioc_), port_(0), j_(TestSink::instance())
+    TestHTTPServer() : acceptor_(ioc_), j_(TestSink::instance())
     {
         // Bind to any available port
         endpoint_ = {boost::asio::ip::tcp::v4(), 0};
@@ -173,6 +173,8 @@ private:
 
             // Shutdown socket gracefully
             boost::system::error_code shutdownEc;
+
+            // NOLINTNEXTLINE(bugprone-unused-return-value)
             socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, shutdownEc);
         }
         catch (std::exception const& e)
@@ -183,61 +185,86 @@ private:
     }
 };
 
-// Helper function to run HTTP client test
-bool
-runHTTPTest(
-    TestHTTPServer& server,
-    std::string const& path,
-    bool& completed,
-    int& resultStatus,
-    std::string& resultData,
-    boost::system::error_code& resultError)
-{
-    // Create a null journal for testing
-    beast::Journal j{TestSink::instance()};
-
-    // Initialize HTTPClient SSL context
-    HTTPClient::initializeSSLContext("", "", false, j);
-
-    HTTPClient::get(
-        false,  // no SSL
-        server.ioc(),
-        "127.0.0.1",
-        server.port(),
-        path,
-        1024,  // max response size
-        std::chrono::seconds(5),
-        [&](boost::system::error_code const& ec, int status, std::string const& data) -> bool {
-            resultError = ec;
-            resultStatus = status;
-            resultData = data;
-            completed = true;
-            return false;  // don't retry
-        },
-        j);
-
-    // Run the IO context until completion
-    auto start = std::chrono::steady_clock::now();
-    while (server.ioc().run_one() != 0)
-    {
-        if (std::chrono::steady_clock::now() - start >= std::chrono::seconds(10) ||
-            server.finished())
-        {
-            break;
-        }
-
-        if (completed)
-        {
-            server.stop();
-        }
-    }
-
-    return completed;
-}
-
 }  // anonymous namespace
 
-TEST(HTTPClient, case_insensitive_content_length)
+// Test fixture that manages the SSL context lifecycle via RAII.
+// SetUp() initializes the context before each test and TearDown()
+// cleans it up afterwards, so individual tests don't need to worry
+// about resource management.
+class HTTPClientTest : public ::testing::Test
+{
+protected:
+    // Shared journal for SSL context initialization and HTTP requests.
+    beast::Journal j_{TestSink::instance()};
+
+    // Initialize the global SSL context used by HTTPClient.
+    void
+    SetUp() override
+    {
+        HTTPClient::initializeSSLContext(
+            "" /* sslVerifyDir*/, "" /*sslVerifyFile */, false /* sslVerify */, j_ /* journal */);
+    }
+
+    // Release the global SSL context to prevent memory leaks.
+    void
+    TearDown() override
+    {
+        HTTPClient::cleanupSSLContext();
+    }
+
+    // Issue an HTTP GET to the given test server and drive the
+    // io_context until a response arrives or a timeout is reached.
+    // Returns true when the completion handler was invoked.
+    bool
+    runHTTPTest(
+        TestHTTPServer& server,
+        std::string const& path,
+        bool& completed,
+        int& resultStatus,
+        std::string& resultData,
+        boost::system::error_code& resultError)
+    {
+        HTTPClient::get(
+            false,  // no SSL
+            server.ioc(),
+            "127.0.0.1",
+            server.port(),
+            path,
+            1024,  // max response size
+            std::chrono::seconds(5),
+            [&](boost::system::error_code const& ec, int status, std::string const& data) -> bool {
+                resultError = ec;
+                resultStatus = status;
+                resultData = data;
+                completed = true;
+                return false;  // don't retry
+            },
+            j_);
+
+        // Run the IO context until completion
+        auto start = std::chrono::steady_clock::now();
+        while (server.ioc().run_one() != 0)
+        {
+            if (std::chrono::steady_clock::now() - start >= std::chrono::seconds(10) ||
+                server.finished())
+            {
+                break;
+            }
+
+            if (completed)
+            {
+                server.stop();
+            }
+        }
+
+        // Drain any remaining handlers to ensure proper cleanup of HTTPClientImp
+        server.ioc().poll();
+
+        return completed;
+    }
+};
+
+TEST_F(HTTPClientTest, case_insensitive_content_length)
 {
     // Test different cases of Content-Length header
     std::vector<std::string> headerCases = {
@@ -262,7 +289,6 @@ TEST(HTTPClient, case_insensitive_content_length)
 
         bool testCompleted =
             runHTTPTest(server, "/test", completed, resultStatus, resultData, resultError);
-
         // Verify results
         EXPECT_TRUE(testCompleted);
         EXPECT_FALSE(resultError);
@@ -271,7 +297,7 @@ TEST(HTTPClient, case_insensitive_content_length)
     }
 }
 
-TEST(HTTPClient, basic_http_request)
+TEST_F(HTTPClientTest, basic_http_request)
 {
     TestHTTPServer server;
     std::string testBody = "Test response body";
@@ -292,7 +318,7 @@ TEST(HTTPClient, basic_http_request)
     EXPECT_EQ(resultData, testBody);
 }
 
-TEST(HTTPClient, empty_response)
+TEST_F(HTTPClientTest, empty_response)
 {
     TestHTTPServer server;
     server.setResponseBody("");  // Empty body
@@ -312,7 +338,7 @@ TEST(HTTPClient, empty_response)
     EXPECT_TRUE(resultData.empty());
 }
 
-TEST(HTTPClient, different_status_codes)
+TEST_F(HTTPClientTest, different_status_codes)
 {
     std::vector<unsigned int> statusCodes = {200, 404, 500};
 
diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp
index 98dccc0089..16cf7f4c9d 100644
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -78,8 +78,6 @@ RCLConsensus::Adaptor::Adaptor(
 
     if (validatorKeys_.nodeID != beast::zero && validatorKeys_.keys)
     {
-        std::stringstream ss;
-
         JLOG(j_.info()) << "Validator identity: "
                         << toBase58(TokenType::NodePublic, validatorKeys_.keys->masterPublicKey);
 
@@ -384,7 +382,10 @@ RCLConsensus::Adaptor::onAccept(
     bool const validating)
 {
     app_.getJobQueue().addJob(
-        jtACCEPT, "AcceptLedger", [=, this, cj = std::move(consensusJson)]() mutable {
+        jtACCEPT,
+        "AcceptLedger",
+        // NOLINTNEXTLINE(cppcoreguidelines-misleading-capture-default-by-value)
+        [=, this, cj = std::move(consensusJson)]() mutable {
             // Note that no lock is held or acquired during this job.
             // This is because generic Consensus guarantees that once a ledger
             // is accepted, the consensus results and capture by reference state
@@ -408,7 +409,7 @@ RCLConsensus::Adaptor::doAccept(
     prevProposers_ = result.proposers;
     prevRoundTime_ = result.roundTime.read();
 
-    bool closeTimeCorrect;
+    bool closeTimeCorrect = false;
 
     bool const proposing = mode == ConsensusMode::proposing;
     bool const haveCorrectLCL = mode != ConsensusMode::wrongLedger;
@@ -673,7 +674,7 @@ RCLConsensus::Adaptor::notify(
         ledger.parentID().begin(), std::decay_t<decltype(ledger.parentID())>::bytes);
     s.set_ledgerhash(ledger.id().begin(), std::decay_t<decltype(ledger.id())>::bytes);
 
-    std::uint32_t uMin, uMax;
+    std::uint32_t uMin = 0, uMax = 0;
     if (!ledgerMaster_.getFullValidatedRange(uMin, uMax))
     {
         uMin = 0;
diff --git a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
index 575a1a1460..48080aaedb 100644
--- a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
+++ b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
@@ -21,7 +21,7 @@ ConsensusTransSetSF::gotNode(
     bool fromFilter,
     SHAMapHash const& nodeHash,
     std::uint32_t,
-    Blob&& nodeData,
+    Blob&& nodeData,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
     SHAMapNodeType type) const
 {
     if (fromFilter)
diff --git a/src/xrpld/app/ledger/Ledger.cpp b/src/xrpld/app/ledger/Ledger.cpp
index bde5ca010a..3a81b5f3a3 100644
--- a/src/xrpld/app/ledger/Ledger.cpp
+++ b/src/xrpld/app/ledger/Ledger.cpp
@@ -846,7 +846,7 @@ Ledger::updateSkipList()
         auto sle = peek(k);
         std::vector<uint256> hashes;
 
-        bool created;
+        bool created = false;
         if (!sle)
         {
             sle = std::make_shared<SLE>(k);
@@ -873,7 +873,7 @@ Ledger::updateSkipList()
     auto const k = keylet::skip();
     auto sle = peek(k);
     std::vector<uint256> hashes;
-    bool created;
+    bool created = false;
     if (!sle)
     {
         sle = std::make_shared<SLE>(k);
@@ -1003,7 +1003,7 @@ Ledger::invariants() const
 std::shared_ptr<Ledger>
 loadLedgerHelper(LedgerHeader const& info, Application& app, bool acquire)
 {
-    bool loaded;
+    bool loaded = false;
     auto ledger = std::make_shared<Ledger>(
         info, loaded, acquire, app.config(), app.getNodeFamily(), app.journal("Ledger"));
 
diff --git a/src/xrpld/app/ledger/LedgerReplayTask.h b/src/xrpld/app/ledger/LedgerReplayTask.h
index 028e7ba0bd..030121b240 100644
--- a/src/xrpld/app/ledger/LedgerReplayTask.h
+++ b/src/xrpld/app/ledger/LedgerReplayTask.h
@@ -78,7 +78,7 @@ public:
         InboundLedgers& inboundLedgers,
         LedgerReplayer& replayer,
         std::shared_ptr<SkipListAcquire>& skipListAcquirer,
-        TaskParameter&& parameter);
+        TaskParameter const& parameter);
 
     ~LedgerReplayTask();
 
diff --git a/src/xrpld/app/ledger/OrderBookDBImpl.cpp b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
index a4eb0fb1ca..b82fa3896b 100644
--- a/src/xrpld/app/ledger/OrderBookDBImpl.cpp
+++ b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/core/JobQueue.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/server/NetworkOPs.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index 4dd8ab887e..b8158e507f 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -1056,8 +1056,6 @@ InboundLedger::processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& p
 
     if ((packet.type() == protocol::liTX_NODE) || (packet.type() == protocol::liAS_NODE))
     {
-        std::string type = packet.type() == protocol::liTX_NODE ? "liTX_NODE: " : "liAS_NODE: ";
-
         if (packet.nodes().empty())
         {
             JLOG(journal_.info()) << peer->id() << ": response with no nodes";
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
index a8ae530bde..a5fdd889ec 100644
--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -241,7 +241,7 @@ public:
                     newNode->getHash().as_uint256(), std::make_shared<Blob>(s.begin(), s.end()));
             }
         }
-        catch (std::exception const&)
+        catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     }
@@ -340,7 +340,7 @@ public:
 
         // Make a list of things to sweep, while holding the lock
         std::vector<MapType::mapped_type> stuffToSweep;
-        std::size_t total;
+        std::size_t total = 0;
 
         {
             ScopedLockType sl(mLock);
diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
index b6f4c961c1..b10adad438 100644
--- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp
+++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
@@ -50,7 +50,6 @@ public:
         std::function<void(std::shared_ptr<SHAMap> const&, bool)> gotSet,
         std::unique_ptr<PeerSetBuilder> peerSetBuilder)
         : app_(app)
-        , m_seq(0)
         , m_zeroSet(m_map[uint256()])
         , m_gotSet(std::move(gotSet))
         , m_peerSetBuilder(std::move(peerSetBuilder))
@@ -227,7 +226,7 @@ private:
 
     bool stopping_{false};
     MapType m_map;
-    std::uint32_t m_seq;
+    std::uint32_t m_seq{0};
 
     // The empty transaction set whose hash is zero
     InboundTransactionSet& m_zeroSet;
diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
index ad9c6a277d..4266185591 100644
--- a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
@@ -356,10 +356,10 @@ private:
 
         while (!shouldExit())
         {
-            LedgerIndex ledgerIndex;
+            LedgerIndex ledgerIndex = 0;
             LedgerHash ledgerHash;
-            bool doNodes;
-            bool doTxns;
+            bool doNodes = false;
+            bool doTxns = false;
 
             if (app_.getFeeTrack().isLoadedLocal())
             {
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
index 8072b619e1..178e14f5c1 100644
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -927,7 +927,7 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
         fees.reserve(fees.size() + fees2.size());
         std::copy(fees2.begin(), fees2.end(), std::back_inserter(fees));
     }
-    std::uint32_t fee;
+    std::uint32_t fee = 0;
     if (!fees.empty())
     {
         std::sort(fees.begin(), fees.end());
@@ -1063,10 +1063,7 @@ LedgerMaster::consensusBuilt(
     class valSeq
     {
     public:
-        valSeq() : valCount_(0), ledgerSeq_(0)
-        {
-            ;
-        }
+        valSeq() = default;
 
         void
         mergeValidation(LedgerIndex seq)
@@ -1078,8 +1075,8 @@ LedgerMaster::consensusBuilt(
                 ledgerSeq_ = seq;
         }
 
-        std::size_t valCount_;
-        LedgerIndex ledgerSeq_;
+        std::size_t valCount_{0};
+        LedgerIndex ledgerSeq_{0};
     };
 
     // Count the number of current, trusted validations
@@ -1637,7 +1634,7 @@ LedgerMaster::getLedgerBySeq(std::uint32_t index)
                 if (hash)
                     return mLedgerHistory.getLedgerByHash(*hash);
             }
-            catch (std::exception const&)
+            catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
             {
                 // Missing nodes are already handled
             }
@@ -1750,7 +1747,7 @@ LedgerMaster::fetchForHistory(
             XRPL_ASSERT(seq == missing, "xrpl::LedgerMaster::fetchForHistory : sequence match");
             JLOG(m_journal.trace()) << "fetchForHistory acquired " << seq;
             setFullLedger(ledger, false, false);
-            int fillInProgress;
+            int fillInProgress = 0;
             {
                 std::lock_guard lock(m_mutex);
                 mHistLedger = ledger;
@@ -1771,7 +1768,7 @@ LedgerMaster::fetchForHistory(
         }
         else
         {
-            std::uint32_t fetchSz;
+            std::uint32_t fetchSz = 0;
             // Do not fetch ledger sequences lower
             // than the earliest ledger sequence
             fetchSz = app_.getNodeStore().earliestLedgerSeq();
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
index 73fcf77e4e..93cf0e5cce 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
@@ -3,6 +3,7 @@
 #include <xrpld/app/ledger/detail/LedgerReplayMsgHandler.h>
 #include <xrpld/app/main/Application.h>
 
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/protocol/LedgerHeader.h>
 
 #include <memory>
@@ -136,7 +137,7 @@ LedgerReplayMsgHandler::processProofPathResponse(
         return false;
     }
 
-    if (auto item = static_cast<SHAMapLeafNode*>(node.get())->peekItem())
+    if (auto item = safe_downcast<SHAMapLeafNode*>(node.get())->peekItem())
     {
         replayer_.gotSkipList(info, item);
         return true;
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
index 42db911830..8f225335c7 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
@@ -67,7 +67,7 @@ LedgerReplayTask::LedgerReplayTask(
     InboundLedgers& inboundLedgers,
     LedgerReplayer& replayer,
     std::shared_ptr<SkipListAcquire>& skipListAcquirer,
-    TaskParameter&& parameter)
+    TaskParameter const& parameter)
     : TimeoutCounter(
           app,
           parameter.finishHash_,
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
index f649eb4d95..5aacf5b5a6 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
@@ -98,8 +98,12 @@ LedgerReplayer::createDeltas(std::shared_ptr<LedgerReplayTask> task)
     {
         auto skipListItem =
             std::find(parameter.skipList_.begin(), parameter.skipList_.end(), parameter.startHash_);
-        if (skipListItem == parameter.skipList_.end() ||
-            ++skipListItem == parameter.skipList_.end())
+        auto const wasLast = skipListItem == parameter.skipList_.end();
+        if (not wasLast)
+            ++skipListItem;
+        auto const isLast = skipListItem == parameter.skipList_.end();
+
+        if (wasLast || isLast)
         {
             JLOG(j_.error()) << "Task parameter error when creating deltas "
                              << parameter.finishHash_;
diff --git a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
index 0fb1239c49..2191ef965a 100644
--- a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
@@ -127,7 +127,7 @@ SkipListAcquire::processData(
             return;
         }
     }
-    catch (...)
+    catch (...)  // NOLINT(bugprone-empty-catch)
     {
     }
 
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index 1162bc497a..53eada2dec 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -1072,6 +1072,12 @@ public:
         return trapTxID_;
     }
 
+    size_t
+    getNumberOfThreads() const override
+    {
+        return get_number_of_threads();
+    }
+
 private:
     // For a newly-started validator, this is the greatest persisted ledger
     // and new validations must be greater than this.
@@ -1340,7 +1346,8 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline)
     {
         try
         {
-            auto setup = setup_ServerHandler(*config_, beast::logstream{m_journal.error()});
+            beast::logstream logStream{m_journal.error()};
+            auto setup = setup_ServerHandler(*config_, logStream);
             setup.makeContexts();
             serverHandler_->setup(setup, m_journal);
             fixConfigPorts(*config_, serverHandler_->endpoints());
@@ -1861,7 +1868,7 @@ ApplicationImp::loadOldLedger(
         else
         {
             // assume by sequence
-            std::uint32_t index;
+            std::uint32_t index = 0;
 
             if (beast::lexicalCastChecked(index, ledgerID))
                 loadLedger = loadByIndex(index, *this);
diff --git a/src/xrpld/app/main/Application.h b/src/xrpld/app/main/Application.h
index 433992bcda..0000ae010b 100644
--- a/src/xrpld/app/main/Application.h
+++ b/src/xrpld/app/main/Application.h
@@ -157,6 +157,10 @@ public:
      * than the last ledger it persisted. */
     virtual LedgerIndex
     getMaxDisallowedLedger() = 0;
+
+    /** Returns the number of io_context (I/O worker) threads used by the application. */
+    virtual size_t
+    getNumberOfThreads() const = 0;
 };
 
 std::unique_ptr<Application>
diff --git a/src/xrpld/app/main/BasicApp.h b/src/xrpld/app/main/BasicApp.h
index 278c255af3..19f07d1e5b 100644
--- a/src/xrpld/app/main/BasicApp.h
+++ b/src/xrpld/app/main/BasicApp.h
@@ -23,4 +23,10 @@ public:
     {
         return io_context_;
     }
+
+    size_t
+    get_number_of_threads() const
+    {
+        return threads_.size();
+    }
 };
diff --git a/src/xrpld/app/main/GRPCServer.cpp b/src/xrpld/app/main/GRPCServer.cpp
index ced252cb71..7f4fb57fb7 100644
--- a/src/xrpld/app/main/GRPCServer.cpp
+++ b/src/xrpld/app/main/GRPCServer.cpp
@@ -29,7 +29,7 @@ getEndpoint(std::string const& peer)
         if (endpoint)
             return beast::IP::to_asio_endpoint(endpoint.value());
     }
-    catch (std::exception const&)
+    catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
     {
     }
     return {};
@@ -383,8 +383,8 @@ GRPCServerImpl::handleRpcs()
         requests.pop_back();
     };
 
-    void* tag;  // uniquely identifies a request.
-    bool ok;
+    void* tag = nullptr;  // uniquely identifies a request.
+    bool ok = false;
     // Block waiting to read the next event from the completion queue. The
     // event is uniquely identified by its tag, which in this case is the
     // memory address of a CallData instance.
diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp
index 83bdb51ec1..7c440d728c 100644
--- a/src/xrpld/app/main/Main.cpp
+++ b/src/xrpld/app/main/Main.cpp
@@ -6,6 +6,7 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/core/CurrentThreadName.h>
+#include <xrpl/git/Git.h>
 #include <xrpl/protocol/BuildInfo.h>
 #include <xrpl/server/Vacuum.h>
 
@@ -60,7 +61,7 @@ adjustDescriptorLimit(int needed, beast::Journal j)
 {
 #ifdef RLIMIT_NOFILE
     // Get the current limit, then adjust it to what we need.
-    struct rlimit rl;
+    struct rlimit rl{};
 
     int available = 0;
 
@@ -102,7 +103,7 @@ adjustDescriptorLimit(int needed, beast::Journal j)
 void
 printHelp(po::options_description const& desc)
 {
-    std::cerr << systemName() << "d [options] <command> <params>\n"
+    std::cerr << systemName() << " [options] <command> <params>\n"
               << desc << std::endl
               << "Commands: \n"
                  "     account_currencies <account> [<ledger>]\n"
@@ -476,12 +477,8 @@ run(int argc, char** argv)
     if (vm.count("version"))
     {
         std::cout << "rippled version " << BuildInfo::getVersionString() << std::endl;
-#ifdef GIT_COMMIT_HASH
-        std::cout << "Git commit hash: " << GIT_COMMIT_HASH << std::endl;
-#endif
-#ifdef GIT_BRANCH
-        std::cout << "Git build branch: " << GIT_BRANCH << std::endl;
-#endif
+        std::cout << "Git commit hash: " << xrpl::git::getCommitHash() << std::endl;
+        std::cout << "Git build branch: " << xrpl::git::getBuildBranch() << std::endl;
         return 0;
     }
 
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index 2cdca4a1c7..d8039c84ba 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -40,6 +40,7 @@
 #include <xrpl/core/PerfLog.h>
 #include <xrpl/crypto/RFC1751.h>
 #include <xrpl/crypto/csprng.h>
+#include <xrpl/git/Git.h>
 #include <xrpl/ledger/AmendmentTable.h>
 #include <xrpl/ledger/OrderBookDB.h>
 #include <xrpl/protocol/BuildInfo.h>
@@ -164,9 +165,9 @@ class NetworkOPsImp final : public NetworkOPs
         struct CounterData
         {
             decltype(counters_) counters;
-            decltype(mode_) mode;
+            decltype(mode_) mode = OperatingMode::DISCONNECTED;
             decltype(start_) start;
-            decltype(initialSyncUs_) initialSyncUs;
+            decltype(initialSyncUs_) initialSyncUs{};
         };
 
         CounterData
@@ -647,23 +648,16 @@ private:
     {
         AccountID const accountId_;
         // forward
-        std::uint32_t forwardTxIndex_;
+        std::uint32_t forwardTxIndex_{0};
         // separate backward and forward
-        std::uint32_t separationLedgerSeq_;
+        std::uint32_t separationLedgerSeq_{0};
         // history, backward
-        std::uint32_t historyLastLedgerSeq_;
-        std::int32_t historyTxIndex_;
-        bool haveHistorical_;
-        std::atomic<bool> stopHistorical_;
+        std::uint32_t historyLastLedgerSeq_{0};
+        std::int32_t historyTxIndex_{-1};
+        bool haveHistorical_{false};
+        std::atomic<bool> stopHistorical_{false};
 
-        SubAccountHistoryIndex(AccountID const& accountId)
-            : accountId_(accountId)
-            , forwardTxIndex_(0)
-            , separationLedgerSeq_(0)
-            , historyLastLedgerSeq_(0)
-            , historyTxIndex_(-1)
-            , haveHistorical_(false)
-            , stopHistorical_(false)
+        SubAccountHistoryIndex(AccountID const& accountId) : accountId_(accountId)
         {
         }
     };
@@ -716,7 +710,7 @@ private:
     std::optional<PublicKey> const validatorPK_;
     std::optional<PublicKey> const validatorMasterPK_;
 
-    ConsensusPhase mLastConsensusPhase;
+    ConsensusPhase mLastConsensusPhase{ConsensusPhase::open};
 
     LedgerMaster& m_ledgerMaster;
 
@@ -1639,7 +1633,7 @@ NetworkOPsImp::getOwnerInfo(std::shared_ptr<ReadView const> lpLedger, AccountID
     auto sleNode = lpLedger->read(keylet::page(root));
     if (sleNode)
     {
-        std::uint64_t uNodeDir;
+        std::uint64_t uNodeDir = 0;
 
         do
         {
@@ -2535,6 +2529,9 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
 
     if (admin)
     {
+        // Note: By default the node size is "tiny". When parsing it's an error if the final
+        // NODE_SIZE is over 4 so below code should be safe.
+        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
         switch (registry_.app().config().NODE_SIZE)
         {
             case 0:
@@ -2594,17 +2591,14 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
             }
         }
 
-#if defined(GIT_COMMIT_HASH) || defined(GIT_BRANCH)
+        if (!xrpl::git::getCommitHash().empty() || !xrpl::git::getBuildBranch().empty())
         {
             auto& x = (info[jss::git] = Json::objectValue);
-#ifdef GIT_COMMIT_HASH
-            x[jss::hash] = GIT_COMMIT_HASH;
-#endif
-#ifdef GIT_BRANCH
-            x[jss::branch] = GIT_BRANCH;
-#endif
+            if (!xrpl::git::getCommitHash().empty())
+                x[jss::hash] = xrpl::git::getCommitHash();
+            if (!xrpl::git::getBuildBranch().empty())
+                x[jss::branch] = xrpl::git::getBuildBranch();
         }
-#endif
     }
     info[jss::io_latency_ms] = static_cast<Json::UInt>(registry_.app().getIOLatency().count());
 
@@ -3597,7 +3591,8 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                 switch (dbType)
                 {
                     case Sqlite: {
-                        auto db = static_cast<SQLiteDatabase*>(&registry_.getRelationalDatabase());
+                        auto db =
+                            safe_downcast<SQLiteDatabase*>(&registry_.getRelationalDatabase());
                         RelationalDatabase::AccountTxPageOptions options{
                             accountId, minLedger, maxLedger, marker, 0, true};
                         return db->newestAccountTxPage(options);
@@ -4203,7 +4198,7 @@ NetworkOPsImp::getBookPage(
 
     std::shared_ptr<SLE const> sleOfferDir;
     uint256 offerIndex;
-    unsigned int uBookEntry;
+    unsigned int uBookEntry = 0;
     STAmount saDirRate;
 
     auto const rate = transferRate(view, book.out.account);
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 47e9f0ef52..60dcd90388 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.cpp
+++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp
@@ -97,7 +97,7 @@ SHAMapStoreImp::SHAMapStoreImp(
     {
         // Configuration that affects the behavior of online delete
         get_if_exists(section, "delete_batch", deleteBatch_);
-        std::uint32_t temp;
+        std::uint32_t temp = 0;
         if (get_if_exists(section, "back_off_milliseconds", temp) ||
             // Included for backward compatibility with an undocumented setting
             get_if_exists(section, "backOff", temp))
diff --git a/src/xrpld/app/misc/ValidatorSite.h b/src/xrpld/app/misc/ValidatorSite.h
index 9c2d45fb6d..9d9031b9a2 100644
--- a/src/xrpld/app/misc/ValidatorSite.h
+++ b/src/xrpld/app/misc/ValidatorSite.h
@@ -197,7 +197,7 @@ private:
     onSiteFetch(
         boost::system::error_code const& ec,
         endpoint_type const& endpoint,
-        detail::response_type&& res,
+        detail::response_type const& res,
         std::size_t siteIdx);
 
     /// Store latest list fetched from anywhere
@@ -224,7 +224,7 @@ private:
     /// lock over sites_mutex_ required
     std::shared_ptr<Site::Resource>
     processRedirect(
-        detail::response_type& res,
+        detail::response_type const& res,
         std::size_t siteIdx,
         std::lock_guard<std::mutex> const&);
 
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 196584fe6f..5bdd604828 100644
--- a/src/xrpld/app/misc/detail/AmendmentTable.cpp
+++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp
@@ -357,7 +357,7 @@ private:
     mutable std::mutex mutex_;
 
     hash_map<uint256, AmendmentState> amendmentMap_;
-    std::uint32_t lastUpdateSeq_;
+    std::uint32_t lastUpdateSeq_{0};
 
     // Record of the last votes seen from trusted validators.
     TrustedVotes previousTrustedVotes_;
@@ -370,7 +370,7 @@ private:
     std::unique_ptr<AmendmentSet> lastVote_;
 
     // True if an unsupported amendment is enabled
-    bool unsupportedEnabled_;
+    bool unsupportedEnabled_{false};
 
     // Unset if no unsupported amendments reach majority,
     // else set to the earliest time an unsupported amendment
@@ -477,11 +477,7 @@ AmendmentTableImpl::AmendmentTableImpl(
     Section const& enabled,
     Section const& vetoed,
     beast::Journal journal)
-    : lastUpdateSeq_(0)
-    , majorityTime_(majorityTime)
-    , unsupportedEnabled_(false)
-    , j_(journal)
-    , db_(registry.getWalletDB())
+    : majorityTime_(majorityTime), j_(journal), db_(registry.getWalletDB())
 {
     std::lock_guard lock(mutex_);
 
diff --git a/src/xrpld/app/misc/detail/Transaction.cpp b/src/xrpld/app/misc/detail/Transaction.cpp
index fae26873fb..35b49504d5 100644
--- a/src/xrpld/app/misc/detail/Transaction.cpp
+++ b/src/xrpld/app/misc/detail/Transaction.cpp
@@ -53,26 +53,26 @@ Transaction::setStatus(
 TransStatus
 Transaction::sqlTransactionStatus(boost::optional<std::string> const& status)
 {
-    char const c = (status) ? (*status)[0] : safe_cast<char>(txnSqlUnknown);
+    auto const c = (status) ? safe_cast<TxnSql>((*status)[0]) : TxnSql::txnSqlUnknown;
 
-    switch (c)
+    switch (static_cast<TxnSql>(c))
     {
-        case txnSqlNew:
+        case TxnSql::txnSqlNew:
             return NEW;
-        case txnSqlConflict:
+        case TxnSql::txnSqlConflict:
             return CONFLICTED;
-        case txnSqlHeld:
+        case TxnSql::txnSqlHeld:
             return HELD;
-        case txnSqlValidated:
+        case TxnSql::txnSqlValidated:
             return COMMITTED;
-        case txnSqlIncluded:
+        case TxnSql::txnSqlIncluded:
             return INCLUDED;
+        default:
+            XRPL_ASSERT(
+                c == TxnSql::txnSqlUnknown,
+                "xrpl::Transaction::sqlTransactionStatus : unknown transaction status");
     }
 
-    XRPL_ASSERT(
-        c == txnSqlUnknown,
-        "xrpl::Transaction::sqlTransactionStatus : unknown transaction "
-        "status");
     return INVALID;
 }
 
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index 718b468ff0..caa5a15ff1 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -1798,7 +1798,7 @@ setup_TxQ(Config const& config)
     set(setup.minimumTxnInLedger, "minimum_txn_in_ledger", section);
     set(setup.minimumTxnInLedgerSA, "minimum_txn_in_ledger_standalone", section);
     set(setup.targetTxnInLedger, "target_txn_in_ledger", section);
-    std::uint32_t max;
+    std::uint32_t max = 0;
     if (set(max, "maximum_txn_in_ledger", section))
     {
         if (max < setup.minimumTxnInLedger)
diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp
index fb68bf5ef4..0a207c344c 100644
--- a/src/xrpld/app/misc/detail/ValidatorSite.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp
@@ -177,7 +177,7 @@ ValidatorSite::stop()
     {
         timer_.cancel();
     }
-    catch (boost::system::system_error const&)
+    catch (boost::system::system_error const&)  // NOLINT(bugprone-empty-catch)
     {
     }
     stopping_ = false;
@@ -222,7 +222,7 @@ ValidatorSite::makeRequest(
         {
             timer_.cancel_one();
         }
-        catch (boost::system::system_error const&)
+        catch (boost::system::system_error const&)  // NOLINT(bugprone-empty-catch)
         {
         }
     };
@@ -367,7 +367,7 @@ ValidatorSite::parseJsonResponse(
             body[jss::manifest].isString() && body.isMember(jss::version) &&
             body[jss::version].isInt();
         // Check the version-specific blob & signature fields
-        std::uint32_t version;
+        std::uint32_t version = 0;
         std::vector<ValidatorBlobInfo> blobs;
         if (valid)
         {
@@ -453,7 +453,7 @@ ValidatorSite::parseJsonResponse(
 
 std::shared_ptr<ValidatorSite::Site::Resource>
 ValidatorSite::processRedirect(
-    detail::response_type& res,
+    detail::response_type const& res,
     std::size_t siteIdx,
     std::lock_guard<std::mutex> const& sites_lock)
 {
@@ -496,7 +496,7 @@ void
 ValidatorSite::onSiteFetch(
     boost::system::error_code const& ec,
     endpoint_type const& endpoint,
-    detail::response_type&& res,
+    detail::response_type const& res,
     std::size_t siteIdx)
 {
     std::lock_guard lock_sites{sites_mutex_};
diff --git a/src/xrpld/app/paths/AMMLiquidity.h b/src/xrpld/app/paths/AMMLiquidity.h
index 5c3ff2a8e6..71b8dbb12a 100644
--- a/src/xrpld/app/paths/AMMLiquidity.h
+++ b/src/xrpld/app/paths/AMMLiquidity.h
@@ -4,9 +4,9 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Quality.h>
-#include <xrpl/tx/transactors/AMM/AMMContext.h>
-#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMContext.h>
+#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 namespace xrpl {
 
diff --git a/src/xrpld/app/paths/PathRequest.h b/src/xrpld/app/paths/PathRequest.h
index fde499a312..0ffc6c6e2c 100644
--- a/src/xrpld/app/paths/PathRequest.h
+++ b/src/xrpld/app/paths/PathRequest.h
@@ -139,7 +139,7 @@ private:
 
     std::optional<uint256> domain;
 
-    bool convert_all_;
+    bool convert_all_{};
 
     std::recursive_mutex mIndexLock;
     LedgerIndex mLastIndex;
diff --git a/src/xrpld/app/paths/Pathfinder.cpp b/src/xrpld/app/paths/Pathfinder.cpp
index 254db35ea5..b852ebd4d4 100644
--- a/src/xrpld/app/paths/Pathfinder.cpp
+++ b/src/xrpld/app/paths/Pathfinder.cpp
@@ -260,7 +260,7 @@ Pathfinder::findPaths(int searchLevel, std::function<bool(void)> const& continue
 
     // Now compute the payment type from the types of the source and destination
     // currencies.
-    PaymentType paymentType;
+    PaymentType paymentType = pt_XRP_to_XRP;
     if (bSrcXrp && bDstXrp)
     {
         // XRP -> XRP
@@ -491,7 +491,7 @@ Pathfinder::rankPaths(
         if (!currentPath.empty())
         {
             STAmount liquidity;
-            uint64_t uQuality;
+            uint64_t uQuality = 0;
             auto const resultCode =
                 getPathLiquidity(currentPath, saMinDstAmount, liquidity, uQuality);
             if (resultCode != tesSUCCESS)
@@ -1158,6 +1158,7 @@ makePath(char const* string)
 
     while (true)
     {
+        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
         switch (*string++)
         {
             case 's':  // source
diff --git a/src/xrpld/app/paths/detail/BookStep.cpp b/src/xrpld/app/paths/detail/BookStep.cpp
index 4124fdfa30..7fe55c3cad 100644
--- a/src/xrpld/app/paths/detail/BookStep.cpp
+++ b/src/xrpld/app/paths/detail/BookStep.cpp
@@ -13,7 +13,7 @@
 #include <xrpl/tx/paths/OfferStream.h>
 #include <xrpl/tx/paths/detail/FlatSets.h>
 #include <xrpl/tx/paths/detail/Steps.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 #include <boost/container/flat_set.hpp>
 
@@ -63,7 +63,7 @@ protected:
 
     std::optional<Cache> cache_;
 
-public:
+private:
     BookStep(StrandContext const& ctx, Issue const& in, Issue const& out)
         : book_(in, out, ctx.domainID)
         , strandSrc_(ctx.strandSrc)
@@ -84,6 +84,7 @@ public:
                 ctx.j);
     }
 
+public:
     Book const&
     book() const
     {
@@ -223,6 +224,8 @@ private:
     // whichever is a better quality.
     std::optional<QualityFunction>
     tipOfferQualityF(ReadView const& view) const;
+
+    friend TDerived;
 };
 
 //------------------------------------------------------------------------------
@@ -240,7 +243,11 @@ class BookPaymentStep : public BookStep<TIn, TOut, BookPaymentStep<TIn, TOut>>
 public:
     explicit BookPaymentStep() = default;
 
-    using BookStep<TIn, TOut, BookPaymentStep<TIn, TOut>>::BookStep;
+    BookPaymentStep(StrandContext const& ctx, Issue const& in, Issue const& out)
+        : BookStep<TIn, TOut, BookPaymentStep<TIn, TOut>>(ctx, in, out)
+    {
+    }
+
     using BookStep<TIn, TOut, BookPaymentStep<TIn, TOut>>::qualityUpperBound;
     using typename BookStep<TIn, TOut, BookPaymentStep<TIn, TOut>>::OfferType;
 
diff --git a/src/xrpld/app/paths/detail/DirectStep.cpp b/src/xrpld/app/paths/detail/DirectStep.cpp
index 09ad2fcd67..3297a9368a 100644
--- a/src/xrpld/app/paths/detail/DirectStep.cpp
+++ b/src/xrpld/app/paths/detail/DirectStep.cpp
@@ -66,7 +66,7 @@ protected:
     std::pair<std::uint32_t, std::uint32_t>
     qualities(ReadView const& sb, DebtDirection srcDebtDir, StrandDirection strandDir) const;
 
-public:
+private:
     DirectStepI(
         StrandContext const& ctx,
         AccountID const& src,
@@ -81,6 +81,7 @@ public:
     {
     }
 
+public:
     AccountID const&
     src() const
     {
@@ -195,6 +196,8 @@ private:
         }
         return false;
     }
+
+    friend TDerived;
 };
 
 //------------------------------------------------------------------------------
@@ -209,7 +212,15 @@ private:
 class DirectIPaymentStep : public DirectStepI<DirectIPaymentStep>
 {
 public:
-    using DirectStepI<DirectIPaymentStep>::DirectStepI;
+    DirectIPaymentStep(
+        StrandContext const& ctx,
+        AccountID const& src,
+        AccountID const& dst,
+        Currency const& c)
+        : DirectStepI<DirectIPaymentStep>(ctx, src, dst, c)
+    {
+    }
+
     using DirectStepI<DirectIPaymentStep>::check;
 
     bool
@@ -252,7 +263,15 @@ public:
 class DirectIOfferCrossingStep : public DirectStepI<DirectIOfferCrossingStep>
 {
 public:
-    using DirectStepI<DirectIOfferCrossingStep>::DirectStepI;
+    DirectIOfferCrossingStep(
+        StrandContext const& ctx,
+        AccountID const& src,
+        AccountID const& dst,
+        Currency const& c)
+        : DirectStepI<DirectIOfferCrossingStep>(ctx, src, dst, c)
+    {
+    }
+
     using DirectStepI<DirectIOfferCrossingStep>::check;
 
     bool
diff --git a/src/xrpld/app/paths/detail/XRPEndpointStep.cpp b/src/xrpld/app/paths/detail/XRPEndpointStep.cpp
index ceb166d6ec..58390f498e 100644
--- a/src/xrpld/app/paths/detail/XRPEndpointStep.cpp
+++ b/src/xrpld/app/paths/detail/XRPEndpointStep.cpp
@@ -37,12 +37,12 @@ private:
         return EitherAmount(*cache_);
     }
 
-public:
     XRPEndpointStep(StrandContext const& ctx, AccountID const& acc)
         : acc_(acc), isLast_(ctx.isLast), j_(ctx.j)
     {
     }
 
+public:
     AccountID const&
     acc() const
     {
@@ -135,6 +135,8 @@ private:
         }
         return false;
     }
+
+    friend TDerived;
 };
 
 //------------------------------------------------------------------------------
@@ -149,7 +151,10 @@ private:
 class XRPEndpointPaymentStep : public XRPEndpointStep<XRPEndpointPaymentStep>
 {
 public:
-    using XRPEndpointStep<XRPEndpointPaymentStep>::XRPEndpointStep;
+    XRPEndpointPaymentStep(StrandContext const& ctx, AccountID const& acc)
+        : XRPEndpointStep<XRPEndpointPaymentStep>(ctx, acc)
+    {
+    }
 
     XRPAmount
     xrpLiquid(ReadView& sb) const
diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp
index 9425cd9159..eccc946e9f 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -74,8 +74,8 @@ makeLedgerDBs(
         {
             // Check if AccountTransactions has primary key
             std::string cid, name, type;
-            std::size_t notnull, dflt_value, pk;
-            soci::indicator ind;
+            std::size_t notnull = 0, dflt_value = 0, pk = 0;
+            soci::indicator ind = soci::i_null;
             soci::statement st =
                 (tx->getSession().prepare << ("PRAGMA table_info(AccountTransactions);"),
                  soci::into(cid),
@@ -136,7 +136,7 @@ deleteBeforeLedgerSeq(soci::session& session, TableType type, LedgerIndex ledger
 std::size_t
 getRows(soci::session& session, TableType type)
 {
-    std::size_t rows;
+    std::size_t rows = 0;
     session << "SELECT COUNT(*) AS rows "
                "FROM "
             << to_string(type) << ";",
@@ -148,7 +148,7 @@ getRows(soci::session& session, TableType type)
 RelationalDatabase::CountMinMax
 getRowsMinMax(soci::session& session, TableType type)
 {
-    RelationalDatabase::CountMinMax res;
+    RelationalDatabase::CountMinMax res{};
     session << "SELECT COUNT(*) AS rows, "
                "MIN(LedgerSeq) AS first, "
                "MAX(LedgerSeq) AS last "
@@ -543,7 +543,7 @@ getHashesByIndex(soci::session& session, LedgerIndex minSeq, LedgerIndex maxSeq,
     sql.append(std::to_string(maxSeq));
     sql.append(";");
 
-    std::uint64_t ls;
+    std::uint64_t ls = 0;
     std::string lh;
     // SOCI requires boost::optional (not std::optional) as the parameter.
     boost::optional<std::string> ph;
@@ -587,7 +587,7 @@ getTxHistory(soci::session& session, Application& app, LedgerIndex startIndex, i
         boost::optional<std::uint64_t> ledgerSeq;
         boost::optional<std::string> status;
         soci::blob sociRawTxnBlob(session);
-        soci::indicator rti;
+        soci::indicator rti = soci::i_null;
         Blob rawTxn;
 
         soci::statement st =
@@ -645,7 +645,7 @@ transactionsSQL(
     constexpr std::uint32_t NONBINARY_PAGE_LENGTH = 200;
     constexpr std::uint32_t BINARY_PAGE_LENGTH = 500;
 
-    std::uint32_t numberOfResults;
+    std::uint32_t numberOfResults = 0;
 
     if (count)
     {
@@ -755,7 +755,7 @@ getAccountTxs(
         boost::optional<std::uint64_t> ledgerSeq;
         boost::optional<std::string> status;
         soci::blob sociTxnBlob(session), sociTxnMetaBlob(session);
-        soci::indicator rti, tmi;
+        soci::indicator rti = soci::i_null, tmi = soci::i_null;
         Blob rawTxn, txnMeta;
 
         soci::statement st =
@@ -872,7 +872,7 @@ getAccountTxsB(
         boost::optional<std::uint64_t> ledgerSeq;
         boost::optional<std::string> status;
         soci::blob sociTxnBlob(session), sociTxnMetaBlob(session);
-        soci::indicator rti, tmi;
+        soci::indicator rti = soci::i_null, tmi = soci::i_null;
 
         soci::statement st =
             (session.prepare << sql,
@@ -953,7 +953,7 @@ accountTxPage(
 
     bool lookingForMarker = options.marker.has_value();
 
-    std::uint32_t numberOfResults;
+    std::uint32_t numberOfResults = 0;
 
     if (options.limit == 0 || options.limit == UINT32_MAX ||
         (options.limit > page_length && !options.bAdmin))
@@ -1041,7 +1041,7 @@ accountTxPage(
         boost::optional<std::string> status;
         soci::blob txnData(session);
         soci::blob txnMeta(session);
-        soci::indicator dataPresent, metaPresent;
+        soci::indicator dataPresent = soci::i_null, metaPresent = soci::i_null;
 
         soci::statement st =
             (session.prepare << sql,
@@ -1151,7 +1151,7 @@ getTransaction(
     Blob rawTxn, rawMeta;
     {
         soci::blob sociRawTxnBlob(session), sociRawMetaBlob(session);
-        soci::indicator txn, meta;
+        soci::indicator txn = soci::i_null, meta = soci::i_null;
 
         session << sql, soci::into(ledgerSeq), soci::into(status), soci::into(sociRawTxnBlob, txn),
             soci::into(sociRawMetaBlob, meta);
@@ -1164,7 +1164,7 @@ getTransaction(
         if (!got_data)
         {
             uint64_t count = 0;
-            soci::indicator rti;
+            soci::indicator rti = soci::i_null;
 
             session << "SELECT COUNT(DISTINCT LedgerSeq) FROM Transactions WHERE "
                        "LedgerSeq BETWEEN "
@@ -1230,16 +1230,16 @@ dbHasSpace(soci::session& session, Config const& config, beast::Journal j)
         }
 
         static auto const pageSize = [&] {
-            std::uint32_t ps;
+            std::uint32_t ps = 0;
             session << "PRAGMA page_size;", soci::into(ps);
             return ps;
         }();
         static auto const maxPages = [&] {
-            std::uint32_t mp;
+            std::uint32_t mp = 0;
             session << "PRAGMA max_page_count;", soci::into(mp);
             return mp;
         }();
-        std::uint32_t pageCount;
+        std::uint32_t pageCount = 0;
         session << "PRAGMA page_count;", soci::into(pageCount);
         std::uint32_t freePages = maxPages - pageCount;
         std::uint64_t freeSpace = safe_cast<std::uint64_t>(freePages) * pageSize;
diff --git a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
index 1b15fcf52e..4f5365ea01 100644
--- a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
+++ b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
@@ -400,7 +400,8 @@ SQLiteDatabase::oldestAccountTxPage(AccountTxPageOptions const& options)
     auto onTransaction =
         [&ret, &app = registry_.app()](
             std::uint32_t ledger_index, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
-            convertBlobsToTxResult(ret, ledger_index, status, rawTxn, rawMeta, app);
+            convertBlobsToTxResult(
+                ret, ledger_index, status, std::move(rawTxn), std::move(rawMeta), app);
         };
 
     if (existsTransaction())
@@ -428,7 +429,8 @@ SQLiteDatabase::newestAccountTxPage(AccountTxPageOptions const& options)
     auto onTransaction =
         [&ret, &app = registry_.app()](
             std::uint32_t ledger_index, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
-            convertBlobsToTxResult(ret, ledger_index, status, rawTxn, rawMeta, app);
+            convertBlobsToTxResult(
+                ret, ledger_index, status, std::move(rawTxn), std::move(rawMeta), app);
         };
 
     if (existsTransaction())
diff --git a/src/xrpld/app/rdb/detail/PeerFinder.cpp b/src/xrpld/app/rdb/detail/PeerFinder.cpp
index cfab6f764a..d619d4bb85 100644
--- a/src/xrpld/app/rdb/detail/PeerFinder.cpp
+++ b/src/xrpld/app/rdb/detail/PeerFinder.cpp
@@ -83,7 +83,7 @@ updatePeerFinderDB(soci::session& session, int currentSchemaVersion, beast::Jour
                    "    PeerFinder_BootstrapCache_Next "
                    "  ( address ); ";
 
-        std::size_t count;
+        std::size_t count = 0;
         session << "SELECT COUNT(*) FROM PeerFinder_BootstrapCache;", soci::into(count);
 
         std::vector<PeerFinder::Store::Entry> list;
@@ -91,7 +91,7 @@ updatePeerFinderDB(soci::session& session, int currentSchemaVersion, beast::Jour
         {
             list.reserve(count);
             std::string s;
-            int valence;
+            int valence = 0;
             soci::statement st =
                 (session.prepare << "SELECT "
                                     " address, "
@@ -187,7 +187,7 @@ void
 readPeerFinderDB(soci::session& session, std::function<void(std::string const&, int)> const& func)
 {
     std::string s;
-    int valence;
+    int valence = 0;
     soci::statement st =
         (session.prepare << "SELECT "
                             " address, "
diff --git a/src/xrpld/core/detail/Config.cpp b/src/xrpld/core/detail/Config.cpp
index d1937fa83e..cee1ce5ed1 100644
--- a/src/xrpld/core/detail/Config.cpp
+++ b/src/xrpld/core/detail/Config.cpp
@@ -51,7 +51,7 @@ namespace detail {
 [[nodiscard]] std::uint64_t
 getMemorySize()
 {
-    if (struct sysinfo si; sysinfo(&si) == 0)
+    if (struct sysinfo si{}; sysinfo(&si) == 0)
         return static_cast<std::uint64_t>(si.totalram) * si.mem_unit;
 
     return 0;
@@ -386,7 +386,6 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand
     if (RUN_STANDALONE)
         LEDGER_HISTORY = 0;
 
-    std::string ledgerTxDbType;
     Section ledgerTxTablesSection = section("ledger_tx_tables");
     get_if_exists(ledgerTxTablesSection, "use_tx_tables", USE_TX_TABLES);
 
@@ -1051,13 +1050,13 @@ setup_FeeVote(Section const& section)
 {
     FeeSetup setup;
     {
-        std::uint64_t temp;
+        std::uint64_t temp = 0;
         if (set(temp, "reference_fee", section) &&
             temp <= std::numeric_limits<XRPAmount::value_type>::max())
             setup.reference_fee = temp;
     }
     {
-        std::uint32_t temp;
+        std::uint32_t temp = 0;
         if (set(temp, "account_reserve", section))
             setup.account_reserve = temp;
         if (set(temp, "owner_reserve", section))
diff --git a/src/xrpld/overlay/detail/ConnectAttempt.cpp b/src/xrpld/overlay/detail/ConnectAttempt.cpp
index c9361a2a5d..54765c68db 100644
--- a/src/xrpld/overlay/detail/ConnectAttempt.cpp
+++ b/src/xrpld/overlay/detail/ConnectAttempt.cpp
@@ -160,7 +160,7 @@ ConnectAttempt::close()
     cancelTimer();
 
     error_code ec;
-    socket_.close(ec);
+    socket_.close(ec);  // NOLINT(bugprone-unused-return-value)
 }
 
 void
@@ -252,7 +252,7 @@ ConnectAttempt::cancelTimer()
         timer_.cancel();
         stepTimer_.cancel();
     }
-    catch (boost::system::system_error const&)
+    catch (boost::system::system_error const&)  // NOLINT(bugprone-empty-catch)
     {
         // ignored
     }
diff --git a/src/xrpld/overlay/detail/Handshake.cpp b/src/xrpld/overlay/detail/Handshake.cpp
index c463a31257..715afc90e8 100644
--- a/src/xrpld/overlay/detail/Handshake.cpp
+++ b/src/xrpld/overlay/detail/Handshake.cpp
@@ -211,7 +211,7 @@ verifyHandshake(
 
     if (auto const iter = headers.find("Network-ID"); iter != headers.end())
     {
-        std::uint32_t nid;
+        std::uint32_t nid = 0;
 
         if (!beast::lexicalCastChecked(nid, iter->value()))
             throw std::runtime_error("Invalid peer network identifier");
@@ -223,7 +223,7 @@ verifyHandshake(
     if (auto const iter = headers.find("Network-Time"); iter != headers.end())
     {
         auto const netTime = [str = iter->value()]() -> TimeKeeper::time_point {
-            TimeKeeper::duration::rep val;
+            TimeKeeper::duration::rep val = 0;
 
             if (beast::lexicalCastChecked(val, str))
                 return TimeKeeper::time_point{TimeKeeper::duration{val}};
diff --git a/src/xrpld/overlay/detail/Message.cpp b/src/xrpld/overlay/detail/Message.cpp
index 510bc24fe2..672ce995ca 100644
--- a/src/xrpld/overlay/detail/Message.cpp
+++ b/src/xrpld/overlay/detail/Message.cpp
@@ -58,6 +58,8 @@ Message::compress()
     bool const compressible = [&] {
         if (messageBytes <= 70)
             return false;
+
+        // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
         switch (type)
         {
             case protocol::mtMANIFESTS:
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index 55f45e727e..d9680d7748 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -635,7 +635,7 @@ OverlayImpl::onManifests(
 
     if (!relay.list().empty())
         for_each([m2 = std::make_shared<Message>(relay, protocol::mtMANIFESTS)](
-                     std::shared_ptr<PeerImp>&& p) { p->send(m2); });
+                     std::shared_ptr<PeerImp> const& p) { p->send(m2); });
 }
 
 void
@@ -671,12 +671,12 @@ OverlayImpl::getOverlayInfo()
 {
     using namespace std::chrono;
     Json::Value jv;
-    auto& av = jv["active"] = Json::Value(Json::arrayValue);
+    auto& av = jv[jss::active] = Json::Value(Json::arrayValue);
 
-    for_each([&](std::shared_ptr<PeerImp>&& sp) {
+    for_each([&](std::shared_ptr<PeerImp> const& sp) {
         auto& pv = av.append(Json::Value(Json::objectValue));
         pv[jss::public_key] = base64_encode(sp->getNodePublic().data(), sp->getNodePublic().size());
-        pv[jss::type] = sp->slot()->inbound() ? "in" : "out";
+        pv[jss::type] = sp->slot()->inbound() ? jss::in : jss::out;
         pv[jss::uptime] = static_cast<std::uint32_t>(duration_cast<seconds>(sp->uptime()).count());
         if (sp->crawl())
         {
@@ -688,7 +688,7 @@ OverlayImpl::getOverlayInfo()
             }
             else
             {
-                pv[jss::port] = std::to_string(sp->getRemoteAddress().port());
+                pv[jss::port] = sp->getRemoteAddress().port();
             }
         }
 
@@ -699,7 +699,7 @@ OverlayImpl::getOverlayInfo()
                 pv[jss::version] = std::string{version};
         }
 
-        std::uint32_t minSeq, maxSeq;
+        std::uint32_t minSeq = 0, maxSeq = 0;
         sp->ledgerRange(minSeq, maxSeq);
         if (minSeq != 0 || maxSeq != 0)
             pv[jss::complete_ledgers] = std::to_string(minSeq) + "-" + std::to_string(maxSeq);
@@ -825,7 +825,7 @@ OverlayImpl::processValidatorList(http_request_type const& req, Handoff& handoff
     // return the most recent validator list for that key.
     constexpr std::string_view prefix("/vl/");
 
-    if (!req.target().starts_with(prefix.data()) || !setup_.vlEnabled)
+    if (!req.target().starts_with(prefix) || !setup_.vlEnabled)
         return false;
 
     std::uint32_t version = 1;
@@ -907,9 +907,9 @@ OverlayImpl::processHealth(http_request_type const& req, Handoff& handoff)
     std::string server_state = info[jss::server_state].asString();
     auto load_factor = info[jss::load_factor_server].asDouble() / info[jss::load_base].asDouble();
 
-    enum { healthy, warning, critical };
-    int health = healthy;
-    auto set_health = [&health](int state) {
+    enum class HealthState { healthy, warning, critical };
+    auto health = HealthState::healthy;
+    auto set_health = [&health](HealthState state) {
         if (health < state)
             health = state;
     };
@@ -919,24 +919,24 @@ OverlayImpl::processHealth(http_request_type const& req, Handoff& handoff)
     {
         msg.body()[jss::info][jss::validated_ledger] = last_validated_ledger_age;
         if (last_validated_ledger_age < 20)
-            set_health(warning);
+            set_health(HealthState::warning);
         else
-            set_health(critical);
+            set_health(HealthState::critical);
     }
 
     if (amendment_blocked)
     {
         msg.body()[jss::info][jss::amendment_blocked] = true;
-        set_health(critical);
+        set_health(HealthState::critical);
     }
 
     if (number_peers <= 7)
     {
         msg.body()[jss::info][jss::peers] = number_peers;
         if (number_peers != 0)
-            set_health(warning);
+            set_health(HealthState::warning);
         else
-            set_health(critical);
+            set_health(HealthState::critical);
     }
 
     if (!(server_state == "full" || server_state == "validating" || server_state == "proposing"))
@@ -944,30 +944,30 @@ OverlayImpl::processHealth(http_request_type const& req, Handoff& handoff)
         msg.body()[jss::info][jss::server_state] = server_state;
         if (server_state == "syncing" || server_state == "tracking" || server_state == "connected")
         {
-            set_health(warning);
+            set_health(HealthState::warning);
         }
         else
-            set_health(critical);
+            set_health(HealthState::critical);
     }
 
     if (load_factor > 100)
     {
         msg.body()[jss::info][jss::load_factor] = load_factor;
         if (load_factor < 1000)
-            set_health(warning);
+            set_health(HealthState::warning);
         else
-            set_health(critical);
+            set_health(HealthState::critical);
     }
 
     switch (health)
     {
-        case healthy:
+        case HealthState::healthy:
             msg.result(boost::beast::http::status::ok);
             break;
-        case warning:
+        case HealthState::warning:
             msg.result(boost::beast::http::status::service_unavailable);
             break;
-        case critical:
+        case HealthState::critical:
             msg.result(boost::beast::http::status::internal_server_error);
             break;
     }
@@ -991,7 +991,7 @@ OverlayImpl::getActivePeers() const
     Overlay::PeerSequence ret;
     ret.reserve(size());
 
-    for_each([&ret](std::shared_ptr<PeerImp>&& sp) { ret.emplace_back(std::move(sp)); });
+    for_each([&ret](std::shared_ptr<PeerImp> const& sp) { ret.emplace_back(std::move(sp)); });
 
     return ret;
 }
@@ -1034,7 +1034,7 @@ OverlayImpl::getActivePeers(
 void
 OverlayImpl::checkTracking(std::uint32_t index)
 {
-    for_each([index](std::shared_ptr<PeerImp>&& sp) { sp->checkTracking(index); });
+    for_each([index](std::shared_ptr<PeerImp> const& sp) { sp->checkTracking(index); });
 }
 
 std::shared_ptr<Peer>
@@ -1070,7 +1070,7 @@ void
 OverlayImpl::broadcast(protocol::TMProposeSet& m)
 {
     auto const sm = std::make_shared<Message>(m, protocol::mtPROPOSE_LEDGER);
-    for_each([&](std::shared_ptr<PeerImp>&& p) { p->send(sm); });
+    for_each([&](std::shared_ptr<PeerImp> const& p) { p->send(sm); });
 }
 
 std::set<Peer::id_t>
@@ -1079,7 +1079,7 @@ OverlayImpl::relay(protocol::TMProposeSet& m, uint256 const& uid, PublicKey cons
     if (auto const toSkip = app_.getHashRouter().shouldRelay(uid))
     {
         auto const sm = std::make_shared<Message>(m, protocol::mtPROPOSE_LEDGER, validator);
-        for_each([&](std::shared_ptr<PeerImp>&& p) {
+        for_each([&](std::shared_ptr<PeerImp> const& p) {
             if (toSkip->find(p->id()) == toSkip->end())
                 p->send(sm);
         });
@@ -1092,7 +1092,7 @@ void
 OverlayImpl::broadcast(protocol::TMValidation& m)
 {
     auto const sm = std::make_shared<Message>(m, protocol::mtVALIDATION);
-    for_each([sm](std::shared_ptr<PeerImp>&& p) { p->send(sm); });
+    for_each([sm](std::shared_ptr<PeerImp> const& p) { p->send(sm); });
 }
 
 std::set<Peer::id_t>
@@ -1101,7 +1101,7 @@ OverlayImpl::relay(protocol::TMValidation& m, uint256 const& uid, PublicKey cons
     if (auto const toSkip = app_.getHashRouter().shouldRelay(uid))
     {
         auto const sm = std::make_shared<Message>(m, protocol::mtVALIDATION, validator);
-        for_each([&](std::shared_ptr<PeerImp>&& p) {
+        for_each([&](std::shared_ptr<PeerImp> const& p) {
             if (toSkip->find(p->id()) == toSkip->end())
                 p->send(sm);
         });
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 139e765266..2b4cc25c05 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -392,7 +392,7 @@ PeerImp::json()
     ret[jss::uptime] =
         static_cast<Json::UInt>(std::chrono::duration_cast<std::chrono::seconds>(uptime()).count());
 
-    std::uint32_t minSeq, maxSeq;
+    std::uint32_t minSeq = 0, maxSeq = 0;
     ledgerRange(minSeq, maxSeq);
 
     if ((minSeq != 0) || (maxSeq != 0))
@@ -635,7 +635,7 @@ PeerImp::close()
     cancelTimer();
 
     error_code ec;
-    socket_.close(ec);
+    socket_.close(ec);  // NOLINT(bugprone-unused-return-value)
 
     overlay_.incPeerDisconnect();
 
@@ -921,7 +921,7 @@ PeerImp::onReadMessage(error_code ec, std::size_t bytes_transferred)
 
     while (read_buffer_.size() > 0)
     {
-        std::size_t bytes_consumed;
+        std::size_t bytes_consumed = 0;
 
         using namespace std::chrono_literals;
         std::tie(bytes_consumed, ec) = perf::measureDurationAndLog(
@@ -1315,7 +1315,7 @@ PeerImp::handleTransaction(
         }
         // LCOV_EXCL_STOP
 
-        HashRouterFlags flags;
+        HashRouterFlags flags = HashRouterFlags::UNDEFINED;
         constexpr std::chrono::seconds tx_interval = 10s;
 
         if (!app_.getHashRouter().shouldProcess(txID, id_, flags, tx_interval))
@@ -1856,7 +1856,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         checkTracking(m->ledgerseq(), app_.getLedgerMaster().getValidLedgerIndex());
     }
 
-    app_.getOPs().pubPeerStatus([=, this]() -> Json::Value {
+    app_.getOPs().pubPeerStatus([m, this]() -> Json::Value {
         Json::Value j = Json::objectValue;
 
         if (m->has_newstatus())
@@ -1933,7 +1933,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
 void
 PeerImp::checkTracking(std::uint32_t validationSeq)
 {
-    std::uint32_t serverSeq;
+    std::uint32_t serverSeq = 0;
     {
         // Extract the sequence number of the highest
         // ledger this peer has
@@ -2879,7 +2879,7 @@ PeerImp::checkPropose(
         return;
     }
 
-    bool relay;
+    bool relay = false;
 
     if (isTrusted)
         relay = app_.getOPs().processTrustedProposal(peerPos);
diff --git a/src/xrpld/overlay/detail/ProtocolVersion.cpp b/src/xrpld/overlay/detail/ProtocolVersion.cpp
index 3163ba55e0..29bff996a9 100644
--- a/src/xrpld/overlay/detail/ProtocolVersion.cpp
+++ b/src/xrpld/overlay/detail/ProtocolVersion.cpp
@@ -81,8 +81,8 @@ parseProtocolVersions(boost::beast::string_view const& value)
 
         if (boost::regex_match(s, m, re))
         {
-            std::uint16_t major;
-            std::uint16_t minor;
+            std::uint16_t major = 0;
+            std::uint16_t minor = 0;
             if (!beast::lexicalCastChecked(major, std::string(m[1])))
                 continue;
 
diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp
index d1267953e4..eb271ac91a 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.cpp
+++ b/src/xrpld/perflog/detail/PerfLogImp.cpp
@@ -472,7 +472,7 @@ setup_PerfLog(Section const& section, boost::filesystem::path const& configDir)
         }
     }
 
-    std::uint64_t logInterval;
+    std::uint64_t logInterval = 0;
     if (get_if_exists(section, "log_interval", logInterval))
         setup.logInterval = std::chrono::seconds(logInterval);
     return setup;
diff --git a/src/xrpld/rpc/ServerHandler.h b/src/xrpld/rpc/ServerHandler.h
index af7ec4bf1c..74f59756b0 100644
--- a/src/xrpld/rpc/ServerHandler.h
+++ b/src/xrpld/rpc/ServerHandler.h
@@ -182,7 +182,7 @@ private:
         Port const& port,
         std::string const& request,
         beast::IP::Endpoint const& remoteIPAddress,
-        Output&&,
+        Output const&,
         std::shared_ptr<JobQueue::Coro> coro,
         std::string_view forwardedFor,
         std::string_view user);
@@ -192,7 +192,7 @@ private:
 };
 
 ServerHandler::Setup
-setup_ServerHandler(Config const& c, std::ostream&& log);
+setup_ServerHandler(Config const& c, std::ostream& log);
 
 std::unique_ptr<ServerHandler>
 make_ServerHandler(
diff --git a/src/xrpld/rpc/detail/DeliveredAmount.cpp b/src/xrpld/rpc/detail/DeliveredAmount.cpp
index 7cb90eaa98..3e89edc1f9 100644
--- a/src/xrpld/rpc/detail/DeliveredAmount.cpp
+++ b/src/xrpld/rpc/detail/DeliveredAmount.cpp
@@ -34,7 +34,7 @@ getDeliveredAmount(
     if (auto const& deliveredAmount = transactionMeta.getDeliveredAmount();
         deliveredAmount.has_value())
     {
-        return *deliveredAmount;
+        return deliveredAmount;
     }
 
     if (serializedTx->isFieldPresent(sfAmount))
diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp
index 7b65daa839..43ca166f9f 100644
--- a/src/xrpld/rpc/detail/RPCCall.cpp
+++ b/src/xrpld/rpc/detail/RPCCall.cpp
@@ -1476,10 +1476,10 @@ rpcClient(
             xrpl::ServerHandler::Setup setup;
             try
             {
-                setup = setup_ServerHandler(
-                    config, beast::logstream{logs.journal("HTTPClient").warn()});
+                beast::logstream rpcCallLog{logs.journal("HTTPClient").warn()};
+                setup = setup_ServerHandler(config, rpcCallLog);
             }
-            catch (std::exception const&)
+            catch (std::exception const&)  // NOLINT(bugprone-empty-catch)
             {
                 // ignore any exceptions, so the command
                 // line client works without a config file
diff --git a/src/xrpld/rpc/detail/RPCHelpers.cpp b/src/xrpld/rpc/detail/RPCHelpers.cpp
index 14e1108955..385bc7f4af 100644
--- a/src/xrpld/rpc/detail/RPCHelpers.cpp
+++ b/src/xrpld/rpc/detail/RPCHelpers.cpp
@@ -10,7 +10,7 @@
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/rdb/RelationalDatabase.h>
 #include <xrpl/resource/Fees.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/predicate.hpp>
diff --git a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
index ddf78425bd..acf9ecd23a 100644
--- a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
+++ b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
@@ -55,7 +55,7 @@ ledgerFromIndex(
     if (index == "closed")
         return getLedger(ledger, LedgerShortcut::Closed, context);
 
-    std::uint32_t iVal;
+    std::uint32_t iVal = 0;
     if (!beast::lexicalCastChecked(iVal, index))
         return {rpcINVALID_PARAMS, expected_field_message(fieldName, "string or number")};
 
diff --git a/src/xrpld/rpc/detail/RPCSub.cpp b/src/xrpld/rpc/detail/RPCSub.cpp
index a0e29f68e2..49a78d0755 100644
--- a/src/xrpld/rpc/detail/RPCSub.cpp
+++ b/src/xrpld/rpc/detail/RPCSub.cpp
@@ -26,10 +26,8 @@ public:
         , m_io_context(io_context)
         , m_jobQueue(jobQueue)
         , mUrl(strUrl)
-        , mSSL(false)
         , mUsername(strUsername)
         , mPassword(strPassword)
-        , mSending(false)
         , j_(logs.journal("RPCSub"))
         , logs_(logs)
     {
@@ -97,7 +95,7 @@ private:
     sendThread()
     {
         Json::Value jvEvent;
-        bool bSend;
+        bool bSend = false;
 
         do
         {
@@ -159,14 +157,14 @@ private:
     std::string mUrl;
     std::string mIp;
     std::uint16_t mPort;
-    bool mSSL;
+    bool mSSL{false};
     std::string mUsername;
     std::string mPassword;
     std::string mPath;
 
     int mSeq;  // Next id to allocate.
 
-    bool mSending;  // Sending thread is active.
+    bool mSending{false};  // Sending thread is active.
 
     std::deque<std::pair<int, Json::Value>> mDeque;
 
diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp
index 5be41a5a23..39f0be6722 100644
--- a/src/xrpld/rpc/detail/ServerHandler.cpp
+++ b/src/xrpld/rpc/detail/ServerHandler.cpp
@@ -561,7 +561,7 @@ ServerHandler::processRequest(
     Port const& port,
     std::string const& request,
     beast::IP::Endpoint const& remoteIPAddress,
-    Output&& output,
+    Output const& output,
     std::shared_ptr<JobQueue::Coro> coro,
     std::string_view forwardedFor,
     std::string_view user)
@@ -981,10 +981,9 @@ ServerHandler::statusResponse(http_request_type const& request) const
     if (app_.serverOkay(reason))
     {
         msg.result(boost::beast::http::status::ok);
-        msg.body() = "<!DOCTYPE html><html><head><title>" + systemName() +
-            " Test page for rippled</title></head><body><h1>" + systemName() +
-            " Test</h1><p>This page shows rippled http(s) "
-            "connectivity is working.</p></body></html>";
+        msg.body() = "<!DOCTYPE html><html><head><title>Test page for " + systemName() +
+            "</title></head><body><h1>Test</h1><p>This page shows " + systemName() +
+            " http(s) connectivity is working.</p></body></html>";
     }
     else
     {
@@ -1176,7 +1175,7 @@ setup_Overlay(ServerHandler::Setup& setup)
 }
 
 ServerHandler::Setup
-setup_ServerHandler(Config const& config, std::ostream&& log)
+setup_ServerHandler(Config const& config, std::ostream& log)
 {
     ServerHandler::Setup setup;
     setup.ports = parse_Ports(config, log);
diff --git a/src/xrpld/rpc/handlers/AMMInfo.cpp b/src/xrpld/rpc/handlers/AMMInfo.cpp
index 3b843c9410..e174a49f87 100644
--- a/src/xrpld/rpc/handlers/AMMInfo.cpp
+++ b/src/xrpld/rpc/handlers/AMMInfo.cpp
@@ -2,11 +2,12 @@
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
 
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Issue.h>
-#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/dex/AMMUtils.h>
 
 #include <grpcpp/support/status.h>
 
@@ -175,7 +176,7 @@ doAMMInfo(RPC::JsonContext& context)
         "xrpl::doAMMInfo : auction slot is set");
     if (amm->isFieldPresent(sfAuctionSlot))
     {
-        auto const& auctionSlot = static_cast<STObject const&>(amm->peekAtField(sfAuctionSlot));
+        auto const& auctionSlot = safe_downcast<STObject const&>(amm->peekAtField(sfAuctionSlot));
         if (auctionSlot.isFieldPresent(sfAccount))
         {
             Json::Value auction;
diff --git a/src/xrpld/rpc/handlers/AccountChannels.cpp b/src/xrpld/rpc/handlers/AccountChannels.cpp
index 062a2b69a0..d2c3d4546d 100644
--- a/src/xrpld/rpc/handlers/AccountChannels.cpp
+++ b/src/xrpld/rpc/handlers/AccountChannels.cpp
@@ -81,7 +81,7 @@ doAccountChannels(RPC::JsonContext& context)
     if (!strDst.empty() && !raDstAccount)
         return rpcError(rpcACT_MALFORMED);
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::accountChannels, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/AccountLines.cpp b/src/xrpld/rpc/handlers/AccountLines.cpp
index bb61e6f6c0..d065180c64 100644
--- a/src/xrpld/rpc/handlers/AccountLines.cpp
+++ b/src/xrpld/rpc/handlers/AccountLines.cpp
@@ -98,7 +98,7 @@ doAccountLines(RPC::JsonContext& context)
         return result;
     }
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::accountLines, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/AccountObjects.cpp b/src/xrpld/rpc/handlers/AccountObjects.cpp
index 9dcdf7bdf6..f5f48d8050 100644
--- a/src/xrpld/rpc/handlers/AccountObjects.cpp
+++ b/src/xrpld/rpc/handlers/AccountObjects.cpp
@@ -11,7 +11,7 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/resource/Fees.h>
-#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
+#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
 
 #include <string>
 
@@ -53,7 +53,7 @@ doAccountNFTs(RPC::JsonContext& context)
     if (!ledger->exists(keylet::account(accountID)))
         return rpcError(rpcACT_NOT_FOUND);
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::accountNFTokens, context))
         return *err;
 
@@ -435,7 +435,7 @@ doAccountObjects(RPC::JsonContext& context)
         }
     }
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::accountObjects, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/AccountOffers.cpp b/src/xrpld/rpc/handlers/AccountOffers.cpp
index 130decad04..842cac71eb 100644
--- a/src/xrpld/rpc/handlers/AccountOffers.cpp
+++ b/src/xrpld/rpc/handlers/AccountOffers.cpp
@@ -63,7 +63,7 @@ doAccountOffers(RPC::JsonContext& context)
     if (!ledger->exists(keylet::account(accountID)))
         return rpcError(rpcACT_NOT_FOUND);
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::accountOffers, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/AccountTx.cpp b/src/xrpld/rpc/handlers/AccountTx.cpp
index a6dcbb7b9d..6c227b16b9 100644
--- a/src/xrpld/rpc/handlers/AccountTx.cpp
+++ b/src/xrpld/rpc/handlers/AccountTx.cpp
@@ -108,8 +108,8 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
 std::variant<LedgerRange, RPC::Status>
 getLedgerRange(RPC::Context& context, std::optional<LedgerSpecifier> const& ledgerSpecifier)
 {
-    std::uint32_t uValidatedMin;
-    std::uint32_t uValidatedMax;
+    std::uint32_t uValidatedMin = 0;
+    std::uint32_t uValidatedMax = 0;
     bool bValidated = context.ledgerMaster.getValidatedRange(uValidatedMin, uValidatedMax);
 
     if (!bValidated)
diff --git a/src/xrpld/rpc/handlers/BookOffers.cpp b/src/xrpld/rpc/handlers/BookOffers.cpp
index 070d7988de..593f3e1fa2 100644
--- a/src/xrpld/rpc/handlers/BookOffers.cpp
+++ b/src/xrpld/rpc/handlers/BookOffers.cpp
@@ -167,7 +167,7 @@ doBookOffers(RPC::JsonContext& context)
         return RPC::make_error(rpcBAD_MARKET);
     }
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::bookOffers, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/Connect.cpp b/src/xrpld/rpc/handlers/Connect.cpp
index c76ebed546..415adbd2fd 100644
--- a/src/xrpld/rpc/handlers/Connect.cpp
+++ b/src/xrpld/rpc/handlers/Connect.cpp
@@ -33,7 +33,7 @@ doConnect(RPC::JsonContext& context)
         return rpcError(rpcINVALID_PARAMS);
     }
 
-    int iPort;
+    int iPort = 0;
 
     if (context.params.isMember(jss::port))
         iPort = context.params[jss::port].asInt();
diff --git a/src/xrpld/rpc/handlers/GatewayBalances.cpp b/src/xrpld/rpc/handlers/GatewayBalances.cpp
index e5e95d6835..a2176ab388 100644
--- a/src/xrpld/rpc/handlers/GatewayBalances.cpp
+++ b/src/xrpld/rpc/handlers/GatewayBalances.cpp
@@ -131,6 +131,10 @@ doGatewayBalances(RPC::JsonContext& context)
             if (sle->getType() == ltESCROW)
             {
                 auto const& escrow = sle->getFieldAmount(sfAmount);
+                // Gateway Balance should not include MPTs
+                if (escrow.holds<MPTIssue>())
+                    return;
+
                 auto& bal = locked[escrow.getCurrency()];
                 if (bal == beast::zero)
                 {
diff --git a/src/xrpld/rpc/handlers/GetAggregatePrice.cpp b/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
index eaeff767cd..4fc8e360fc 100644
--- a/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
+++ b/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
@@ -3,6 +3,7 @@
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
 
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/ErrorCodes.h>
@@ -25,7 +26,7 @@ static void
 iteratePriceData(
     RPC::JsonContext& context,
     std::shared_ptr<SLE const> const& sle,
-    std::function<bool(STObject const&)>&& f)
+    std::function<bool(STObject const&)> const& f)
 {
     using Meta = std::shared_ptr<STObject const>;
     constexpr std::uint8_t maxHistory = 3;
@@ -87,8 +88,8 @@ iteratePriceData(
             if (isNew && history == 1)
                 return;
 
-            oracle = isNew ? &static_cast<STObject const&>(node.peekAtField(sfNewFields))
-                           : &static_cast<STObject const&>(node.peekAtField(sfFinalFields));
+            oracle = isNew ? &safe_downcast<STObject const&>(node.peekAtField(sfNewFields))
+                           : &safe_downcast<STObject const&>(node.peekAtField(sfFinalFields));
             break;
         }
     }
@@ -148,7 +149,7 @@ doGetAggregatePrice(RPC::JsonContext& context)
     // support positive int, uint, and a number represented as a string
     auto validUInt = [](Json::Value const& params, Json::StaticString const& field) {
         auto const& jv = params[field];
-        std::uint32_t v;
+        std::uint32_t v = 0;
         return jv.isUInt() || (jv.isInt() && jv.asInt() >= 0) ||
             (jv.isString() && beast::lexicalCastChecked(v, jv.asString()));
     };
diff --git a/src/xrpld/rpc/handlers/NFTOffers.cpp b/src/xrpld/rpc/handlers/NFTOffers.cpp
index 51f75bfe4c..3af7c28f9e 100644
--- a/src/xrpld/rpc/handlers/NFTOffers.cpp
+++ b/src/xrpld/rpc/handlers/NFTOffers.cpp
@@ -44,7 +44,7 @@ appendNftOfferJson(
 static Json::Value
 enumerateNFTOffers(RPC::JsonContext& context, uint256 const& nftId, Keylet const& directory)
 {
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::nftOffers, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/NoRippleCheck.cpp
index e17a437efc..9985591303 100644
--- a/src/xrpld/rpc/handlers/NoRippleCheck.cpp
+++ b/src/xrpld/rpc/handlers/NoRippleCheck.cpp
@@ -60,7 +60,7 @@ doNoRippleCheck(RPC::JsonContext& context)
             return RPC::invalid_field_error("role");
     }
 
-    unsigned int limit;
+    unsigned int limit = 0;
     if (auto err = readLimitField(limit, RPC::Tuning::noRippleCheck, context))
         return *err;
 
diff --git a/src/xrpld/rpc/handlers/ServerDefinitions.cpp b/src/xrpld/rpc/handlers/ServerDefinitions.cpp
index ea1912f66e..e153065ea9 100644
--- a/src/xrpld/rpc/handlers/ServerDefinitions.cpp
+++ b/src/xrpld/rpc/handlers/ServerDefinitions.cpp
@@ -6,12 +6,15 @@
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/jss.h>
 
 #include <boost/algorithm/string.hpp>
 
+#include <set>
+#include <string_view>
 #include <unordered_map>
 
 namespace xrpl {
@@ -47,13 +50,14 @@ public:
 std::string
 ServerDefinitions::translate(std::string const& inp)
 {
-    auto replace = [&](char const* oldStr, char const* newStr) -> std::string {
+    auto replace = [&](std::string_view oldStr, std::string_view newStr) -> std::string {
         std::string out = inp;
         boost::replace_all(out, oldStr, newStr);
         return out;
     };
 
-    auto contains = [&](char const* s) -> bool { return inp.find(s) != std::string::npos; };
+    // TODO: use string::contains with C++23
+    auto contains = [&](std::string_view s) -> bool { return inp.find(s) != std::string::npos; };
 
     if (contains("UINT"))
     {
@@ -64,7 +68,7 @@ ServerDefinitions::translate(std::string const& inp)
             return replace("UINT", "UInt");
     }
 
-    std::unordered_map<std::string, std::string> replacements{
+    static std::unordered_map<std::string_view, std::string_view> const replacements{
         {"OBJECT", "STObject"},
         {"ARRAY", "STArray"},
         {"ACCOUNT", "AccountID"},
@@ -77,7 +81,7 @@ ServerDefinitions::translate(std::string const& inp)
 
     if (auto const& it = replacements.find(inp); it != replacements.end())
     {
-        return it->second;
+        return std::string(it->second);
     }
 
     std::string out;
@@ -211,36 +215,35 @@ ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
         defs_[jss::FIELDS][i++] = a;
     }
 
-    for (auto const& [code, f] : xrpl::SField::getKnownCodeToField())
+    for (auto const& [code, field] : xrpl::SField::getKnownCodeToField())
     {
-        if (f->fieldName == "")
+        if (field->fieldName == "")
             continue;
 
         Json::Value innerObj = Json::objectValue;
 
-        uint32_t type = f->fieldType;
+        uint32_t type = field->fieldType;
 
-        innerObj[jss::nth] = f->fieldValue;
+        innerObj[jss::nth] = field->fieldValue;
 
-        // whether the field is variable-length encoded
-        // this means that the length is included before the content
+        // whether the field is variable-length encoded this means that the length is included
+        // before the content
         innerObj[jss::isVLEncoded] =
-            (type == 7U /* Blob       */ || type == 8U /* AccountID  */ ||
-             type == 19U /* Vector256  */);
+            (type == 7U /* Blob */ || type == 8U /* AccountID */ || type == 19U /* Vector256 */);
 
         // whether the field is included in serialization
         innerObj[jss::isSerialized] =
-            (type < 10000 && f->fieldName != "hash" &&
-             f->fieldName != "index"); /* hash, index, TRANSACTION,
-                                         LEDGER_ENTRY, VALIDATION, METADATA */
+            (type < 10000 && field->fieldName != "hash" &&
+             field->fieldName !=
+                 "index");  // hash, index, TRANSACTION, LEDGER_ENTRY, VALIDATION, METADATA
 
         // whether the field is included in serialization when signing
-        innerObj[jss::isSigningField] = f->shouldInclude(false);
+        innerObj[jss::isSigningField] = field->shouldInclude(false);
 
         innerObj[jss::type] = typeMap[type];
 
         Json::Value innerArray = Json::arrayValue;
-        innerArray[0U] = f->fieldName;
+        innerArray[0U] = field->fieldName;
         innerArray[1U] = innerObj;
 
         defs_[jss::FIELDS][i++] = innerArray;
@@ -262,6 +265,92 @@ ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
         defs_[jss::TRANSACTION_TYPES][f.getName()] = f.getType();
     }
 
+    // populate TxFormats
+    defs_[jss::TRANSACTION_FORMATS] = Json::objectValue;
+
+    defs_[jss::TRANSACTION_FORMATS][jss::common] = Json::arrayValue;
+    auto txCommonFields = std::set<std::string>();
+    for (auto const& element : TxFormats::getCommonFields())
+    {
+        Json::Value elementObj = Json::objectValue;
+        elementObj[jss::name] = element.sField().getName();
+        elementObj[jss::optionality] = element.style();
+        defs_[jss::TRANSACTION_FORMATS][jss::common].append(elementObj);
+        txCommonFields.insert(element.sField().getName());
+    }
+
+    for (auto const& format : TxFormats::getInstance())
+    {
+        auto const& soTemplate = format.getSOTemplate();
+        Json::Value templateArray = Json::arrayValue;
+        for (auto const& element : soTemplate)
+        {
+            if (txCommonFields.contains(element.sField().getName()))
+                continue;  // skip common fields, already added
+            Json::Value elementObj = Json::objectValue;
+            elementObj[jss::name] = element.sField().getName();
+            elementObj[jss::optionality] = element.style();
+            templateArray.append(elementObj);
+        }
+        defs_[jss::TRANSACTION_FORMATS][format.getName()] = templateArray;
+    }
+
+    // populate LedgerFormats
+    defs_[jss::LEDGER_ENTRY_FORMATS] = Json::objectValue;
+    defs_[jss::LEDGER_ENTRY_FORMATS][jss::common] = Json::arrayValue;
+    auto ledgerCommonFields = std::set<std::string>();
+    for (auto const& element : LedgerFormats::getCommonFields())
+    {
+        Json::Value elementObj = Json::objectValue;
+        elementObj[jss::name] = element.sField().getName();
+        elementObj[jss::optionality] = element.style();
+        defs_[jss::LEDGER_ENTRY_FORMATS][jss::common].append(elementObj);
+        ledgerCommonFields.insert(element.sField().getName());
+    }
+    for (auto const& format : LedgerFormats::getInstance())
+    {
+        auto const& soTemplate = format.getSOTemplate();
+        Json::Value templateArray = Json::arrayValue;
+        for (auto const& element : soTemplate)
+        {
+            if (ledgerCommonFields.contains(element.sField().getName()))
+                continue;  // skip common fields, already added
+            Json::Value elementObj = Json::objectValue;
+            elementObj[jss::name] = element.sField().getName();
+            elementObj[jss::optionality] = element.style();
+            templateArray.append(elementObj);
+        }
+        defs_[jss::LEDGER_ENTRY_FORMATS][format.getName()] = templateArray;
+    }
+
+    defs_[jss::TRANSACTION_FLAGS] = Json::objectValue;
+    for (auto const& [name, value] : getAllTxFlags())
+    {
+        Json::Value txObj = Json::objectValue;
+        for (auto const& [flagName, flagValue] : value)
+        {
+            txObj[flagName] = flagValue;
+        }
+        defs_[jss::TRANSACTION_FLAGS][name] = txObj;
+    }
+
+    defs_[jss::LEDGER_ENTRY_FLAGS] = Json::objectValue;
+    for (auto const& [name, value] : getAllLedgerFlags())
+    {
+        Json::Value ledgerObj = Json::objectValue;
+        for (auto const& [flagName, flagValue] : value)
+        {
+            ledgerObj[flagName] = flagValue;
+        }
+        defs_[jss::LEDGER_ENTRY_FLAGS][name] = ledgerObj;
+    }
+
+    defs_[jss::ACCOUNT_SET_FLAGS] = Json::objectValue;
+    for (auto const& [name, value] : getAsfFlagMap())
+    {
+        defs_[jss::ACCOUNT_SET_FLAGS][name] = value;
+    }
+
     // generate hash
     {
         std::string const out = Json::FastWriter().write(defs_);
diff --git a/src/xrpld/rpc/handlers/Simulate.cpp b/src/xrpld/rpc/handlers/Simulate.cpp
index b1be45c2ab..48481dcc82 100644
--- a/src/xrpld/rpc/handlers/Simulate.cpp
+++ b/src/xrpld/rpc/handlers/Simulate.cpp
@@ -127,7 +127,7 @@ autofillTx(Json::Value& tx_json, RPC::JsonContext& context)
     }
 
     if (auto error = autofillSignature(tx_json))
-        return *error;
+        return error;
 
     if (!tx_json.isMember(jss::Sequence))
     {
diff --git a/src/xrpld/rpc/handlers/Tx.cpp b/src/xrpld/rpc/handlers/Tx.cpp
index 84f2a6c618..a34c1f1a2e 100644
--- a/src/xrpld/rpc/handlers/Tx.cpp
+++ b/src/xrpld/rpc/handlers/Tx.cpp
@@ -42,7 +42,7 @@ struct TxResult
     std::optional<std::string> ctid;
     std::optional<NetClock::time_point> closeTime;
     std::optional<uint256> ledgerHash;
-    TxSearched searchedAll;
+    TxSearched searchedAll = TxSearched::unknown;
 };
 
 struct TxArgs