Merge remote-tracking branch 'ripple/develop' into spns5

2026-06-03 16:56:48 +00:00 · 2026-05-14 01:05:31 -04:00
parent 08357b196f afbccf971a
commit 39e819927f
531 changed files with 5382 additions and 3653 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -156,7 +156,13 @@ Checks: "-*,
 # readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
 # readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
 # ---
+
 CheckOptions:
+  bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
+  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
+
+  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
+
  readability-braces-around-statements.ShortStatementLines: 2
  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
  readability-identifier-naming.ClassCase: CamelCase
@@ -191,9 +197,7 @@ CheckOptions:
  readability-identifier-naming.ProtectedMemberSuffix: _
  readability-identifier-naming.PublicMemberSuffix: ""
  readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"
-  bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
-  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
-  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
+
 HeaderFilterRegex: '^.*/(test|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
 ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
 WarningsAsErrors: "*"
--- a/.github/scripts/strategy-matrix/generate.py
+++ b/.github/scripts/strategy-matrix/generate.py
@@ -72,7 +72,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                        skip = False
                    if (
                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
-                        and build_type == "Debug"
+                        and build_type == "Release"
                        and architecture["platform"] == "linux/amd64"
                    ):
                        skip = False
@@ -90,8 +90,9 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                    ):
                        cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=1000 {cmake_args}"
                        skip = False
+                elif os["distro_version"] == "trixie":
                    if (
-                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20"
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
                        and build_type == "Debug"
                        and architecture["platform"] == "linux/amd64"
                    ):
@@ -188,8 +189,9 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:

        # We skip all clang 20+ on arm64 due to Boost build error.
        if (
-            f"{os['compiler_name']}-{os['compiler_version']}"
-            in ["clang-20", "clang-21"]
+            os["compiler_name"] == "clang"
+            and os["compiler_version"].isdigit()
+            and int(os["compiler_version"]) >= 20
            and architecture["platform"] == "linux/arm64"
        ):
            continue
@@ -238,13 +240,14 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
        # Add Address and UB sanitizers as separate configurations for specific
        # bookworm distros. Thread sanitizer is currently disabled (see below).
        # GCC-Asan xrpld-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
-        if os[
-            "distro_version"
-        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
-            "gcc-15",
-            "clang-20",
-        ]:
-            # Add ASAN configuration.
+        if (
+            os["distro_version"] == "bookworm"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
+        ) or (
+            os["distro_version"] == "trixie"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+        ):
+            # Add ASAN and UBSAN configurations for both gcc-15 and clang-22
            configurations.append(
                {
                    "config_name": config_name + "-asan",
@@ -257,7 +260,6 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                    "sanitizers": "address",
                }
            )
-            # Add UBSAN configuration.
            configurations.append(
                {
                    "config_name": config_name + "-ubsan",
--- a/.github/scripts/strategy-matrix/linux.json
+++ b/.github/scripts/strategy-matrix/linux.json
@@ -15,196 +15,203 @@
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "15",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "16",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "17",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "18",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "19",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "20",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "gcc",
      "compiler_version": "15",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "clang",
      "compiler_version": "20",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "clang",
      "compiler_version": "21",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "22",
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "8",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "8",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "10",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "rhel",
      "distro_version": "10",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "jammy",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "16",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "17",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "18",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "19",
-      "image_sha": "ab4d1f0"
+      "image_sha": "4c086b9"
    }
  ],
  "build_type": ["Debug", "Release"],
--- a/.github/workflows/build-nix-image.yml
+++ b/.github/workflows/build-nix-image.yml
@@ -0,0 +1,101 @@
+name: Build Nix Docker image
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - "docker/nix.Dockerfile"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  pull_request:
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - "docker/nix.Dockerfile"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  UBUNTU_VERSION: "20.04"
+  RHEL_VERSION: "9"
+  DEBIAN_VERSION: "bookworm"
+
+jobs:
+  build:
+    name: Build and push Nix image (${{ matrix.distro }})
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          - distro: nixos
+          - distro: ubuntu
+          - distro: rhel
+          - distro: debian
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Determine base image
+        id: vars
+        run: |
+          case "${{ matrix.distro }}" in
+            nixos)
+              echo "base_image=nixos/nix:latest" >> $GITHUB_OUTPUT
+              ;;
+            ubuntu)
+              echo "base_image=ubuntu:${UBUNTU_VERSION}" >> $GITHUB_OUTPUT
+              ;;
+            rhel)
+              echo "base_image=registry.access.redhat.com/ubi${RHEL_VERSION}/ubi:latest" >> $GITHUB_OUTPUT
+              ;;
+            debian)
+              echo "base_image=debian:${DEBIAN_VERSION}" >> $GITHUB_OUTPUT
+              ;;
+          esac
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+
+      - name: Login to GitHub Container Registry
+        if: github.event_name == 'push'
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Docker metadata
+        id: meta
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/xrplf/ci/nix-${{ matrix.distro }}
+          tags: |
+            type=sha,prefix=sha-,format=short
+            type=raw,value=latest
+
+      - name: Build and push
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          file: docker/nix.Dockerfile
+          platforms: linux/amd64
+          push: ${{ github.event_name == 'push' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: BASE_IMAGE=${{ steps.vars.outputs.base_image }}
--- a/.github/workflows/reusable-build-test-config.yml
+++ b/.github/workflows/reusable-build-test-config.yml
@@ -181,7 +181,7 @@ jobs:
      - name: Build the binary
        working-directory: ${{ env.BUILD_DIR }}
        env:
-          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+          BUILD_NPROC: ${{ runner.os == 'Linux' && '16' || steps.nproc.outputs.nproc }}
          BUILD_TYPE: ${{ inputs.build_type }}
          CMAKE_TARGET: ${{ inputs.cmake_target }}
        run: |
@@ -283,8 +283,16 @@ jobs:

      - 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 }}
+        env:
+          WORKING_DIR: ${{ runner.os == 'Windows' && format('{0}\{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
        run: |
+          if [ ! -d "${WORKING_DIR}" ]; then
+            echo "Working directory '${WORKING_DIR}' does not exist."
+            exit 0
+          fi
+
+          cd "${WORKING_DIR}"
+
          if [ ! -f unittest.log ]; then
            echo "unittest.log not found; embedded tests may not have run."
            exit 0
--- a/.github/workflows/reusable-clang-tidy.yml
+++ b/.github/workflows/reusable-clang-tidy.yml
@@ -29,7 +29,7 @@ jobs:
    if: ${{ inputs.check_only_changed }}
    permissions:
      contents: read
-    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@12f5dbc98a2260259a66970e57fa4d26fb7f285c
+    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f

  run-clang-tidy:
    name: Run clang tidy
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -70,7 +70,11 @@ repos:
    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
    hooks:
      - id: cspell # Spell check changed files
-        exclude: (.config/cspell.config.yaml|^include/xrpl/protocol_autogen/(transactions|ledger_entries)/)
+        exclude: |
+          (?x)^(
+              .config/cspell.config.yaml|
+              include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
+          )$
      - id: cspell # Spell check the commit message
        name: check commit message spelling
        args:
--- a/BUILD.md
+++ b/BUILD.md
@@ -141,7 +141,7 @@ Alternatively, you can pull our recipes from the repository and export them loca

 ```bash
 # Define which recipes to export.
-recipes=('abseil' 'ed25519' 'grpc' 'm4' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
+recipes=('abseil' 'ed25519' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')

 # Selectively check out the recipes from our CCI fork.
 cd external
--- a/cfg/xrpld-example.cfg
+++ b/cfg/xrpld-example.cfg
@@ -1258,7 +1258,7 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           account_reserve = 10000000   # 10 XRP
+#           account_reserve = 1000000   # 1 XRP
 #
 #   owner_reserve = <drops>
 #
@@ -1270,7 +1270,7 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           owner_reserve = 2000000      # 2 XRP
+#           owner_reserve = 200000      # 0.2 XRP
 #
 #-------------------------------------------------------------------------------
 #
--- a/cmake/scripts/codegen/requirements.txt
+++ b/cmake/scripts/codegen/requirements.txt
@@ -10,4 +10,4 @@ pcpp>=1.30
 pyparsing>=3.0.0

 # Template engine - used to generate C++ code from templates
-Mako>=1.2.0
+Mako>=1.2.2
--- a/conan.lock
+++ b/conan.lock
@@ -1,38 +1,38 @@
 {
    "version": "0.5",
    "requires": [
-        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
+        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
-        "sqlite3/3.51.0#66aa11eabd0e34954c5c1c061ad44abe%1774467355.988",
+        "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1776096494.149",
        "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231",
        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",
        "secp256k1/0.7.1#481881709eb0bdd0185a12b912bbe8ad%1770910500.329",
        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1765850186.86",
        "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1774398111.888",
        "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12",
-        "openssl/3.6.1#e6399de266349245a4542fc5f6c71552%1774458290.139",
-        "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1774883011.384",
+        "openssl/3.6.2#4789bbf131b77d0515d15e094c8f697f%1778071755.506",
+        "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1775040983.408",
        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
-        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736",
-        "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244",
+        "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1776147552.838",
+        "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228",
        "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152",
        "grpc/1.78.1#b1a9e74b145cc471bed4dc64dc6eb2c1%1774467387.342",
        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772",
        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
        "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681",
        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
-        "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1769454080.269",
+        "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1778050991.9",
        "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
    ],
    "build_requires": [
-        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
+        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
        "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1774447376.964",
        "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12",
        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707",
        "msys2/cci.latest#d22fe7b2808f5fd34d0a7923ace9c54f%1770657326.649",
-        "m4/1.4.19#5d7a4994e5875d76faf7acf3ed056036%1774365463.87",
+        "m4/1.4.19#4523e4347b55cd26ae918bd5770cab9a%1778062762.471",
        "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183",
        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447",
        "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
@@ -48,13 +48,13 @@
            "lz4/1.10.0"
        ],
        "boost/[>=1.83.0 <1.91.0]": [
-            "boost/1.90.0"
+            "boost/1.91.0"
        ],
        "sqlite3/[>=3.44 <4]": [
-            "sqlite3/3.51.0"
+            "sqlite3/3.53.0"
        ],
        "boost/1.83.0": [
-            "boost/1.90.0"
+            "boost/1.91.0"
        ],
        "lz4/[>=1.9.4 <2]": [
            "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"
--- a/conan/global.conf
+++ b/conan/global.conf
@@ -3,3 +3,5 @@
 core:non_interactive=True
 core.download:parallel={{ os.cpu_count() }}
 core.upload:parallel={{ os.cpu_count() }}
+tools.files.download:retry=5
+tools.files.download:retry_wait=10
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,4 +1,3 @@
-import os
 import re

 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
@@ -30,12 +29,12 @@ class Xrpl(ConanFile):
    requires = [
        "ed25519/2015.03",
        "grpc/1.78.1",
-        "libarchive/3.8.1",
+        "libarchive/3.8.7",
        "nudb/2.0.9",
-        "openssl/3.6.1",
+        "openssl/3.6.2",
        "secp256k1/0.7.1",
        "soci/4.0.3",
-        "zlib/1.3.1",
+        "zlib/1.3.2",
    ]

    test_requires = [
@@ -57,6 +56,7 @@ class Xrpl(ConanFile):
        "tests": False,
        "unity": False,
        "xrpld": False,
+        "boost/*:without_cobalt": True,
        "boost/*:without_context": False,
        "boost/*:without_coroutine": True,
        "boost/*:without_coroutine2": False,
@@ -130,13 +130,13 @@ class Xrpl(ConanFile):
            self.options["boost"].without_cobalt = True

    def requirements(self):
-        self.requires("boost/1.90.0", force=True, transitive_headers=True)
+        self.requires("boost/1.91.0", force=True, transitive_headers=True)
        self.requires("date/3.0.4", transitive_headers=True)
        self.requires("lz4/1.10.0", force=True)
        self.requires("protobuf/6.33.5", force=True)
-        self.requires("sqlite3/3.51.0", force=True)
+        self.requires("sqlite3/3.53.0", force=True)
        if self.options.jemalloc:
-            self.requires("jemalloc/5.3.0")
+            self.requires("jemalloc/5.3.1")
        if self.options.rocksdb:
            self.requires("rocksdb/10.5.1")
        self.requires("xxhash/0.8.3", transitive_headers=True)
--- a/cspell.config.yaml
+++ b/cspell.config.yaml
@@ -63,6 +63,7 @@ words:
  - Bougalis
  - Britto
  - Btrfs
+  - Buildx
  - canonicality
  - changespq
  - checkme
--- a/docker/nix.Dockerfile
+++ b/docker/nix.Dockerfile
@@ -0,0 +1,66 @@
+ARG BASE_IMAGE=nixos/nix:latest
+
+# Nix builder
+FROM nixos/nix:latest AS builder-source
+
+RUN mkdir -p ~/.config/nix && \
+    echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+
+# Copy our source and setup our working dir.
+COPY nix/ci-env.nix /tmp/build/nix/ci-env.nix
+COPY nix/packages.nix /tmp/build/nix/packages.nix
+COPY nix/utils.nix /tmp/build/nix/utils.nix
+COPY flake.nix /tmp/build/
+COPY flake.lock /tmp/build/
+WORKDIR /tmp/build
+
+FROM builder-source AS builder
+
+# Build our Nix CI environment (all build tools in a single store path)
+RUN nix \
+    --option filter-syscalls false \
+    build
+
+# Copy the Nix store closure into a directory. The Nix store closure is the
+# entire set of Nix store values that we need for our build.
+RUN mkdir /tmp/nix-store-closure && \
+    cp -R $(nix-store -qR result/) /tmp/nix-store-closure
+
+# Final image
+FROM ${BASE_IMAGE}
+
+# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
+RUN if [ -d /nix ]; then \
+        ln -s /root/.nix-profile/bin/bash /bin/bash; \
+    fi
+
+# Use Bash as the default shell for RUN commands, using the options
+# `set -o errexit -o pipefail`, and as the entrypoint.
+SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"]
+ENTRYPOINT ["/bin/bash"]
+
+# Copy /nix/store and the env symlink tree
+COPY --from=builder /tmp/nix-store-closure /nix/store
+COPY --from=builder /tmp/build/result /nix/ci-env
+
+ENV PATH="/nix/ci-env/bin:$PATH"
+
+RUN <<EOF
+ccache --version
+clang-format --version
+cmake --version
+conan --version
+g++ --version
+gcc --version
+gcovr --version
+git --version
+make --version
+mold --version
+ninja --version
+perl --version
+pkg-config --version
+pre-commit --version
+python3 --version
+run-clang-tidy --help
+vim --version
+EOF
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1769461804,
-        "narHash": "sha256-6h5sROT/3CTHvzPy9koKBmoCa2eJKh4fzQK8eYFEgl8=",
+        "lastModified": 1777954456,
+        "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "b579d443b37c9c5373044201ea77604e37e748c8",
+        "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
        "type": "github"
      },
      "original": {
@@ -15,9 +15,27 @@
        "type": "indirect"
      }
    },
+    "nixpkgs-glibc231": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1593520194,
+        "narHash": "sha256-+TZW+2I7kLL9JglPNOagm1ywjf9ua0JYGoptq/dzVn0=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9cd98386a38891d1074fc18036b842dc4416f562",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9cd98386a38891d1074fc18036b842dc4416f562",
+        "type": "github"
+      }
+    },
    "root": {
      "inputs": {
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-glibc231": "nixpkgs-glibc231"
      }
    }
  },
--- a/flake.nix
+++ b/flake.nix
@@ -2,15 +2,24 @@
  description = "Nix related things for xrpld";
  inputs = {
    nixpkgs.url = "nixpkgs/nixos-unstable";
+    # nixpkgs snapshot (2020-06-30) that shipped glibc 2.31 as the primary
+    # version — matches the system libc on Ubuntu 20.04 LTS. Imported
+    # manually (flake = false) because this revision predates nixpkgs'
+    # own flake.nix.
+    nixpkgs-glibc231 = {
+      url = "github:NixOS/nixpkgs/9cd98386a38891d1074fc18036b842dc4416f562";
+      flake = false;
+    };
  };

  outputs =
-    { nixpkgs, ... }:
+    { nixpkgs, nixpkgs-glibc231, ... }:
    let
-      forEachSystem = (import ./nix/utils.nix { inherit nixpkgs; }).forEachSystem;
+      forEachSystem = import ./nix/utils.nix { inherit nixpkgs nixpkgs-glibc231; };
    in
    {
      devShells = forEachSystem (import ./nix/devshell.nix);
+      packages = forEachSystem (import ./nix/ci-env.nix);
      formatter = forEachSystem ({ pkgs, ... }: pkgs.nixfmt);
    };
 }
--- a/include/xrpl/basics/Expected.h
+++ b/include/xrpl/basics/Expected.h
@@ -148,17 +148,23 @@ public:
    }

    [[nodiscard]] constexpr E const&
-    error() const
+    error() const&
    {
        return Base::error();
    }

-    constexpr E&
-    error()
+    [[nodiscard]] constexpr E&
+    error() &
    {
        return Base::error();
    }

+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
    constexpr explicit
    operator bool() const
    {
@@ -215,17 +221,23 @@ public:
    }

    [[nodiscard]] constexpr E const&
-    error() const
+    error() const&
    {
        return Base::error();
    }

-    constexpr E&
-    error()
+    [[nodiscard]] constexpr E&
+    error() &
    {
        return Base::error();
    }

+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
    constexpr explicit
    operator bool() const
    {
--- a/include/xrpl/basics/Log.h
+++ b/include/xrpl/basics/Log.h
@@ -10,24 +10,11 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <utility>

 namespace xrpl {

-// DEPRECATED use beast::severities::Severity instead
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum LogSeverity {
-    LSInvalid = -1,  // used to indicate an invalid severity
-    LSTrace = 0,     // Very low-level progress information, details inside
-                     // an operation
-    LSDebug = 1,     // Function-level progress information, operations
-    LSInfo = 2,      // Server-level progress information, major operations
-    LSWarning = 3,   // Conditions that warrant human attention, may indicate
-                     // a problem
-    LSError = 4,     // A condition that indicates a problem
-    LSFatal = 5      // A severe condition that indicates a server problem
-};
-
 /** Manages partitions for logging. */
 class Logs
 {
@@ -39,17 +26,17 @@ private:
        std::string partition_;

    public:
-        Sink(std::string partition, beast::severities::Severity thresh, Logs& logs);
+        Sink(std::string partition, beast::Severity thresh, Logs& logs);

        Sink(Sink const&) = delete;
        Sink&
        operator=(Sink const&) = delete;

        void
-        write(beast::severities::Severity level, std::string const& text) override;
+        write(beast::Severity level, std::string const& text) override;

        void
-        writeAlways(beast::severities::Severity level, std::string const& text) override;
+        writeAlways(beast::Severity level, std::string const& text) override;
    };

    /** Manages a system file containing logged output.
@@ -136,12 +123,12 @@ private:

    std::mutex mutable mutex_;
    std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
-    beast::severities::Severity thresh_;
+    beast::Severity thresh_;
    File file_;
    bool silent_ = false;

 public:
-    Logs(beast::severities::Severity level);
+    Logs(beast::Severity level);

    Logs(Logs const&) = delete;
    Logs&
@@ -161,18 +148,18 @@ public:
    beast::Journal
    journal(std::string const& name);

-    beast::severities::Severity
+    beast::Severity
    threshold() const;

    void
-    threshold(beast::severities::Severity thresh);
+    threshold(beast::Severity thresh);

    std::vector<std::pair<std::string, std::string>>
    partitionSeverities() const;

    void
    write(
-        beast::severities::Severity level,
+        beast::Severity level,
        std::string const& partition,
        std::string const& text,
        bool console);
@@ -192,36 +179,25 @@ public:
    }

    virtual std::unique_ptr<beast::Journal::Sink>
-    makeSink(std::string const& partition, beast::severities::Severity startingLevel);
+    makeSink(std::string const& partition, beast::Severity startingLevel);

 public:
-    static LogSeverity
-    fromSeverity(beast::severities::Severity level);
-
-    static beast::severities::Severity
-    toSeverity(LogSeverity level);
-
    static std::string
-    toString(LogSeverity s);
+    toString(beast::Severity s);

-    static LogSeverity
+    static std::optional<beast::Severity>
    fromString(std::string const& s);

 private:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        // Maximum line length for log messages.
-        // If the message exceeds this length it will be truncated with
-        // ellipses.
-        MaximumMessageCharacters = 12 * 1024
-    };
+    // Maximum line length for log messages.
+    // If the message exceeds this length it will be truncated with ellipses.
+    static constexpr auto kMAXIMUM_MESSAGE_CHARACTERS = 12 * 1024;

    static void
    format(
        std::string& output,
        std::string const& message,
-        beast::severities::Severity severity,
+        beast::Severity severity,
        std::string const& partition);
 };

--- a/include/xrpl/basics/SHAMapHash.h
+++ b/include/xrpl/basics/SHAMapHash.h
@@ -21,12 +21,12 @@ public:
    }

    [[nodiscard]] uint256 const&
-    asUint256() const
+    asUInt256() const
    {
        return hash_;
    }
    uint256&
-    asUint256()
+    asUInt256()
    {
        return hash_;
    }
@@ -93,7 +93,7 @@ template <>
 inline std::size_t
 extract(SHAMapHash const& key)
 {
-    return *reinterpret_cast<std::size_t const*>(key.asUint256().data());
+    return *reinterpret_cast<std::size_t const*>(key.asUInt256().data());
 }

 }  // namespace xrpl
--- a/include/xrpl/basics/StringUtilities.h
+++ b/include/xrpl/basics/StringUtilities.h
@@ -7,9 +7,11 @@
 #include <boost/utility/string_view.hpp>

 #include <array>
+#include <concepts>
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <type_traits>

 namespace xrpl {

@@ -26,28 +28,39 @@ namespace xrpl {
 std::string
 sqlBlobLiteral(Blob const& blob);

+namespace detail {
+
+template <typename T>
+concept SomeChar = std::same_as<std::remove_cvref_t<T>, int8_t> ||
+    std::same_as<std::remove_cvref_t<T>, char> || std::same_as<std::remove_cvref_t<T>, uint8_t>;
+
+inline constexpr std::array<std::optional<int>, 256> const kDIGIT_LOOKUP_TABLE = []() {
+    std::array<std::optional<int>, 256> t{};
+
+    for (int i = 0; i < 10; ++i)
+        t['0' + i] = i;
+
+    for (int i = 0; i < 6; ++i)
+    {
+        t['A' + i] = 10 + i;
+        t['a' + i] = 10 + i;
+    }
+
+    return t;
+}();
+
+inline std::optional<int>
+hexCharToInt(SomeChar auto hexChar)
+{
+    return kDIGIT_LOOKUP_TABLE[static_cast<uint8_t>(hexChar)];
+}
+
+}  // namespace detail
+
 template <class Iterator>
 std::optional<Blob>
 strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 {
-    static constexpr std::array<int, 256> const kDIGIT_LOOKUP_TABLE = []() {
-        std::array<int, 256> t{};
-
-        for (auto& x : t)
-            x = -1;
-
-        for (int i = 0; i < 10; ++i)
-            t['0' + i] = i;
-
-        for (int i = 0; i < 6; ++i)
-        {
-            t['A' + i] = 10 + i;
-            t['a' + i] = 10 + i;
-        }
-
-        return t;
-    }();
-
    Blob out;

    out.reserve((strSize + 1) / 2);
@@ -56,27 +69,26 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)

    if (strSize & 1)
    {
-        int c = kDIGIT_LOOKUP_TABLE[*iter++];
-
-        if (c < 0)
+        auto const c = detail::hexCharToInt(*iter++);
+        if (!c.has_value())
            return {};

-        out.push_back(c);
+        out.push_back(static_cast<unsigned char>(*c));
    }

    while (iter != end)
    {
-        int const cHigh = kDIGIT_LOOKUP_TABLE[*iter++];
+        auto const cHigh = detail::hexCharToInt(*iter++);

-        if (cHigh < 0)
+        if (!cHigh.has_value())
            return {};

-        int const cLow = kDIGIT_LOOKUP_TABLE[*iter++];
+        auto const cLow = detail::hexCharToInt(*iter++);

-        if (cLow < 0)
+        if (!cLow.has_value())
            return {};

-        out.push_back(static_cast<unsigned char>((cHigh << 4) | cLow));
+        out.push_back(static_cast<unsigned char>((*cHigh << 4) | *cLow));
    }

    return {std::move(out)};
@@ -120,7 +132,7 @@ std::string
 trimWhitespace(std::string str);

 std::optional<std::uint64_t>
-toUint64(std::string const& s);
+toUInt64(std::string const& s);

 /** Determines if the given string looks like a TOML-file hosting domain.

--- a/include/xrpl/basics/base_uint.h
+++ b/include/xrpl/basics/base_uint.h
@@ -46,6 +46,11 @@ struct IsContiguousContainer<Slice> : std::true_type
 {
 };

+template <typename...>
+struct AlwaysFalseT : std::bool_constant<false>
+{
+};
+
 }  // namespace detail

 /** Integers of any length that is a multiple of 32-bits
@@ -62,7 +67,7 @@ struct IsContiguousContainer<Slice> : std::true_type
                      number of bits.
 */
 template <std::size_t Bits, class Tag = void>
-class BaseUint
+class BaseUInt
 {
    static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32.");

@@ -160,7 +165,7 @@ private:
        explicit VoidHelper() = default;
    };

-    explicit BaseUint(void const* data, VoidHelper)
+    explicit BaseUInt(void const* data, VoidHelper)
    {
        memcpy(data_.data(), data, kBYTES);
    }
@@ -244,15 +249,15 @@ private:
    }

 public:
-    constexpr BaseUint() : data_{}
+    constexpr BaseUInt() : data_{}
    {
    }

-    constexpr BaseUint(beast::Zero) : data_{}
+    constexpr BaseUInt(beast::Zero) : data_{}
    {
    }

-    explicit BaseUint(std::uint64_t b)
+    explicit BaseUInt(std::uint64_t b)
    {
        *this = b;
    }
@@ -260,7 +265,7 @@ public:
    // This constructor is intended to be used at compile time since it might
    // throw at runtime.  Consider declaring this constructor consteval once
    // we get to C++23.
-    explicit constexpr BaseUint(std::string_view sv) noexcept(false)
+    explicit constexpr BaseUInt(std::string_view sv) noexcept(false)
        : data_(parseFromStringViewThrows(sv))
    {
    }
@@ -270,24 +275,42 @@ public:
        class = std::enable_if_t<
            detail::IsContiguousContainer<Container>::value &&
            std::is_trivially_copyable_v<typename Container::value_type>>>
-    explicit BaseUint(Container const& c)
+    explicit BaseUInt(Container const& c)
    {
+        // Use AlwaysFalseT so the static_assert condition is dependent
+        // and only triggers when this constructor template is instantiated.
+        static_assert(
+            detail::AlwaysFalseT<Container>::value,
+            "This constructor is not intended to be used and will be soon removed. "
+            "Use base_uint::fromRaw instead.");
+    }
+
+    template <
+        class Container,
+        class = std::enable_if_t<
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>>>
+    static BaseUInt
+    fromRaw(Container const& c)
+    {
+        BaseUInt result;
        XRPL_ASSERT(
            c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::base_uint::base_uint(Container auto) : input size match");
-        std::memcpy(data_.data(), c.data(), size());
+            "xrpl::BaseUInt::fromRaw(Container auto) : input size match");
+        std::memcpy(result.data_.data(), c.data(), size());
+        return result;
    }

    template <class Container>
    std::enable_if_t<
        detail::IsContiguousContainer<Container>::value &&
            std::is_trivially_copyable_v<typename Container::value_type>,
-        BaseUint&>
+        BaseUInt&>
    operator=(Container const& c)
    {
        XRPL_ASSERT(
            c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::base_uint::operator=(Container auto) : input size match");
+            "xrpl::BaseUInt::operator=(Container auto) : input size match");
        std::memcpy(data_.data(), c.data(), size());
        return *this;
    }
@@ -295,14 +318,14 @@ public:
    /* Construct from a raw pointer.
        The buffer pointed to by `data` must be at least Bits/8 bytes.
    */
-    static BaseUint
+    static BaseUInt
    fromVoid(void const* data)
    {
-        return BaseUint(data, VoidHelper());
+        return BaseUInt(data, VoidHelper());
    }

    template <class T>
-    static std::optional<BaseUint>
+    static std::optional<BaseUInt>
    fromVoidChecked(T const& from)
    {
        if (from.size() != size())
@@ -328,10 +351,10 @@ public:
        return *this == beast::kZERO;
    }

-    constexpr BaseUint
+    constexpr BaseUInt
    operator~() const
    {
-        BaseUint ret;
+        BaseUInt ret;

        for (int i = 0; i < kWIDTH; i++)
            ret.data_[i] = ~data_[i];
@@ -339,7 +362,7 @@ public:
        return ret;
    }

-    BaseUint&
+    BaseUInt&
    operator=(std::uint64_t uHost)
    {
        *this = beast::kZERO;
@@ -357,8 +380,8 @@ public:
        return *this;
    }

-    BaseUint&
-    operator^=(BaseUint const& b)
+    BaseUInt&
+    operator^=(BaseUInt const& b)
    {
        for (int i = 0; i < kWIDTH; i++)
            data_[i] ^= b.data_[i];
@@ -366,8 +389,8 @@ public:
        return *this;
    }

-    BaseUint&
-    operator&=(BaseUint const& b)
+    BaseUInt&
+    operator&=(BaseUInt const& b)
    {
        for (int i = 0; i < kWIDTH; i++)
            data_[i] &= b.data_[i];
@@ -375,8 +398,8 @@ public:
        return *this;
    }

-    BaseUint&
-    operator|=(BaseUint const& b)
+    BaseUInt&
+    operator|=(BaseUInt const& b)
    {
        for (int i = 0; i < kWIDTH; i++)
            data_[i] |= b.data_[i];
@@ -384,7 +407,7 @@ public:
        return *this;
    }

-    BaseUint&
+    BaseUInt&
    operator++()
    {
        // prefix operator
@@ -398,17 +421,17 @@ public:
        return *this;
    }

-    BaseUint
+    BaseUInt
    operator++(int)
    {
        // postfix operator
-        BaseUint const ret = *this;
+        BaseUInt const ret = *this;
        ++(*this);

        return ret;
    }

-    BaseUint&
+    BaseUInt&
    operator--()
    {
        for (int i = kWIDTH - 1; i >= 0; --i)
@@ -423,32 +446,32 @@ public:
        return *this;
    }

-    BaseUint
+    BaseUInt
    operator--(int)
    {
        // postfix operator
-        BaseUint const ret = *this;
+        BaseUInt const ret = *this;
        --(*this);

        return ret;
    }

-    [[nodiscard]] BaseUint
+    [[nodiscard]] BaseUInt
    next() const
    {
        auto ret = *this;
        return ++ret;
    }

-    [[nodiscard]] BaseUint
+    [[nodiscard]] BaseUInt
    prev() const
    {
        auto ret = *this;
        return --ret;
    }

-    BaseUint&
-    operator+=(BaseUint const& b)
+    BaseUInt&
+    operator+=(BaseUInt const& b)
    {
        std::uint64_t carry = 0;

@@ -466,7 +489,7 @@ public:

    template <class Hasher>
    friend void
-    hash_append(Hasher& h, BaseUint const& a) noexcept
+    hash_append(Hasher& h, BaseUInt const& a) noexcept
    {
        // Do not allow any endian transformations on this memory
        h(a.data_.data(), sizeof(a.data_));
@@ -509,7 +532,7 @@ public:
        return kBYTES;
    }

-    BaseUint<Bits, Tag>&
+    BaseUInt<Bits, Tag>&
    operator=(beast::Zero)
    {
        data_.fill(0);
@@ -534,14 +557,14 @@ public:
    }
 };

-using uint128 = BaseUint<128>;
-using uint160 = BaseUint<160>;
-using uint256 = BaseUint<256>;
-using uint192 = BaseUint<192>;
+using uint128 = BaseUInt<128>;
+using uint160 = BaseUInt<160>;
+using uint256 = BaseUInt<256>;
+using uint192 = BaseUInt<192>;

 template <std::size_t Bits, class Tag>
 [[nodiscard]] constexpr std::strong_ordering
-operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
+operator<=>(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 {
    // This comparison might seem wrong on a casual inspection because it
    // compares data internally stored as std::uint32_t byte-by-byte. But
@@ -562,7 +585,7 @@ operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)

 template <std::size_t Bits, typename Tag>
 [[nodiscard]] constexpr bool
-operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
+operator==(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 {
    return (lhs <=> rhs) == 0;
 }
@@ -570,59 +593,59 @@ operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 constexpr bool
-operator==(BaseUint<Bits, Tag> const& a, std::uint64_t b)
+operator==(BaseUInt<Bits, Tag> const& a, std::uint64_t b)
 {
-    return a == BaseUint<Bits, Tag>(b);
+    return a == BaseUInt<Bits, Tag>(b);
 }

 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator^(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator^(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) ^= b;
+    return BaseUInt<Bits, Tag>(a) ^= b;
 }

 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator&(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator&(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) &= b;
+    return BaseUInt<Bits, Tag>(a) &= b;
 }

 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator|(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator|(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) |= b;
+    return BaseUInt<Bits, Tag>(a) |= b;
 }

 template <std::size_t Bits, class Tag>
-constexpr BaseUint<Bits, Tag>
-operator+(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
+constexpr BaseUInt<Bits, Tag>
+operator+(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
 {
-    return BaseUint<Bits, Tag>(a) += b;
+    return BaseUInt<Bits, Tag>(a) += b;
 }

 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 inline std::string
-to_string(BaseUint<Bits, Tag> const& a)
+to_string(BaseUInt<Bits, Tag> const& a)
 {
    return strHex(a.cbegin(), a.cend());
 }

 template <std::size_t Bits, class Tag>
 inline std::string
-toShortString(BaseUint<Bits, Tag> const& a)
+toShortString(BaseUInt<Bits, Tag> const& a)
 {
-    static_assert(BaseUint<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
+    static_assert(BaseUInt<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
    return strHex(a.cbegin(), a.cbegin() + 4) + "...";
 }

 template <std::size_t Bits, class Tag>
 inline std::ostream&
-operator<<(std::ostream& out, BaseUint<Bits, Tag> const& u)
+operator<<(std::ostream& out, BaseUInt<Bits, Tag> const& u)
 {
    return out << to_string(u);
 }
@@ -650,7 +673,7 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
 namespace beast {

 template <std::size_t Bits, class Tag>
-struct IsUniquelyRepresented<xrpl::BaseUint<Bits, Tag>> : public std::true_type
+struct IsUniquelyRepresented<xrpl::BaseUInt<Bits, Tag>> : public std::true_type
 {
    explicit IsUniquelyRepresented() = default;
 };
--- a/include/xrpl/basics/partitioned_unordered_map.h
+++ b/include/xrpl/basics/partitioned_unordered_map.h
@@ -236,7 +236,7 @@ public:
        map_.resize(partitions_);
        XRPL_ASSERT(
            partitions_,
-            "xrpl::partitioned_unordered_map::partitioned_unordered_map : "
+            "xrpl::PartitionedUnorderedMap::PartitionedUnorderedMap : "
            "nonzero partitions");
    }

--- a/include/xrpl/basics/random.h
+++ b/include/xrpl/basics/random.h
@@ -94,7 +94,7 @@ template <class Engine, class Integral>
 std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral min, Integral max)
 {
-    XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
+    XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");

    // This should have no state and constructing it should
    // be very cheap. If that turns out not to be the case
--- a/include/xrpl/basics/safe_cast.h
+++ b/include/xrpl/basics/safe_cast.h
@@ -81,7 +81,7 @@ safeDowncast(Src* s) noexcept
    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");
+    XRPL_ASSERT(result != nullptr, "xrpl::safeDowncast : pointer downcast is valid");
    return result;
 #endif
 }
@@ -94,7 +94,7 @@ safeDowncast(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");
+        "xrpl::safeDowncast : reference downcast is valid");
 #endif
    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
 }
--- a/include/xrpl/basics/scope.h
+++ b/include/xrpl/basics/scope.h
@@ -205,7 +205,7 @@ class ScopeUnlock
 public:
    explicit ScopeUnlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock_(&lock)
    {
-        XRPL_ASSERT(plock_->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
+        XRPL_ASSERT(plock_->owns_lock(), "xrpl::ScopeUnlock::ScopeUnlock : mutex must be locked");
        plock_->unlock();
    }

--- a/include/xrpl/basics/spinlock.h
+++ b/include/xrpl/basics/spinlock.h
@@ -103,7 +103,7 @@ public:
    {
        XRPL_ASSERT(
            index >= 0 && (mask_ != 0),
-            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
+            "xrpl::PackedSpinlock::PackedSpinlock : valid index and mask");
    }

    [[nodiscard]] bool
--- a/include/xrpl/beast/asio/io_latency_probe.h
+++ b/include/xrpl/beast/asio/io_latency_probe.h
@@ -15,7 +15,7 @@ namespace beast {

 /** Measures handler latency on an io_context queue. */
 template <class Clock>
-class IoLatencyProbe
+class IOLatencyProbe
 {
 private:
    using duration = typename Clock::duration;
@@ -30,12 +30,12 @@ private:
    bool cancel_{false};

 public:
-    IoLatencyProbe(duration const& period, boost::asio::io_context& ios)
+    IOLatencyProbe(duration const& period, boost::asio::io_context& ios)
        : period_(period), ios_(ios), timer_(ios_)
    {
    }

-    ~IoLatencyProbe()
+    ~IOLatencyProbe()
    {
        std::unique_lock<decltype(mutex_)> lock(mutex_);
        cancel(lock, true);
@@ -85,7 +85,7 @@ public:
    {
        std::scoped_lock const lock(mutex_);
        if (cancel_)
-            throw std::logic_error("io_latency_probe is canceled");
+            throw std::logic_error("IOLatencyProbe is canceled");
        boost::asio::post(
            ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
    }
@@ -100,7 +100,7 @@ public:
    {
        std::scoped_lock const lock(mutex_);
        if (cancel_)
-            throw std::logic_error("io_latency_probe is canceled");
+            throw std::logic_error("IOLatencyProbe is canceled");
        boost::asio::post(
            ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
    }
@@ -140,18 +140,18 @@ private:
        Handler handler;
        time_point start;
        bool repeat;
-        IoLatencyProbe* probe;
+        IOLatencyProbe* probe;

        SampleOp(
            Handler const& handler,
            time_point const& start,
            bool repeat,
-            IoLatencyProbe* probe)
+            IOLatencyProbe* probe)
            : handler(handler), start(start), repeat(repeat), probe(probe)
        {
            XRPL_ASSERT(
                probe,
-                "beast::io_latency_probe::sample_op::sample_op : non-null "
+                "beast::IOLatencyProbe::SampleOp::SampleOp : non-null "
                "probe input");
            probe->addref();
        }
@@ -164,7 +164,7 @@ private:
        {
            XRPL_ASSERT(
                probe,
-                "beast::io_latency_probe::sample_op::sample_op(sample_op&&) : "
+                "beast::IOLatencyProbe::SampleOp::SampleOp(SampleOp&&) : "
                "non-null probe input");
            from.probe = nullptr;
        }
--- a/include/xrpl/beast/container/detail/aged_unordered_container.h
+++ b/include/xrpl/beast/container/detail/aged_unordered_container.h
@@ -1370,7 +1370,7 @@ private:
            buck_.resize(size() + additional, cont_);
        XRPL_ASSERT(
            loadFactor() <= maxLoadFactor(),
-            "beast::detail::AgedUnorderedContainer::maybe_rehash : maximum "
+            "beast::detail::AgedUnorderedContainer::maybeRehash : maximum "
            "load factor");
    }

--- a/include/xrpl/beast/unit_test/reporter.h
+++ b/include/xrpl/beast/unit_test/reporter.h
@@ -62,9 +62,7 @@ private:
    {
        using run_time = std::pair<std::string, typename clock_type::duration>;

-        // Need to be named before converting
-        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-        enum { MaxTop = 10 };
+        static constexpr auto kMAX_TOP = 10;

        std::size_t suites = 0;
        std::size_t cases = 0;
@@ -148,11 +146,11 @@ Reporter<Unused>::Results::add(SuiteResults const& r)
            });
        if (iter != top.end())
        {
-            if (top.size() == MaxTop)
+            if (top.size() == kMAX_TOP)
                top.resize(top.size() - 1);
            top.emplace(iter, r.name, elapsed);
        }
-        else if (top.size() < MaxTop)
+        else if (top.size() < kMAX_TOP)
        {
            top.emplace_back(r.name, elapsed);
        }
--- a/include/xrpl/beast/utility/Journal.h
+++ b/include/xrpl/beast/utility/Journal.h
@@ -2,29 +2,25 @@

 #include <xrpl/beast/utility/instrumentation.h>

+#include <cstdint>
 #include <sstream>

 namespace beast {

-/** A namespace for easy access to logging severity values. */
-namespace severities {
 /** Severity level / threshold of a Journal message. */
-// Hundreds of usages via logging macros
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum Severity {
-    KAll = 0,
+enum class Severity : std::uint8_t {
+    All = 0,

-    KTrace = KAll,
-    KDebug = 1,
-    KInfo = 2,
-    KWarning = 3,
-    KError = 4,
-    KFatal = 5,
+    Trace = All,
+    Debug = 1,
+    Info = 2,
+    Warning = 3,
+    Error = 4,
+    Fatal = 5,

-    KDisabled = 6,
-    KNone = KDisabled
+    Disabled = 6,
+    None = Disabled
 };
-}  // namespace severities

 /** A generic endpoint for log messages.

@@ -44,9 +40,6 @@ public:
    class Sink;

 private:
-    // Severity level / threshold of a Journal message.
-    using Severity = severities::Severity;
-
    // Invariant: sink_ always points to a valid Sink
    Sink* sink_;

@@ -183,7 +176,7 @@ public:
    {
    public:
        /** Create a stream which produces no output. */
-        explicit Stream() : sink_(getNullSink()), level_(severities::KDisabled)
+        explicit Stream() : sink_(getNullSink()), level_(Severity::Disabled)
        {
        }

@@ -194,7 +187,7 @@ public:
        Stream(Sink& sink, Severity level) : sink_(sink), level_(level)
        {
            XRPL_ASSERT(
-                level_ < severities::KDisabled, "beast::Journal::Stream::Stream : maximum level");
+                level_ < Severity::Disabled, "beast::Journal::Stream::Stream : maximum level");
        }

        /** Construct or copy another Stream. */
@@ -297,37 +290,37 @@ public:
    [[nodiscard]] Stream
    trace() const
    {
-        return {*sink_, severities::KTrace};
+        return {*sink_, Severity::Trace};
    }

    [[nodiscard]] Stream
    debug() const
    {
-        return {*sink_, severities::KDebug};
+        return {*sink_, Severity::Debug};
    }

    [[nodiscard]] Stream
    info() const
    {
-        return {*sink_, severities::KInfo};
+        return {*sink_, Severity::Info};
    }

    [[nodiscard]] Stream
    warn() const
    {
-        return {*sink_, severities::KWarning};
+        return {*sink_, Severity::Warning};
    }

    [[nodiscard]] Stream
    error() const
    {
-        return {*sink_, severities::KError};
+        return {*sink_, Severity::Error};
    }

    [[nodiscard]] Stream
    fatal() const
    {
-        return {*sink_, severities::KFatal};
+        return {*sink_, Severity::Fatal};
    }
    /** @} */
 };
--- a/include/xrpl/beast/utility/WrappedSink.h
+++ b/include/xrpl/beast/utility/WrappedSink.h
@@ -36,7 +36,7 @@ public:
    }

    [[nodiscard]] bool
-    active(beast::severities::Severity level) const override
+    active(beast::Severity level) const override
    {
        return sink_.active(level);
    }
@@ -53,27 +53,27 @@ public:
        sink_.console(output);
    }

-    [[nodiscard]] beast::severities::Severity
+    [[nodiscard]] beast::Severity
    threshold() const override
    {
        return sink_.threshold();
    }

    void
-    threshold(beast::severities::Severity thresh) override
+    threshold(beast::Severity thresh) override
    {
        sink_.threshold(thresh);
    }

    void
-    write(beast::severities::Severity level, std::string const& text) override
+    write(beast::Severity level, std::string const& text) override
    {
        using beast::Journal;
        sink_.write(level, prefix_ + text);
    }

    void
-    writeAlways(severities::Severity level, std::string const& text) override
+    writeAlways(Severity level, std::string const& text) override
    {
        using beast::Journal;
        sink_.writeAlways(level, prefix_ + text);
--- a/include/xrpl/json/JsonPropertyStream.h
+++ b/include/xrpl/json/JsonPropertyStream.h
@@ -5,7 +5,7 @@

 namespace xrpl {

-/** A PropertyStream::Sink which produces a json::Value of type objectValue. */
+/** A PropertyStream::Sink which produces a json::Value of type ValueType::Object. */
 class JsonPropertyStream : public beast::PropertyStream
 {
 public:
--- a/include/xrpl/json/json_reader.h
+++ b/include/xrpl/json/json_reader.h
@@ -70,24 +70,22 @@ public:
    static constexpr unsigned kNEST_LIMIT{25};

 private:
-    // 53 files, protocol-wide
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum TokenType {
-        TokenEndOfStream = 0,
-        TokenObjectBegin,
-        TokenObjectEnd,
-        TokenArrayBegin,
-        TokenArrayEnd,
-        TokenString,
-        TokenInteger,
-        TokenDouble,
-        TokenTrue,
-        TokenFalse,
-        TokenNull,
-        TokenArraySeparator,
-        TokenMemberSeparator,
-        TokenComment,
-        TokenError
+    enum class TokenType {
+        EndOfStream = 0,
+        ObjectBegin,
+        ObjectEnd,
+        ArrayBegin,
+        ArrayEnd,
+        String,
+        Integer,
+        Double,
+        True,
+        False,
+        Null,
+        ArraySeparator,
+        MemberSeparator,
+        Comment,
+        Error
    };

    class Token
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -15,22 +15,20 @@ namespace json {

 /** \brief Type of the value held by a Value object.
 */
-// Used throughout JSON layer
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum ValueType {
-    NullValue = 0,  ///< 'null' value
-    IntValue,       ///< signed integer value
-    UintValue,      ///< unsigned integer value
-    RealValue,      ///< double value
-    StringValue,    ///< UTF-8 string value
-    BooleanValue,   ///< bool value
-    ArrayValue,     ///< array value (ordered list)
-    ObjectValue     ///< object value (collection of name/value pairs).
+enum class ValueType {
+    Null = 0,  ///< 'null' value
+    Int,       ///< signed integer value
+    UInt,      ///< unsigned integer value
+    Real,      ///< double value
+    String,    ///< UTF-8 string value
+    Boolean,   ///< bool value
+    Array,     ///< array value (ordered list)
+    Object     ///< object value (collection of name/value pairs).
 };

 /** \brief Lightweight wrapper to tag static string.
 *
- * Value constructor and objectValue member assignment takes advantage of the
+ * Value constructor and ValueType::Object member assignment takes advantage of the
 * StaticString and avoid the cost of string duplication when storing the
 * string or the member name.
 *
@@ -104,8 +102,8 @@ operator!=(StaticString x, std::string const& y)
 /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
 *
 * This class is a discriminated union wrapper that can represent a:
- * - signed integer [range: Value::minInt - Value::maxInt]
- * - unsigned integer (range: 0 - Value::maxUInt)
+ * - signed integer [range: Value::kMIN_INT - Value::kMAX_INT]
+ * - unsigned integer (range: 0 - Value::kMAX_UINT)
 * - double
 * - UTF-8 string
 * - boolean
@@ -116,16 +114,16 @@ operator!=(StaticString x, std::string const& y)
 * The type of the held value is represented by a #ValueType and
 * can be obtained using type().
 *
- * values of an #objectValue or #arrayValue can be accessed using operator[]()
- * methods. Non const methods will automatically create the a #nullValue element
+ * values of an ValueType::Object or ValueType::Array can be accessed using operator[]()
+ * methods. Non const methods will automatically create the a ValueType::Null element
 * if it does not exist.
- * The sequence of an #arrayValue will be automatically resize and initialized
- * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+ * The sequence of an ValueType::Array will be automatically resize and initialized
+ * with ValueType::Null. resize() can be used to enlarge or truncate an ValueType::Array.
 *
 * The get() methods can be used to obtain a default value in the case the
 * required element does not exist.
 *
- * It is possible to iterate over the list of a #objectValue values using
+ * It is possible to iterate over the list of a ValueType::Object values using
 * the getMemberNames() method.
 */
 class Value
@@ -143,15 +141,13 @@ public:
    static Value const kNULL;
    static constexpr Int kMIN_INT = std::numeric_limits<Int>::min();
    static constexpr Int kMAX_INT = std::numeric_limits<Int>::max();
-    static constexpr UInt kMAX_U_INT = std::numeric_limits<UInt>::max();
+    static constexpr UInt kMAX_UINT = std::numeric_limits<UInt>::max();

 private:
    class CZString
    {
    public:
-        // Stored as int field, implicit conversion
-        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-        enum DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy };
+        enum class DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy };

        CZString(int index);
        CZString(char const* cstr, DuplicationPolicy allocate);
@@ -182,19 +178,19 @@ public:
    /** \brief Create a default Value of the given type.

      This is a very useful constructor.
-      To create an empty array, pass arrayValue.
-      To create an empty object, pass objectValue.
+      To create an empty array, pass ValueType::Array.
+      To create an empty object, pass ValueType::Object.
      Another Value can then be set to this one by assignment.
    This is useful since clear() and resize() will not alter types.

           Examples:
    \code
    json::Value null_value; // null
-    json::Value arr_value(json::arrayValue); // []
-    json::Value obj_value(json::objectValue); // {}
+    json::Value arr_value(json::ValueType::Array); // []
+    json::Value obj_value(json::ValueType::Object); // {}
    \endcode
         */
-    Value(ValueType type = NullValue);
+    Value(ValueType type = ValueType::Null);
    Value(Int value);
    Value(UInt value);
    Value(double value);
@@ -290,7 +286,7 @@ public:
    operator bool() const;

    /// Remove all object members and array elements.
-    /// \pre type() is arrayValue, objectValue, or nullValue
+    /// \pre type() is ValueType::Array, ValueType::Object, or ValueType::Null
    /// \post type() is unchanged
    void
    clear();
@@ -367,7 +363,7 @@ public:
    ///
    /// Do nothing if it did not exist.
    /// \return the removed Value, or null.
-    /// \pre type() is objectValue or nullValue
+    /// \pre type() is ValueType::Object or ValueType::Null
    /// \post type() is unchanged
    Value
    removeMember(char const* key);
@@ -388,8 +384,8 @@ public:
    /// \brief Return a list of the member names.
    ///
    /// If null, return an empty list.
-    /// \pre type() is objectValue or nullValue
-    /// \post if type() was nullValue, it remains nullValue
+    /// \pre type() is ValueType::Object or ValueType::Null
+    /// \post if type() was ValueType::Null, it remains ValueType::Null
    [[nodiscard]] Members
    getMemberNames() const;

@@ -469,16 +465,14 @@ operator>=(Value const& x, Value const& y)
 * string value memory management done by Value.
 *
 * - makeMemberName() and releaseMemberName() are called to respectively
- * duplicate and free an json::objectValue member name.
+ * duplicate and free an json::ValueType::Object member name.
 * - duplicateStringValue() and releaseStringValue() are called similarly to
- *   duplicate and free a json::stringValue value.
+ *   duplicate and free a json::ValueType::String value.
 */
 class ValueAllocator
 {
 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { Unknown = (unsigned)-1 };
+    static constexpr auto kUNKNOWN = (unsigned)-1;

    virtual ~ValueAllocator() = default;

@@ -487,7 +481,7 @@ public:
    virtual void
    releaseMemberName(char* memberName) = 0;
    virtual char*
-    duplicateStringValue(char const* value, unsigned int length = Unknown) = 0;
+    duplicateStringValue(char const* value, unsigned int length = kUNKNOWN) = 0;
    virtual void
    releaseStringValue(char* value) = 0;
 };
@@ -523,12 +517,12 @@ public:
    [[nodiscard]] Value
    key() const;

-    /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+    /// Return the index of the referenced Value. -1 if it is not an ValueType::Array.
    [[nodiscard]] UInt
    index() const;

    /// Return the member name of the referenced Value. "" if it is not an
-    /// objectValue.
+    /// ValueType::Object.
    [[nodiscard]] char const*
    memberName() const;

--- a/include/xrpl/json/json_writer.h
+++ b/include/xrpl/json/json_writer.h
@@ -204,31 +204,31 @@ writeValue(Write const& write, Value const& value)
 {
    switch (value.type())
    {
-        case NullValue:
+        case ValueType::Null:
            write("null", 4);
            break;

-        case IntValue:
+        case ValueType::Int:
            writeString(write, valueToString(value.asInt()));
            break;

-        case UintValue:
+        case ValueType::UInt:
            writeString(write, valueToString(value.asUInt()));
            break;

-        case RealValue:
+        case ValueType::Real:
            writeString(write, valueToString(value.asDouble()));
            break;

-        case StringValue:
+        case ValueType::String:
            writeString(write, valueToQuotedString(value.asCString()));
            break;

-        case BooleanValue:
+        case ValueType::Boolean:
            writeString(write, valueToString(value.asBool()));
            break;

-        case ArrayValue: {
+        case ValueType::Array: {
            write("[", 1);
            int const size = value.size();
            for (int index = 0; index < size; ++index)
@@ -241,7 +241,7 @@ writeValue(Write const& write, Value const& value)
            break;
        }

-        case ObjectValue: {
+        case ValueType::Object: {
            Value::Members const members = value.getMemberNames();
            write("{", 1);
            for (auto it = members.begin(); it != members.end(); ++it)
--- a/include/xrpl/ledger/AmendmentTable.h
+++ b/include/xrpl/ledger/AmendmentTable.h
@@ -67,7 +67,7 @@ public:
    [[nodiscard]] virtual json::Value
    getJson(bool isAdmin) const = 0;

-    /** Returns a json::objectValue. */
+    /** Returns a json::ValueType::Object. */
    [[nodiscard]] virtual json::Value
    getJson(uint256 const& amendment, bool isAdmin) const = 0;

--- a/include/xrpl/ledger/helpers/CredentialHelpers.h
+++ b/include/xrpl/ledger/helpers/CredentialHelpers.h
@@ -19,14 +19,10 @@ namespace credentials {

 // Check if credential sfExpiration field has passed ledger's parentCloseTime
 bool
-checkExpired(std::shared_ptr<SLE const> const& sleCredential, NetClock::time_point const& closed);
-
-// Return true if any expired credential was found in arr (and deleted)
-bool
-removeExpired(ApplyView& view, STVector256 const& arr, beast::Journal const j);
+checkExpired(SLE const& sleCredential, NetClock::time_point const& closed);

 // Actually remove a credentials object from the ledger
-TER
+[[nodiscard]] TER
 deleteSLE(ApplyView& view, std::shared_ptr<SLE> const& sleCredential, beast::Journal j);

 // Amendment and parameters checks for sfCredentialIDs field
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -184,6 +184,7 @@ checkLoanGuards(

 LoanState
 computeTheoreticalLoanState(
+    Rules const& rules,
    Number const& periodicPayment,
    Number const& periodicRate,
    std::uint32_t const paymentRemaining,
@@ -353,6 +354,7 @@ struct LoanStateDeltas

 Expected<std::pair<LoanPaymentParts, LoanProperties>, TER>
 tryOverpayment(
+    Rules const& rules,
    Asset const& asset,
    std::int32_t loanScale,
    ExtendedPaymentComponents const& overpaymentComponents,
@@ -363,11 +365,17 @@ tryOverpayment(
    TenthBips16 const managementFeeRate,
    beast::Journal j);

-Number
-computeRaisedRate(Number const& periodicRate, std::uint32_t paymentsRemaining);
+[[nodiscard]] Number
+computePowerMinusOne(Number const& periodicRate, std::uint32_t paymentsRemaining);

-Number
-computePaymentFactor(Number const& periodicRate, std::uint32_t paymentsRemaining);
+[[nodiscard]] Number
+computePowerMinusOneHybrid(Number const& periodicRate, std::uint32_t paymentsRemaining);
+
+[[nodiscard]] Number
+computePaymentFactor(
+    Rules const& rules,
+    Number const& periodicRate,
+    std::uint32_t paymentsRemaining);

 std::pair<Number, Number>
 computeInterestAndFeeParts(
@@ -378,12 +386,14 @@ computeInterestAndFeeParts(

 Number
 loanPeriodicPayment(
+    Rules const& rules,
    Number const& principalOutstanding,
    Number const& periodicRate,
    std::uint32_t paymentsRemaining);

 Number
 loanPrincipalFromPeriodicPayment(
+    Rules const& rules,
    Number const& periodicPayment,
    Number const& periodicRate,
    std::uint32_t paymentsRemaining);
@@ -415,6 +425,7 @@ computeOverpaymentComponents(

 PaymentComponents
 computePaymentComponents(
+    Rules const& rules,
    Asset const& asset,
    std::int32_t scale,
    Number const& totalValueOutstanding,
@@ -438,6 +449,7 @@ operator+(LoanState const& lhs, detail::LoanStateDeltas const& rhs);

 LoanProperties
 computeLoanProperties(
+    Rules const& rules,
    Asset const& asset,
    Number const& principalOutstanding,
    TenthBips32 interestRate,
@@ -448,6 +460,7 @@ computeLoanProperties(

 LoanProperties
 computeLoanProperties(
+    Rules const& rules,
    Asset const& asset,
    Number const& principalOutstanding,
    Number const& periodicRate,
--- a/include/xrpl/nodestore/Types.h
+++ b/include/xrpl/nodestore/Types.h
@@ -6,20 +6,16 @@

 namespace xrpl::NodeStore {

-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum {
-    // This is only used to pre-allocate the array for
-    // batch objects and does not affect the amount written.
-    //
-    BatchWritePreallocationSize = 256,
+// This is only used to pre-allocate the array for
+// batch objects and does not affect the amount written.
+//
+static constexpr auto kBATCH_WRITE_PREALLOCATION_SIZE = 256;

-    // This sets a limit on the maximum number of writes
-    // in a batch. Actual usage can be twice this since
-    // we have a new batch growing as we write the old.
-    //
-    BatchWriteLimitSize = 65536
-};
+// This sets a limit on the maximum number of writes
+// in a batch. Actual usage can be twice this since
+// we have a new batch growing as we write the old.
+//
+static constexpr auto kBATCH_WRITE_LIMIT_SIZE = 65536;

 /** Return codes from Backend operations. */
 enum class Status {
--- a/include/xrpl/protocol/AccountID.h
+++ b/include/xrpl/protocol/AccountID.h
@@ -25,7 +25,7 @@ public:
 }  // namespace detail

 /** A 160-bit unsigned that uniquely identifies an account. */
-using AccountID = BaseUint<160, detail::AccountIDTag>;
+using AccountID = BaseUInt<160, detail::AccountIDTag>;

 /** Convert AccountID to base58 checked string */
 std::string
--- a/include/xrpl/protocol/ApiVersion.h
+++ b/include/xrpl/protocol/ApiVersion.h
@@ -61,7 +61,7 @@ setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled)
 {
    XRPL_ASSERT(apiVersion != kAPI_INVALID_VERSION, "xrpl::RPC::setVersion : input is valid");

-    auto& retObj = parent[jss::version] = json::ObjectValue;
+    auto& retObj = parent[jss::version] = json::ValueType::Object;

    if (apiVersion == kAPI_VERSION_IF_UNSPECIFIED)
    {
--- a/include/xrpl/protocol/PublicKey.h
+++ b/include/xrpl/protocol/PublicKey.h
@@ -267,10 +267,10 @@ getOrThrow(json::Value const& v, xrpl::SField const& field)
 {
    using namespace xrpl;
    std::string const b58 = getOrThrow<std::string>(v, field);
-    if (auto pubKeyBlob = strUnHex(b58); pubKeyBlob && publicKeyType(makeSlice(*pubKeyBlob)))
+    if (auto pubKeyBlob = strUnHex(b58);
+        pubKeyBlob.has_value() && publicKeyType(makeSlice(*pubKeyBlob)))
    {
-        return PublicKey{makeSlice(
-            *pubKeyBlob)};  // NOLINT(bugprone-unchecked-optional-access) checked in condition above
+        return PublicKey{makeSlice(*pubKeyBlob)};
    }
    for (auto const tokenType : {TokenType::NodePublic, TokenType::AccountPublic})
    {
--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -129,23 +129,20 @@ fieldCode(int id, int index)
 class SField
 {
 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        SMdNever = 0x00,
-        SMdChangeOrig = 0x01,     // original value when it changes
-        SMdChangeNew = 0x02,      // new value when it changes
-        SMdDeleteFinal = 0x04,    // final value when it is deleted
-        SMdCreate = 0x08,         // value when it's created
-        SMdAlways = 0x10,         // value when node containing it is affected at all
-        SMdBaseTen = 0x20,        // value is treated as base 10, overriding behavior
-        SMdPseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
-                                  // _only_, then it is a pseudo-account
-        SMdNeedsAsset = 0x80,     // This field needs to be associated with an
-                                  // asset before it is serialized as a ledger
-                                  // object. Intended for STNumber.
-        SMdDefault = SMdChangeOrig | SMdChangeNew | SMdDeleteFinal | SMdCreate
-    };
+    static constexpr auto kSMD_NEVER = 0x00;
+    static constexpr auto kSMD_CHANGE_ORIG = 0x01;   // original value when it changes
+    static constexpr auto kSMD_CHANGE_NEW = 0x02;    // new value when it changes
+    static constexpr auto kSMD_DELETE_FINAL = 0x04;  // final value when it is deleted
+    static constexpr auto kSMD_CREATE = 0x08;        // value when it's created
+    static constexpr auto kSMD_ALWAYS = 0x10;    // value when node containing it is affected at all
+    static constexpr auto kSMD_BASE_TEN = 0x20;  // value is treated as base 10, overriding behavior
+    static constexpr auto kSMD_PSEUDO_ACCOUNT = 0x40;  // if this field is set in an ACCOUNT_ROOT
+                                                       // _only_, then it is a pseudo-account
+    static constexpr auto kSMD_NEEDS_ASSET = 0x80;     // This field needs to be associated with an
+                                                       // asset before it is serialized as a ledger
+                                                       // object. Intended for STNumber.
+    static constexpr auto kSMD_DEFAULT =
+        kSMD_CHANGE_ORIG | kSMD_CHANGE_NEW | kSMD_DELETE_FINAL | kSMD_CREATE;

    enum class IsSigning : unsigned char { No, Yes };
    static IsSigning const kNOT_SIGNING = IsSigning::No;
@@ -175,7 +172,7 @@ public:
        SerializedTypeID tid,
        int fv,
        char const* fn,
-        int meta = SMdDefault,
+        int meta = kSMD_DEFAULT,
        IsSigning signing = IsSigning::Yes);
    explicit SField(PrivateAccessTagT, int fc, char const* fn);

--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -241,7 +241,7 @@ public:
    [[nodiscard]] std::string
    getText() const override;

-    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override;
+    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override;

    void
    add(Serializer& s) const override;
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -18,23 +18,23 @@ struct JsonOptions
    using underlying_t = unsigned int;
    underlying_t value;

-    // Bitwise flags with operator~
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum Values : underlying_t {
-        // clang-format off
-        KNone                       = 0b0000'0000,
-        KIncludeDate               = 0b0000'0001,
-        KDisableApiPriorV2       = 0b0000'0010,
+    enum class Values : underlying_t {
+        None = 0b0000'0000,
+        IncludeDate = 0b0000'0001,
+        DisableApiPriorV2 = 0b0000'0010,

-        // IMPORTANT `kALL` must be union of all of the above; see also operator~
-        KAll                        = 0b0000'0011
-        // clang-format on
+        // IMPORTANT `All` must be union of all of the above; see also operator~
+        All = IncludeDate | DisableApiPriorV2  // 0b0000'0011
    };

    constexpr JsonOptions(underlying_t v) noexcept : value(v)
    {
    }

+    constexpr JsonOptions(Values v) noexcept : value(static_cast<JsonOptions::underlying_t>(v))
+    {
+    }
+
    [[nodiscard]] constexpr explicit
    operator underlying_t() const noexcept
    {
@@ -69,18 +69,18 @@ struct JsonOptions
    [[nodiscard]] constexpr JsonOptions friend
    operator~(JsonOptions v) noexcept
    {
-        return {~v.value & static_cast<underlying_t>(KAll)};
+        return {~v.value & static_cast<underlying_t>(Values::All)};
    }
 };

 template <typename T>
    requires requires(T const& t) {
-        { t.getJson(JsonOptions::KNone) } -> std::convertible_to<json::Value>;
+        { t.getJson(JsonOptions::Values::None) } -> std::convertible_to<json::Value>;
    }
 json::Value
 toJson(T const& t)
 {
-    return t.getJson(JsonOptions::KNone);
+    return t.getJson(JsonOptions::Values::None);
 }

 namespace detail {
@@ -148,7 +148,7 @@ public:
    [[nodiscard]] virtual std::string
    getText() const;

-    [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::KNone) const;
+    [[nodiscard]] virtual json::Value getJson(JsonOptions = JsonOptions::Values::None) const;

    virtual void
    add(Serializer& s) const;
--- a/include/xrpl/protocol/STBitString.h
+++ b/include/xrpl/protocol/STBitString.h
@@ -16,7 +16,7 @@ class STBitString final : public STBase, public CountedObject<STBitString<Bits>>
    static_assert(Bits > 0, "Number of bits must be positive");

 public:
-    using value_type = BaseUint<Bits>;
+    using value_type = BaseUInt<Bits>;

 private:
    value_type value_{};
@@ -46,7 +46,7 @@ public:

    template <typename Tag>
    void
-    setValue(BaseUint<Bits, Tag> const& v);
+    setValue(BaseUInt<Bits, Tag> const& v);

    [[nodiscard]] value_type const&
    value() const;
@@ -157,7 +157,7 @@ STBitString<Bits>::add(Serializer& s) const
 template <int Bits>
 template <typename Tag>
 void
-STBitString<Bits>::setValue(BaseUint<Bits, Tag> const& v)
+STBitString<Bits>::setValue(BaseUInt<Bits, Tag> const& v)
 {
    value_ = v;
 }
--- a/include/xrpl/protocol/STLedgerEntry.h
+++ b/include/xrpl/protocol/STLedgerEntry.h
@@ -38,7 +38,7 @@ public:
    getText() const override;

    [[nodiscard]] json::Value
-    getJson(JsonOptions options = JsonOptions::KNone) const override;
+    getJson(JsonOptions options = JsonOptions::Values::None) const override;

    /** Returns the 'key' (or 'index') of this item.
        The key identifies this entry's position in
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -132,7 +132,7 @@ public:
    getText() const override;

    // TODO(tom): options should be an enum.
-    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::KNone) const override;
+    [[nodiscard]] json::Value getJson(JsonOptions = JsonOptions::Values::None) const override;

    void
    addWithoutSigningFields(Serializer& s) const;
@@ -381,7 +381,7 @@ public:

    template <class Tag>
    void
-    setFieldH160(SField const& field, BaseUint<160, Tag> const& v);
+    setFieldH160(SField const& field, BaseUInt<160, Tag> const& v);

    STObject&
    peekFieldObject(SField const& field);
@@ -1143,7 +1143,7 @@ STObject::at(OptionaledField<T> const& of) -> OptionalProxy<T>

 template <class Tag>
 void
-STObject::setFieldH160(SField const& field, BaseUint<160, Tag> const& v)
+STObject::setFieldH160(SField const& field, BaseUInt<160, Tag> const& v)
 {
    STBase* rf = getPField(field, true);

--- a/include/xrpl/protocol/STParsedJSON.h
+++ b/include/xrpl/protocol/STParsedJSON.h
@@ -6,6 +6,13 @@

 namespace xrpl {

+/** Maximum JSON object nesting depth permitted during parsing. */
+inline constexpr std::size_t kMAX_PARSED_JSON_DEPTH = 64;
+
+/** Maximum number of elements permitted in any JSON array field during parsing.
+    Requests exceeding this limit are rejected with an invalidParams error. */
+inline constexpr std::size_t kMAX_PARSED_JSON_ARRAY_SIZE = 512;
+
 /** Holds the serialized result of parsing an input JSON object.
    This does validation and checking on the provided JSON.
 */
--- a/include/xrpl/protocol/STValidation.h
+++ b/include/xrpl/protocol/STValidation.h
@@ -161,7 +161,7 @@ STValidation::STValidation(SerialIter& sit, LookupNodeID&& lookupNodeID, bool ch
    if (checkSignature && !isValid())
    {
        JLOG(debugLog().error()) << "Invalid signature in validation: "
-                                 << getJson(JsonOptions::KNone);
+                                 << getJson(JsonOptions::Values::None);
        Throw<std::runtime_error>("Invalid signature in validation");
    }

--- a/include/xrpl/protocol/Serializer.h
+++ b/include/xrpl/protocol/Serializer.h
@@ -102,7 +102,7 @@ public:

    template <std::size_t Bits, class Tag>
    int
-    addBitString(BaseUint<Bits, Tag> const& v)
+    addBitString(BaseUInt<Bits, Tag> const& v)
    {
        return addRaw(v.data(), v.size());
    }
@@ -151,7 +151,7 @@ public:

    template <std::size_t Bits, typename Tag = void>
    bool
-    getBitString(BaseUint<Bits, Tag>& data, int offset) const
+    getBitString(BaseUInt<Bits, Tag>& data, int offset) const
    {
        auto success = (offset + (Bits / 8)) <= data_.size();
        if (success)
@@ -369,7 +369,7 @@ public:
    geti64();

    template <std::size_t Bits, class Tag = void>
-    BaseUint<Bits, Tag>
+    BaseUInt<Bits, Tag>
    getBitString();

    uint128
@@ -428,7 +428,7 @@ public:
 };

 template <std::size_t Bits, class Tag>
-BaseUint<Bits, Tag>
+BaseUInt<Bits, Tag>
 SerialIter::getBitString()
 {
    auto const n = Bits / 8;
@@ -442,7 +442,7 @@ SerialIter::getBitString()
    used_ += n;
    remain_ -= n;

-    return BaseUint<Bits, Tag>::fromVoid(x);
+    return BaseUInt<Bits, Tag>::fromVoid(x);
 }

 }  // namespace xrpl
--- a/include/xrpl/protocol/UintTypes.h
+++ b/include/xrpl/protocol/UintTypes.h
@@ -30,21 +30,21 @@ public:

 /** Directory is an index into the directory of offer books.
    The last 64 bits of this are the quality. */
-using Directory = BaseUint<256, detail::DirectoryTag>;
+using Directory = BaseUInt<256, detail::DirectoryTag>;

 /** Currency is a hash representing a specific currency. */
-using Currency = BaseUint<160, detail::CurrencyTag>;
+using Currency = BaseUInt<160, detail::CurrencyTag>;

 /** NodeID is a 160-bit hash representing one node. */
-using NodeID = BaseUint<160, detail::NodeIDTag>;
+using NodeID = BaseUInt<160, detail::NodeIDTag>;

 /** MPTID is a 192-bit value representing MPT Issuance ID,
 * which is a concatenation of a 32-bit sequence (big endian)
 * and a 160-bit account */
-using MPTID = BaseUint<192>;
+using MPTID = BaseUInt<192>;

 /** Domain is a 256-bit hash representing a specific domain. */
-using Domain = BaseUint<256>;
+using Domain = BaseUInt<256>;

 /** XRP currency. */
 Currency const&
--- a/include/xrpl/protocol/detail/features.macro
+++ b/include/xrpl/protocol/detail/features.macro
@@ -16,11 +16,10 @@
 // Keep it sorted in reverse chronological order.

 XRPL_FEATURE(Sponsor,                     Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FIX    (Cleanup3_2_0,                Supported::No, VoteBehavior::DefaultNo)
-XRPL_FEATURE(MPTokensV2,                  Supported::No, VoteBehavior::DefaultNo)
-XRPL_FIX    (Security3_1_3,               Supported::No, VoteBehavior::DefaultNo)
-XRPL_FIX    (PermissionedDomainInvariant, Supported::Yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (BatchInnerSigs,              Supported::No, VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_2_0,                Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(MPTokensV2,                  Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_1_3,                Supported::Yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (BatchInnerSigs,              Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocol,             Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegationV1_1,    Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DirectoryLimit,              Supported::Yes, VoteBehavior::DefaultNo)
@@ -35,7 +34,7 @@ XRPL_FIX    (EnforceNFTokenTrustlineV2,   Supported::Yes, VoteBehavior::DefaultN
 XRPL_FIX    (AMMv1_3,                     Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionedDEX,             Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Batch,                       Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(SingleAssetVault,            Supported::Yes,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(SingleAssetVault,            Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (PayChanCancelAfter,          Supported::Yes, VoteBehavior::DefaultNo)
 // Check flags in Credential transactions
 XRPL_FIX    (InvalidTxFlags,             Supported::Yes, VoteBehavior::DefaultNo)
@@ -47,9 +46,6 @@ XRPL_FEATURE(Credentials,                Supported::Yes, VoteBehavior::DefaultNo
 XRPL_FEATURE(AMMClawback,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (AMMv1_2,                    Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV1,                 Supported::Yes, VoteBehavior::DefaultNo)
-// InvariantsV1_1 will be changes to Supported::yes when all the
-// invariants expected to be included under it are complete.
-XRPL_FEATURE(InvariantsV1_1,             Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (NFTokenPageLinks,           Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (InnerObjTemplate2,          Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (EnforceNFTokenTrustline,    Supported::Yes, VoteBehavior::DefaultNo)
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -27,7 +27,7 @@ TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
 TYPED_SFIELD(sfWithdrawalPolicy,         UINT8,     20)

 // 16-bit integers (common)
-TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::SMdNever)
+TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::kSMD_NEVER)
 TYPED_SFIELD(sfTransactionType,          UINT16,     2)
 TYPED_SFIELD(sfSignerWeight,             UINT16,     3)
 TYPED_SFIELD(sfTransferFee,              UINT16,     4)
@@ -48,7 +48,7 @@ TYPED_SFIELD(sfNetworkID,                UINT32,     1)
 TYPED_SFIELD(sfFlags,                    UINT32,     2)
 TYPED_SFIELD(sfSourceTag,                UINT32,     3)
 TYPED_SFIELD(sfSequence,                 UINT32,     4)
-TYPED_SFIELD(sfPreviousTxnLgrSeq,        UINT32,     5, SField::SMdDeleteFinal)
+TYPED_SFIELD(sfPreviousTxnLgrSeq,        UINT32,     5, SField::kSMD_DELETE_FINAL)
 TYPED_SFIELD(sfLedgerSequence,           UINT32,     6)
 TYPED_SFIELD(sfCloseTime,                UINT32,     7)
 TYPED_SFIELD(sfParentCloseTime,          UINT32,     8)
@@ -143,12 +143,12 @@ TYPED_SFIELD(sfXChainClaimID,            UINT64,    20)
 TYPED_SFIELD(sfXChainAccountCreateCount, UINT64,    21)
 TYPED_SFIELD(sfXChainAccountClaimCount,  UINT64,    22)
 TYPED_SFIELD(sfAssetPrice,               UINT64,    23)
-TYPED_SFIELD(sfMaximumAmount,            UINT64,    24, SField::SMdBaseTen|SField::SMdDefault)
-TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::SMdBaseTen|SField::SMdDefault)
-TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::SMdBaseTen|SField::SMdDefault)
+TYPED_SFIELD(sfMaximumAmount,            UINT64,    24, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfOutstandingAmount,        UINT64,    25, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfMPTAmount,                UINT64,    26, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfIssuerNode,               UINT64,    27)
 TYPED_SFIELD(sfSubjectNode,              UINT64,    28)
-TYPED_SFIELD(sfLockedAmount,             UINT64,    29, SField::SMdBaseTen|SField::SMdDefault)
+TYPED_SFIELD(sfLockedAmount,             UINT64,    29, SField::kSMD_BASE_TEN|SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfVaultNode,                UINT64,    30)
 TYPED_SFIELD(sfLoanBrokerNode,           UINT64,    31)
 TYPED_SFIELD(sfSponseeNode,              UINT64,    32)
@@ -173,17 +173,17 @@ TYPED_SFIELD(sfLedgerHash,               UINT256,    1)
 TYPED_SFIELD(sfParentHash,               UINT256,    2)
 TYPED_SFIELD(sfTransactionHash,          UINT256,    3)
 TYPED_SFIELD(sfAccountHash,              UINT256,    4)
-TYPED_SFIELD(sfPreviousTxnID,            UINT256,    5, SField::SMdDeleteFinal)
+TYPED_SFIELD(sfPreviousTxnID,            UINT256,    5, SField::kSMD_DELETE_FINAL)
 TYPED_SFIELD(sfLedgerIndex,              UINT256,    6)
 TYPED_SFIELD(sfWalletLocator,            UINT256,    7)
-TYPED_SFIELD(sfRootIndex,                UINT256,    8, SField::SMdAlways)
+TYPED_SFIELD(sfRootIndex,                UINT256,    8, SField::kSMD_ALWAYS)
 TYPED_SFIELD(sfAccountTxnID,             UINT256,    9)
 TYPED_SFIELD(sfNFTokenID,                UINT256,   10)
 TYPED_SFIELD(sfEmitParentTxnID,          UINT256,   11)
 TYPED_SFIELD(sfEmitNonce,                UINT256,   12)
 TYPED_SFIELD(sfEmitHookHash,             UINT256,   13)
 TYPED_SFIELD(sfAMMID,                    UINT256,   14,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)

 // 256-bit (uncommon)
 TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
@@ -206,31 +206,31 @@ TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
 TYPED_SFIELD(sfVaultID,                  UINT256,   35,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfParentBatchID,            UINT256,   36)
 TYPED_SFIELD(sfLoanBrokerID,             UINT256,   37,
-    SField::SMdPseudoAccount | SField::SMdDefault)
+    SField::kSMD_PSEUDO_ACCOUNT | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfLoanID,                   UINT256,   38)
 TYPED_SFIELD(sfObjectID,                 UINT256,   39)

 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::SMdNeedsAsset | SField::SMdDefault)
-TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
+TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfLoanOriginationFee,       NUMBER,     9)
 TYPED_SFIELD(sfLoanServiceFee,           NUMBER,     10)
 TYPED_SFIELD(sfLatePaymentFee,           NUMBER,     11)
 TYPED_SFIELD(sfClosePaymentFee,          NUMBER,     12)
-TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
-TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
-TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::SMdNeedsAsset | SField::SMdDefault)
+TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSMD_NEEDS_ASSET | SField::kSMD_DEFAULT)

 // int32
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
@@ -278,9 +278,9 @@ TYPED_SFIELD(sfMaxFee,                   AMOUNT,    33)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
 TYPED_SFIELD(sfMessageKey,               VL,         2)
 TYPED_SFIELD(sfSigningPubKey,            VL,         3)
-TYPED_SFIELD(sfTxnSignature,             VL,         4, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfTxnSignature,             VL,         4, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfURI,                      VL,         5)
-TYPED_SFIELD(sfSignature,                VL,         6, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfSignature,                VL,         6, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfDomain,                   VL,         7)
 TYPED_SFIELD(sfFundCode,                 VL,         8)
 TYPED_SFIELD(sfRemoveCode,               VL,         9)
@@ -293,7 +293,7 @@ TYPED_SFIELD(sfMemoFormat,               VL,        14)
 // variable length (uncommon)
 TYPED_SFIELD(sfFulfillment,              VL,        16)
 TYPED_SFIELD(sfCondition,                VL,        17)
-TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::SMdDefault, SField::kNOT_SIGNING)
+TYPED_SFIELD(sfMasterSignature,          VL,        18, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 TYPED_SFIELD(sfUNLModifyValidator,       VL,        19)
 TYPED_SFIELD(sfValidatorToDisable,       VL,        20)
 TYPED_SFIELD(sfValidatorToReEnable,      VL,        21)
@@ -340,7 +340,7 @@ TYPED_SFIELD(sfCounterpartySponsor,      ACCOUNT,   30)
 TYPED_SFIELD(sfSponsee,                  ACCOUNT,   31)

 // vector of 256-bit
-TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::SMdNever)
+TYPED_SFIELD(sfIndexes,                  VECTOR256,  1, SField::kSMD_NEVER)
 TYPED_SFIELD(sfHashes,                   VECTOR256,  2)
 TYPED_SFIELD(sfAmendments,               VECTOR256,  3)
 TYPED_SFIELD(sfNFTokenOffers,            VECTOR256,  4)
@@ -401,14 +401,14 @@ UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
 UNTYPED_SFIELD(sfRawTransaction,         OBJECT,    34)
 UNTYPED_SFIELD(sfBatchSigner,            OBJECT,    35)
 UNTYPED_SFIELD(sfBook,                   OBJECT,    36)
-UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    37, SField::SMdDefault, SField::kNOT_SIGNING)
-UNTYPED_SFIELD(sfSponsorSignature,       OBJECT,    38, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfCounterpartySignature,  OBJECT,    37, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfSponsorSignature,       OBJECT,    38, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)

 // array of objects (common)
 // ARRAY/1 is reserved for end of array
 // sfSigningAccounts has never been used.
 //UNTYPED_SFIELD(sfSigningAccounts,        ARRAY,      2)
-UNTYPED_SFIELD(sfSigners,                ARRAY,      3, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfSigners,                ARRAY,      3, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
 UNTYPED_SFIELD(sfSignerEntries,          ARRAY,      4)
 UNTYPED_SFIELD(sfTemplate,               ARRAY,      5)
 UNTYPED_SFIELD(sfNecessary,              ARRAY,      6)
@@ -436,4 +436,4 @@ UNTYPED_SFIELD(sfUnauthorizeCredentials, ARRAY,     27)
 UNTYPED_SFIELD(sfAcceptedCredentials,    ARRAY,     28)
 UNTYPED_SFIELD(sfPermissions,            ARRAY,     29)
 UNTYPED_SFIELD(sfRawTransactions,        ARRAY,     30)
-UNTYPED_SFIELD(sfBatchSigners,           ARRAY,     31, SField::SMdDefault, SField::kNOT_SIGNING)
+UNTYPED_SFIELD(sfBatchSigners,           ARRAY,     31, SField::kSMD_DEFAULT, SField::kNOT_SIGNING)
--- a/include/xrpl/resource/detail/Entry.h
+++ b/include/xrpl/resource/detail/Entry.h
@@ -67,7 +67,7 @@ struct Entry : public beast::List<Entry>::Node
    int refcount;

    // Exponentially decaying balance of resource consumption
-    DecayingSample<DecayWindowSeconds, clock_type> local_balance;
+    DecayingSample<kDECAY_WINDOW_SECONDS, clock_type> local_balance;

    // Normalized balance contribution from imports
    int remote_balance;
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -180,16 +180,16 @@ public:
    json::Value
    getJson()
    {
-        return getJson(WarningThreshold);
+        return getJson(kWARNING_THRESHOLD);
    }

-    /** Returns a json::objectValue. */
+    /** Returns a json::ValueType::Object. */
    json::Value
    getJson(int threshold)
    {
        clock_type::time_point const now(clock_.now());

-        json::Value ret(json::ObjectValue);
+        json::Value ret(json::ValueType::Object);
        std::scoped_lock const _(lock_);

        for (auto& inboundEntry : inbound_)
@@ -197,7 +197,7 @@ public:
            int const localBalance = inboundEntry.local_balance.value(now);
            if ((localBalance + inboundEntry.remote_balance) >= threshold)
            {
-                json::Value& entry = (ret[inboundEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[inboundEntry.toString()] = json::ValueType::Object);
                entry[jss::local] = localBalance;
                entry[jss::remote] = inboundEntry.remote_balance;
                entry[jss::type] = "inbound";
@@ -208,7 +208,7 @@ public:
            int const localBalance = outboundEntry.local_balance.value(now);
            if ((localBalance + outboundEntry.remote_balance) >= threshold)
            {
-                json::Value& entry = (ret[outboundEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[outboundEntry.toString()] = json::ValueType::Object);
                entry[jss::local] = localBalance;
                entry[jss::remote] = outboundEntry.remote_balance;
                entry[jss::type] = "outbound";
@@ -219,7 +219,7 @@ public:
            int const localBalance = adminEntry.local_balance.value(now);
            if ((localBalance + adminEntry.remote_balance) >= threshold)
            {
-                json::Value& entry = (ret[adminEntry.toString()] = json::ObjectValue);
+                json::Value& entry = (ret[adminEntry.toString()] = json::ValueType::Object);
                entry[jss::local] = localBalance;
                entry[jss::remote] = adminEntry.remote_balance;
                entry[jss::type] = "admin";
@@ -243,7 +243,7 @@ public:
        {
            Gossip::Item item;
            item.balance = inboundEntry.local_balance.value(now);
-            if (item.balance >= MinimumGossipBalance)
+            if (item.balance >= kMINIMUM_GOSSIP_BALANCE)
            {
                item.address = inboundEntry.key->address;
                gossip.items.push_back(item);
@@ -363,10 +363,10 @@ public:
    static Disposition
    disposition(int balance)
    {
-        if (balance >= DropThreshold)
+        if (balance >= kDROP_THRESHOLD)
            return Disposition::Drop;

-        if (balance >= WarningThreshold)
+        if (balance >= kWARNING_THRESHOLD)
            return Disposition::Warn;

        return Disposition::Ok;
@@ -461,7 +461,7 @@ public:
        std::scoped_lock const _(lock_);
        bool notify(false);
        auto const elapsed = clock_.now();
-        if (entry.balance(clock_.now()) >= WarningThreshold && elapsed != entry.lastWarningTime)
+        if (entry.balance(clock_.now()) >= kWARNING_THRESHOLD && elapsed != entry.lastWarningTime)
        {
            charge(entry, kFEE_WARNING);
            notify = true;
@@ -485,10 +485,10 @@ public:
        bool drop(false);
        clock_type::time_point const now(clock_.now());
        int const balance(entry.balance(now));
-        if (balance >= DropThreshold)
+        if (balance >= kDROP_THRESHOLD)
        {
            JLOG(journal_.warn()) << "Consumer entry " << entry << " dropped with balance "
-                                  << balance << " at or above drop threshold " << DropThreshold;
+                                  << balance << " at or above drop threshold " << kDROP_THRESHOLD;

            // Adding feeDrop at this point keeps the dropped connection
            // from re-connecting for at least a little while after it is
--- a/include/xrpl/resource/detail/Tuning.h
+++ b/include/xrpl/resource/detail/Tuning.h
@@ -5,30 +5,23 @@
 namespace xrpl::Resource {

 /** Tunable constants. */
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum {
-    // Balance at which a warning is issued
-    WarningThreshold = 5000

-    // Balance at which the consumer is disconnected
-    ,
-    DropThreshold = 25000
+// balance at which a warning is issued
+static constexpr auto kWARNING_THRESHOLD = 5000;

-    // The number of seconds in the exponential decay window
-    // (This should be a power of two)
-    ,
-    DecayWindowSeconds = 32
+// balance at which the consumer is disconnected
+static constexpr auto kDROP_THRESHOLD = 25000;

-    // The minimum balance required in order to include a load source in gossip
-    ,
-    MinimumGossipBalance = 1000
-};
+// seconds in exponential decay window (power of two)
+static constexpr auto kDECAY_WINDOW_SECONDS = 32;
+
+// minimum balance to include a load source in gossip
+static constexpr auto kMINIMUM_GOSSIP_BALANCE = 1000;

 // The number of seconds until an inactive table item is removed
-std::chrono::seconds constexpr kSECONDS_UNTIL_EXPIRATION{300};
+static constexpr std::chrono::seconds kSECONDS_UNTIL_EXPIRATION{300};

 // Number of seconds until imported gossip expires
-std::chrono::seconds constexpr kGOSSIP_EXPIRATION_SECONDS{30};
+static constexpr std::chrono::seconds kGOSSIP_EXPIRATION_SECONDS{30};

 }  // namespace xrpl::Resource
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -30,7 +30,7 @@ namespace xrpl {

 /** Represents an active connection. */
 template <class Handler, class Impl>
-class BaseHTTPPeer : public IoList::Work, public Session
+class BaseHTTPPeer : public IOList::Work, public Session
 {
 protected:
    using clock_type = std::chrono::system_clock;
@@ -38,16 +38,9 @@ protected:
    using endpoint_type = boost::asio::ip::tcp::endpoint;
    using yield_context = boost::asio::yield_context;

-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum {
-        // Size of our read/write buffer
-        BufferSize = 4 * 1024,
-
-        // Max seconds without completing a message
-        TimeoutSeconds = 30,
-        TimeoutSecondsLocal = 3  // used for localhost clients
-    };
+    static constexpr auto kBUFFER_SIZE = 4 * 1024;     // size of read/write buffer
+    static constexpr auto kTIMEOUT_SECONDS = 30;       // max seconds without completing a message
+    static constexpr auto kTIMEOUT_SECONDS_LOCAL = 3;  // used for localhost clients

    struct Buffer
    {
@@ -252,7 +245,8 @@ BaseHTTPPeer<Handler, Impl>::startTimer()
    boost::beast::get_lowest_layer(impl().stream_)
        .expires_after(
            std::chrono::seconds(
-                remote_address_.address().is_loopback() ? TimeoutSecondsLocal : TimeoutSeconds));
+                remote_address_.address().is_loopback() ? kTIMEOUT_SECONDS_LOCAL
+                                                        : kTIMEOUT_SECONDS));
 }

 // Convenience for discarding the error code
@@ -364,7 +358,7 @@ BaseHTTPPeer<Handler, Impl>::doWriter(

    for (;;)
    {
-        if (!writer->prepare(BufferSize, resume))
+        if (!writer->prepare(kBUFFER_SIZE, resume))
            return;
        error_code ec;
        auto const bytesTransferred = boost::asio::async_write(
--- a/include/xrpl/server/detail/BasePeer.h
+++ b/include/xrpl/server/detail/BasePeer.h
@@ -17,7 +17,7 @@ namespace xrpl {

 // Common part of all peers
 template <class Handler, class Impl>
-class BasePeer : public IoList::Work
+class BasePeer : public IOList::Work
 {
 protected:
    using clock_type = std::chrono::system_clock;
--- a/include/xrpl/server/detail/Door.h
+++ b/include/xrpl/server/detail/Door.h
@@ -39,7 +39,7 @@ namespace xrpl {

 /** A listening socket. */
 template <class Handler>
-class Door : public IoList::Work, public std::enable_shared_from_this<Door<Handler>>
+class Door : public IOList::Work, public std::enable_shared_from_this<Door<Handler>>
 {
 private:
    using clock_type = std::chrono::steady_clock;
@@ -53,7 +53,7 @@ private:
    using stream_type = boost::beast::tcp_stream;

    // Detects SSL on a socket
-    class Detector : public IoList::Work, public std::enable_shared_from_this<Detector>
+    class Detector : public IOList::Work, public std::enable_shared_from_this<Detector>
    {
    private:
        Port const& port_;
--- a/include/xrpl/server/detail/ServerImpl.h
+++ b/include/xrpl/server/detail/ServerImpl.h
@@ -62,9 +62,7 @@ class ServerImpl : public Server
 private:
    using clock_type = std::chrono::system_clock;

-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { HistorySize = 100 };
+    static constexpr auto kHISTORY_SIZE = 100;

    Handler& handler_;
    beast::Journal const j_;
@@ -78,7 +76,7 @@ private:
    int high_ = 0;
    std::array<std::size_t, 64> hist_{};

-    IoList ios_;
+    IOList ios_;

 public:
    ServerImpl(Handler& handler, boost::asio::io_context& ioContext, beast::Journal journal);
@@ -97,7 +95,7 @@ public:
    void
    close() override;

-    IoList&
+    IOList&
    ios()
    {
        return ios_;
--- a/include/xrpl/server/detail/io_list.h
+++ b/include/xrpl/server/detail/io_list.h
@@ -12,7 +12,7 @@
 namespace xrpl {

 /** Manages a set of objects performing asynchronous I/O. */
-class IoList final
+class IOList final
 {
 public:
    class Work
@@ -21,8 +21,8 @@ public:
        void
        destroy();

-        friend class IoList;
-        IoList* ios_ = nullptr;
+        friend class IOList;
+        IOList* ios_ = nullptr;

    public:
        virtual ~Work()
@@ -30,13 +30,13 @@ public:
            destroy();
        }

-        /** Return the IoList associated with the work.
+        /** Return the IOList associated with the work.

            Requirements:
-                The call to IoList::emplace to
+                The call to IOList::emplace to
                create the work has already returned.
        */
-        IoList&
+        IOList&
        ios()
        {
            return *ios_;
@@ -59,17 +59,17 @@ private:
    std::function<void(void)> f_;

 public:
-    IoList() = default;
+    IOList() = default;

    /** Destroy the list.

        Effects:
-            Closes the IoList if it was not previously
+            Closes the IOList if it was not previously
                closed. No finisher is invoked in this case.

            Blocks until all work is destroyed.
    */
-    ~IoList()
+    ~IOList()
    {
        destroy();
    }
@@ -159,7 +159,7 @@ public:

 template <class>
 void
-IoList::Work::destroy()
+IOList::Work::destroy()
 {
    if (!ios_)
        return;
@@ -179,7 +179,7 @@ IoList::Work::destroy()

 template <class>
 void
-IoList::destroy()
+IOList::destroy()
 {
    close();
    join();
@@ -187,9 +187,9 @@ IoList::destroy()

 template <class T, class... Args>
 std::shared_ptr<T>
-IoList::emplace(Args&&... args)
+IOList::emplace(Args&&... args)
 {
-    static_assert(std::is_base_of_v<Work, T>, "T must derive from IoList::Work");
+    static_assert(std::is_base_of_v<Work, T>, "T must derive from IOList::Work");
    if (closed_)
        return nullptr;
    auto sp = std::make_shared<T>(std::forward<Args>(args)...);
@@ -211,7 +211,7 @@ IoList::emplace(Args&&... args)

 template <class Finisher>
 void
-IoList::close(Finisher&& f)
+IOList::close(Finisher&& f)
 {
    std::unique_lock<std::mutex> lock(m_);
    if (closed_)
@@ -237,7 +237,7 @@ IoList::close(Finisher&& f)

 template <class>
 void
-IoList::join()
+IOList::join()
 {
    std::unique_lock<std::mutex> lock(m_);
    cv_.wait(lock, [&] { return closed_ && n_ == 0; });
--- a/include/xrpl/shamap/FullBelowCache.h
+++ b/include/xrpl/shamap/FullBelowCache.h
@@ -22,9 +22,7 @@ private:
    using CacheType = KeyCache;

 public:
-    // Need to be named before converting
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum { DefaultCacheTargetSize = 0 };
+    static constexpr auto kDEFAULT_CACHE_TARGET_SIZE = 0;

    using key_type = uint256;
    using clock_type = typename CacheType::clock_type;
@@ -41,7 +39,7 @@ public:
        clock_type& clock,
        beast::Journal j,
        beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make(),
-        std::size_t targetSize = DefaultCacheTargetSize,
+        std::size_t targetSize = kDEFAULT_CACHE_TARGET_SIZE,
        std::chrono::seconds expiration = std::chrono::minutes{2})
        : cache_(name, targetSize, expiration, clock, j, collector), gen_(1)
    {
--- a/include/xrpl/shamap/SHAMap.h
+++ b/include/xrpl/shamap/SHAMap.h
@@ -624,7 +624,7 @@ private:

 inline SHAMap::ConstIterator::ConstIterator(SHAMap const* map) : map_(map)
 {
-    XRPL_ASSERT(map_, "xrpl::SHAMap::const_iterator::const_iterator : non-null input");
+    XRPL_ASSERT(map_, "xrpl::SHAMap::ConstIterator::ConstIterator : non-null input");

    if (auto temp = map_->peekFirstItem(stack_))
        item_ = temp->peekItem().get();
--- a/include/xrpl/shamap/SHAMapItem.h
+++ b/include/xrpl/shamap/SHAMapItem.h
@@ -139,7 +139,7 @@ inline boost::intrusive_ptr<SHAMapItem>
 makeShamapitem(uint256 const& tag, Slice data)
 {
    XRPL_ASSERT(
-        data.size() <= megabytes<std::size_t>(16), "xrpl::make_shamapitem : maximum input size");
+        data.size() <= megabytes<std::size_t>(16), "xrpl::makeShamapitem : maximum input size");

    // NOLINTNEXTLINE(misc-const-correctness)
    std::uint8_t* raw = detail::gSlabber.allocate(data.size());
--- a/include/xrpl/shamap/SHAMapTreeNode.h
+++ b/include/xrpl/shamap/SHAMapTreeNode.h
@@ -7,6 +7,7 @@
 #include <xrpl/shamap/SHAMapItem.h>
 #include <xrpl/shamap/SHAMapNodeID.h>

+#include <cstddef>
 #include <cstdint>
 #include <string>

@@ -20,6 +21,9 @@ static constexpr unsigned char const kWIRE_TYPE_INNER = 2;
 static constexpr unsigned char const kWIRE_TYPE_COMPRESSED_INNER = 3;
 static constexpr unsigned char const kWIRE_TYPE_TRANSACTION_WITH_META = 4;

+// Lower bound on SHAMap leaf item payload size, in bytes.
+inline constexpr std::size_t kMIN_SHA_MAP_ITEM_BYTES = 12;
+
 enum class SHAMapNodeType {
    TnInner = 1,
    TnTransactionNm = 2,  // transaction, no metadata
--- a/include/xrpl/tx/Transactor.h
+++ b/include/xrpl/tx/Transactor.h
@@ -138,9 +138,8 @@ public:
    Transactor(Transactor const&) = delete;
    Transactor&
    operator=(Transactor const&) = delete;
-    // 68 transactor subclass files
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum ConsequencesFactoryType { Normal, Blocker, Custom };
+
+    enum class ConsequencesFactoryType { Normal, Blocker, Custom };

    /** Process the transaction. */
    ApplyResult
--- a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
+++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
@@ -25,7 +25,7 @@ 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.
 */

-// Bitwise flags, 86 files
+// Bitwise flags, 86 files, used in macros files
 // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Privilege {
    NoPriv = 0x0000,              // The transaction can not do any of the enumerated operations
--- a/include/xrpl/tx/invariants/PermissionedDEXInvariant.h
+++ b/include/xrpl/tx/invariants/PermissionedDEXInvariant.h
@@ -11,8 +11,8 @@ namespace xrpl {
 class ValidPermissionedDEX
 {
    bool regularOffers_ = false;
-    bool badHybridsOld_ = false;  // pre-fixSecurity3_1_3: missing field/domain or size > 1
-    bool badHybrids_ = false;     // post-fixSecurity3_1_3: also catches size == 0 (size != 1)
+    bool badHybridsOld_ = false;  // pre-fixCleanup3_1_3: missing field/domain or size > 1
+    bool badHybrids_ = false;     // post-fixCleanup3_1_3: also catches size == 0 (size != 1)
    hash_set<uint256> domains_;

 public:
--- a/include/xrpl/tx/transactors/account/AccountDelete.h
+++ b/include/xrpl/tx/transactors/account/AccountDelete.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class AccountDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit AccountDelete(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/account/AccountSet.h
+++ b/include/xrpl/tx/transactors/account/AccountSet.h
@@ -8,7 +8,7 @@ namespace xrpl {
 class AccountSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;

    explicit AccountSet(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/account/SetRegularKey.h
+++ b/include/xrpl/tx/transactors/account/SetRegularKey.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class SetRegularKey : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit SetRegularKey(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/account/SignerListSet.h
+++ b/include/xrpl/tx/transactors/account/SignerListSet.h
@@ -24,7 +24,7 @@ private:
    std::vector<SignerEntries::SignerEntry> signers_;

 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit SignerListSet(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/bridge/XChainBridge.h
+++ b/include/xrpl/tx/transactors/bridge/XChainBridge.h
@@ -12,7 +12,7 @@ constexpr size_t kXBRIDGE_MAX_ACCOUNT_CREATE_CLAIMS = 128;
 class XChainCreateBridge : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit XChainCreateBridge(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -45,7 +45,7 @@ public:
 class BridgeModify : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit BridgeModify(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -95,7 +95,7 @@ class XChainClaim : public Transactor
 {
 public:
    // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit XChainClaim(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -133,7 +133,7 @@ public:
 class XChainCommit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;

    static TxConsequences
    makeTxConsequences(PreflightContext const& ctx);
@@ -179,7 +179,7 @@ public:
 class XChainCreateClaimID : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit XChainCreateClaimID(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -222,7 +222,7 @@ class XChainAddClaimAttestation : public Transactor
 {
 public:
    // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit XChainAddClaimAttestation(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -256,7 +256,7 @@ class XChainAddAccountCreateAttestation : public Transactor
 {
 public:
    // Blocker since we cannot accurately calculate the consequences
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Blocker};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Blocker;

    explicit XChainAddAccountCreateAttestation(ApplyContext& ctx) : Transactor(ctx)
    {
@@ -314,7 +314,7 @@ public:
 class XChainCreateAccountCommit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit XChainCreateAccountCommit(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/check/CheckCancel.h
+++ b/include/xrpl/tx/transactors/check/CheckCancel.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CheckCancel(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/check/CheckCash.h
+++ b/include/xrpl/tx/transactors/check/CheckCash.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCash : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CheckCash(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/check/CheckCreate.h
+++ b/include/xrpl/tx/transactors/check/CheckCreate.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CheckCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CheckCreate(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/credentials/CredentialAccept.h
+++ b/include/xrpl/tx/transactors/credentials/CredentialAccept.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialAccept : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CredentialAccept(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/credentials/CredentialCreate.h
+++ b/include/xrpl/tx/transactors/credentials/CredentialCreate.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CredentialCreate(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/credentials/CredentialDelete.h
+++ b/include/xrpl/tx/transactors/credentials/CredentialDelete.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class CredentialDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit CredentialDelete(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/delegate/DelegateSet.h
+++ b/include/xrpl/tx/transactors/delegate/DelegateSet.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class DelegateSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit DelegateSet(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMBid.h
+++ b/include/xrpl/tx/transactors/dex/AMMBid.h
@@ -45,7 +45,7 @@ namespace xrpl {
 class AMMBid : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMBid(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMClawback.h
+++ b/include/xrpl/tx/transactors/dex/AMMClawback.h
@@ -7,7 +7,7 @@ class Sandbox;
 class AMMClawback : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMClawback(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMCreate.h
+++ b/include/xrpl/tx/transactors/dex/AMMCreate.h
@@ -37,7 +37,7 @@ namespace xrpl {
 class AMMCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMCreate(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMDelete.h
+++ b/include/xrpl/tx/transactors/dex/AMMDelete.h
@@ -13,7 +13,7 @@ namespace xrpl {
 class AMMDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMDelete(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMDeposit.h
+++ b/include/xrpl/tx/transactors/dex/AMMDeposit.h
@@ -42,7 +42,7 @@ class Sandbox;
 class AMMDeposit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMDeposit(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMVote.h
+++ b/include/xrpl/tx/transactors/dex/AMMVote.h
@@ -30,7 +30,7 @@ namespace xrpl {
 class AMMVote : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMVote(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/AMMWithdraw.h
+++ b/include/xrpl/tx/transactors/dex/AMMWithdraw.h
@@ -50,7 +50,7 @@ enum class WithdrawAll : bool { No = false, Yes };
 class AMMWithdraw : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit AMMWithdraw(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/OfferCancel.h
+++ b/include/xrpl/tx/transactors/dex/OfferCancel.h
@@ -8,7 +8,7 @@ namespace xrpl {
 class OfferCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit OfferCancel(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/dex/OfferCreate.h
+++ b/include/xrpl/tx/transactors/dex/OfferCreate.h
@@ -12,7 +12,7 @@ class Sandbox;
 class OfferCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;

    /** Construct a Transactor subclass that creates an offer in the ledger. */
    explicit OfferCreate(ApplyContext& ctx) : Transactor(ctx)
--- a/include/xrpl/tx/transactors/did/DIDDelete.h
+++ b/include/xrpl/tx/transactors/did/DIDDelete.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class DIDDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit DIDDelete(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/did/DIDSet.h
+++ b/include/xrpl/tx/transactors/did/DIDSet.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class DIDSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit DIDSet(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/escrow/EscrowCancel.h
+++ b/include/xrpl/tx/transactors/escrow/EscrowCancel.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowCancel : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit EscrowCancel(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/escrow/EscrowCreate.h
+++ b/include/xrpl/tx/transactors/escrow/EscrowCreate.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowCreate : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Custom};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Custom;

    explicit EscrowCreate(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/escrow/EscrowFinish.h
+++ b/include/xrpl/tx/transactors/escrow/EscrowFinish.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class EscrowFinish : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit EscrowFinish(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h
+++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverClawback : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit LoanBrokerCoverClawback(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h
+++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverDeposit : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit LoanBrokerCoverDeposit(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h
+++ b/include/xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerCoverWithdraw : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit LoanBrokerCoverWithdraw(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h
+++ b/include/xrpl/tx/transactors/lending/LoanBrokerDelete.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LoanBrokerDelete : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType kCONSEQUENCES_FACTORY{Normal};
+    static constexpr auto kCONSEQUENCES_FACTORY = ConsequencesFactoryType::Normal;

    explicit LoanBrokerDelete(ApplyContext& ctx) : Transactor(ctx)
    {
--- a/Show More
+++ b/Show More